publicationcmds.h File Reference

#include "catalog/objectaddress.h"
#include "parser/parse_node.h"
#include "utils/inval.h"

Include dependency graph for publicationcmds.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MAX_RELCACHE_INVAL_MSGS   4096

Functions
ObjectAddress	CreatePublication (ParseState *pstate, CreatePublicationStmt *stmt)
void	AlterPublication (ParseState *pstate, AlterPublicationStmt *stmt)
void	RemovePublicationById (Oid pubid)
void	RemovePublicationRelById (Oid proid)
void	RemovePublicationSchemaById (Oid psoid)
ObjectAddress	AlterPublicationOwner (const char *name, Oid newOwnerId)
void	AlterPublicationOwner_oid (Oid subid, Oid newOwnerId)
void	InvalidatePublicationRels (List *relids)
bool	pub_rf_contains_invalid_column (Oid pubid, Relation relation, List *ancestors, bool pubviaroot)
bool	pub_collist_contains_invalid_column (Oid pubid, Relation relation, List *ancestors, bool pubviaroot)

Macro Definition Documentation

MAX_RELCACHE_INVAL_MSGS

#define MAX_RELCACHE_INVAL_MSGS   4096

Definition at line 23 of file publicationcmds.h.

Function Documentation

AlterPublication()

void AlterPublication	(	ParseState *	pstate,
		AlterPublicationStmt *	stmt
	)

Definition at line 1378 of file publicationcmds.c.

{
    Relation    rel;
    HeapTuple   tup;
    Form_pg_publication pubform;
 
    rel = table_open(PublicationRelationId, RowExclusiveLock);
 
    tup = SearchSysCacheCopy1(PUBLICATIONNAME,
                              CStringGetDatum(stmt->pubname));
 
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication \"%s\" does not exist",
                        stmt->pubname)));
 
    pubform = (Form_pg_publication) GETSTRUCT(tup);
 
    /* must be owner */
    if (!object_ownercheck(PublicationRelationId, pubform->oid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
                       stmt->pubname);
 
    if (stmt->options)
        AlterPublicationOptions(pstate, stmt, rel, tup);
    else
    {
        List       *relations = NIL;
        List       *schemaidlist = NIL;
        Oid         pubid = pubform->oid;
 
        ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
                                   &schemaidlist);
 
        CheckAlterPublication(stmt, tup, relations, schemaidlist);
 
        heap_freetuple(tup);
 
        /* Lock the publication so nobody else can do anything with it. */
        LockDatabaseObject(PublicationRelationId, pubid, 0,
                           AccessExclusiveLock);
 
        /*
         * It is possible that by the time we acquire the lock on publication,
         * concurrent DDL has removed it. We can test this by checking the
         * existence of publication. We get the tuple again to avoid the risk
         * of any publication option getting changed.
         */
        tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
        if (!HeapTupleIsValid(tup))
            ereport(ERROR,
                    errcode(ERRCODE_UNDEFINED_OBJECT),
                    errmsg("publication \"%s\" does not exist",
                           stmt->pubname));
 
        AlterPublicationTables(stmt, tup, relations, pstate->p_sourcetext,
                               schemaidlist != NIL);
        AlterPublicationSchemas(stmt, tup, schemaidlist);
    }
 
    /* Cleanup. */
    heap_freetuple(tup);
    table_close(rel, RowExclusiveLock);
}

References AccessExclusiveLock, aclcheck_error(), ACLCHECK_NOT_OWNER, AlterPublicationOptions(), AlterPublicationSchemas(), AlterPublicationTables(), CheckAlterPublication(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetUserId(), heap_freetuple(), HeapTupleIsValid, LockDatabaseObject(), NIL, object_ownercheck(), OBJECT_PUBLICATION, ObjectIdGetDatum(), ObjectsInPublicationToOids(), ParseState::p_sourcetext, PUBLICATIONNAME, PUBLICATIONOID, RowExclusiveLock, SearchSysCacheCopy1, stmt, table_close(), and table_open().

Referenced by ProcessUtilitySlow().

AlterPublicationOwner()

ObjectAddress AlterPublicationOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 1953 of file publicationcmds.c.

{
    Oid         subid;
    HeapTuple   tup;
    Relation    rel;
    ObjectAddress address;
    Form_pg_publication pubform;
 
    rel = table_open(PublicationRelationId, RowExclusiveLock);
 
    tup = SearchSysCacheCopy1(PUBLICATIONNAME, CStringGetDatum(name));
 
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication \"%s\" does not exist", name)));
 
    pubform = (Form_pg_publication) GETSTRUCT(tup);
    subid = pubform->oid;
 
    AlterPublicationOwner_internal(rel, tup, newOwnerId);
 
    ObjectAddressSet(address, PublicationRelationId, subid);
 
    heap_freetuple(tup);
 
    table_close(rel, RowExclusiveLock);
 
    return address;
}

References AlterPublicationOwner_internal(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, name, ObjectAddressSet, PUBLICATIONNAME, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

AlterPublicationOwner_oid()

void AlterPublicationOwner_oid	(	Oid	subid,
		Oid	newOwnerId
	)

Definition at line 1988 of file publicationcmds.c.

{
    HeapTuple   tup;
    Relation    rel;
 
    rel = table_open(PublicationRelationId, RowExclusiveLock);
 
    tup = SearchSysCacheCopy1(PUBLICATIONOID, ObjectIdGetDatum(subid));
 
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication with OID %u does not exist", subid)));
 
    AlterPublicationOwner_internal(rel, tup, newOwnerId);
 
    heap_freetuple(tup);
 
    table_close(rel, RowExclusiveLock);
}

References AlterPublicationOwner_internal(), ereport, errcode(), errmsg(), ERROR, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), PUBLICATIONOID, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned().

CreatePublication()

ObjectAddress CreatePublication	(	ParseState *	pstate,
		CreatePublicationStmt *	stmt
	)

Definition at line 735 of file publicationcmds.c.

{
    Relation    rel;
    ObjectAddress myself;
    Oid         puboid;
    bool        nulls[Natts_pg_publication];
    Datum       values[Natts_pg_publication];
    HeapTuple   tup;
    bool        publish_given;
    PublicationActions pubactions;
    bool        publish_via_partition_root_given;
    bool        publish_via_partition_root;
    AclResult   aclresult;
    List       *relations = NIL;
    List       *schemaidlist = NIL;
 
    /* must have CREATE privilege on database */
    aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_DATABASE,
                       get_database_name(MyDatabaseId));
 
    /* FOR ALL TABLES requires superuser */
    if (stmt->for_all_tables && !superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to create FOR ALL TABLES publication")));
 
    rel = table_open(PublicationRelationId, RowExclusiveLock);
 
    /* Check if name is used */
    puboid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
                             CStringGetDatum(stmt->pubname));
    if (OidIsValid(puboid))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("publication \"%s\" already exists",
                        stmt->pubname)));
 
    /* Form a tuple. */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));
 
    values[Anum_pg_publication_pubname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->pubname));
    values[Anum_pg_publication_pubowner - 1] = ObjectIdGetDatum(GetUserId());
 
    parse_publication_options(pstate,
                              stmt->options,
                              &publish_given, &pubactions,
                              &publish_via_partition_root_given,
                              &publish_via_partition_root);
 
    puboid = GetNewOidWithIndex(rel, PublicationObjectIndexId,
                                Anum_pg_publication_oid);
    values[Anum_pg_publication_oid - 1] = ObjectIdGetDatum(puboid);
    values[Anum_pg_publication_puballtables - 1] =
        BoolGetDatum(stmt->for_all_tables);
    values[Anum_pg_publication_pubinsert - 1] =
        BoolGetDatum(pubactions.pubinsert);
    values[Anum_pg_publication_pubupdate - 1] =
        BoolGetDatum(pubactions.pubupdate);
    values[Anum_pg_publication_pubdelete - 1] =
        BoolGetDatum(pubactions.pubdelete);
    values[Anum_pg_publication_pubtruncate - 1] =
        BoolGetDatum(pubactions.pubtruncate);
    values[Anum_pg_publication_pubviaroot - 1] =
        BoolGetDatum(publish_via_partition_root);
 
    tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
    /* Insert tuple into catalog. */
    CatalogTupleInsert(rel, tup);
    heap_freetuple(tup);
 
    recordDependencyOnOwner(PublicationRelationId, puboid, GetUserId());
 
    ObjectAddressSet(myself, PublicationRelationId, puboid);
 
    /* Make the changes visible. */
    CommandCounterIncrement();
 
    /* Associate objects with the publication. */
    if (stmt->for_all_tables)
    {
        /* Invalidate relcache so that publication info is rebuilt. */
        CacheInvalidateRelcacheAll();
    }
    else
    {
        ObjectsInPublicationToOids(stmt->pubobjects, pstate, &relations,
                                   &schemaidlist);
 
        /* FOR TABLES IN SCHEMA requires superuser */
        if (schemaidlist != NIL && !superuser())
            ereport(ERROR,
                    errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                    errmsg("must be superuser to create FOR TABLES IN SCHEMA publication"));
 
        if (relations != NIL)
        {
            List       *rels;
 
            rels = OpenTableList(relations);
            TransformPubWhereClauses(rels, pstate->p_sourcetext,
                                     publish_via_partition_root);
 
            CheckPubRelationColumnList(stmt->pubname, rels,
                                       schemaidlist != NIL,
                                       publish_via_partition_root);
 
            PublicationAddTables(puboid, rels, true, NULL);
            CloseTableList(rels);
        }
 
        if (schemaidlist != NIL)
        {
            /*
             * Schema lock is held until the publication is created to prevent
             * concurrent schema deletion.
             */
            LockSchemaList(schemaidlist);
            PublicationAddSchemas(puboid, schemaidlist, true, NULL);
        }
    }
 
    table_close(rel, RowExclusiveLock);
 
    InvokeObjectPostCreateHook(PublicationRelationId, puboid, 0);
 
    if (wal_level != WAL_LEVEL_LOGICAL)
        ereport(WARNING,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("wal_level is insufficient to publish logical changes"),
                 errhint("Set wal_level to \"logical\" before creating subscriptions.")));
 
    return myself;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, BoolGetDatum(), CacheInvalidateRelcacheAll(), CatalogTupleInsert(), CheckPubRelationColumnList(), CloseTableList(), CommandCounterIncrement(), CStringGetDatum(), DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, get_database_name(), GetNewOidWithIndex(), GetSysCacheOid1, GetUserId(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, LockSchemaList(), MyDatabaseId, namein(), NIL, object_aclcheck(), OBJECT_DATABASE, ObjectAddressSet, ObjectIdGetDatum(), ObjectsInPublicationToOids(), OidIsValid, OpenTableList(), ParseState::p_sourcetext, parse_publication_options(), PublicationActions::pubdelete, PublicationActions::pubinsert, PublicationAddSchemas(), PublicationAddTables(), PUBLICATIONNAME, PublicationActions::pubtruncate, PublicationActions::pubupdate, recordDependencyOnOwner(), RelationGetDescr, RowExclusiveLock, stmt, superuser(), table_close(), table_open(), TransformPubWhereClauses(), values, wal_level, WAL_LEVEL_LOGICAL, and WARNING.

Referenced by ProcessUtilitySlow().

InvalidatePublicationRels()

void InvalidatePublicationRels

(

List *

relids

)

Definition at line 1065 of file publicationcmds.c.

{
    /*
     * We don't want to send too many individual messages, at some point it's
     * cheaper to just reset whole relcache.
     */
    if (list_length(relids) < MAX_RELCACHE_INVAL_MSGS)
    {
        ListCell   *lc;
 
        foreach(lc, relids)
            CacheInvalidateRelcacheByRelid(lfirst_oid(lc));
    }
    else
        CacheInvalidateRelcacheAll();
}

References CacheInvalidateRelcacheAll(), CacheInvalidateRelcacheByRelid(), lfirst_oid, list_length(), and MAX_RELCACHE_INVAL_MSGS.

Referenced by AlterPublicationOptions(), publication_add_relation(), publication_add_schema(), RemovePublicationRelById(), and RemovePublicationSchemaById().

pub_collist_contains_invalid_column()

bool pub_collist_contains_invalid_column	(	Oid	pubid,
		Relation	relation,
		List *	ancestors,
		bool	pubviaroot
	)

Definition at line 341 of file publicationcmds.c.

{
    HeapTuple   tuple;
    Oid         relid = RelationGetRelid(relation);
    Oid         publish_as_relid = RelationGetRelid(relation);
    bool        result = false;
    Datum       datum;
    bool        isnull;
 
    /*
     * For a partition, if pubviaroot is true, find the topmost ancestor that
     * is published via this publication as we need to use its column list for
     * the changes.
     *
     * Note that even though the column list used is for an ancestor, the
     * REPLICA IDENTITY used will be for the actual child table.
     */
    if (pubviaroot && relation->rd_rel->relispartition)
    {
        publish_as_relid = GetTopMostAncestorInPublication(pubid, ancestors, NULL);
 
        if (!OidIsValid(publish_as_relid))
            publish_as_relid = relid;
    }
 
    tuple = SearchSysCache2(PUBLICATIONRELMAP,
                            ObjectIdGetDatum(publish_as_relid),
                            ObjectIdGetDatum(pubid));
 
    if (!HeapTupleIsValid(tuple))
        return false;
 
    datum = SysCacheGetAttr(PUBLICATIONRELMAP, tuple,
                            Anum_pg_publication_rel_prattrs,
                            &isnull);
 
    if (!isnull)
    {
        int         x;
        Bitmapset  *idattrs;
        Bitmapset  *columns = NULL;
 
        /* With REPLICA IDENTITY FULL, no column list is allowed. */
        if (relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
            result = true;
 
        /* Transform the column list datum to a bitmapset. */
        columns = pub_collist_to_bitmapset(NULL, datum, NULL);
 
        /* Remember columns that are part of the REPLICA IDENTITY */
        idattrs = RelationGetIndexAttrBitmap(relation,
                                             INDEX_ATTR_BITMAP_IDENTITY_KEY);
 
        /*
         * Attnums in the bitmap returned by RelationGetIndexAttrBitmap are
         * offset (to handle system columns the usual way), while column list
         * does not use offset, so we can't do bms_is_subset(). Instead, we
         * have to loop over the idattrs and check all of them are in the
         * list.
         */
        x = -1;
        while ((x = bms_next_member(idattrs, x)) >= 0)
        {
            AttrNumber  attnum = (x + FirstLowInvalidHeapAttributeNumber);
 
            /*
             * If pubviaroot is true, we are validating the column list of the
             * parent table, but the bitmap contains the replica identity
             * information of the child table. The parent/child attnums may
             * not match, so translate them to the parent - get the attname
             * from the child, and look it up in the parent.
             */
            if (pubviaroot)
            {
                /* attribute name in the child table */
                char       *colname = get_attname(relid, attnum, false);
 
                /*
                 * Determine the attnum for the attribute name in parent (we
                 * are using the column list defined on the parent).
                 */
                attnum = get_attnum(publish_as_relid, colname);
            }
 
            /* replica identity column, not covered by the column list */
            if (!bms_is_member(attnum, columns))
            {
                result = true;
                break;
            }
        }
 
        bms_free(idattrs);
        bms_free(columns);
    }
 
    ReleaseSysCache(tuple);
 
    return result;
}

References attnum, bms_free(), bms_is_member(), bms_next_member(), FirstLowInvalidHeapAttributeNumber, get_attname(), get_attnum(), GetTopMostAncestorInPublication(), HeapTupleIsValid, INDEX_ATTR_BITMAP_IDENTITY_KEY, ObjectIdGetDatum(), OidIsValid, pub_collist_to_bitmapset(), PUBLICATIONRELMAP, RelationData::rd_rel, RelationGetIndexAttrBitmap(), RelationGetRelid, ReleaseSysCache(), SearchSysCache2(), SysCacheGetAttr(), and x.

Referenced by RelationBuildPublicationDesc().

pub_rf_contains_invalid_column()

bool pub_rf_contains_invalid_column	(	Oid	pubid,
		Relation	relation,
		List *	ancestors,
		bool	pubviaroot
	)

Definition at line 265 of file publicationcmds.c.

{
    HeapTuple   rftuple;
    Oid         relid = RelationGetRelid(relation);
    Oid         publish_as_relid = RelationGetRelid(relation);
    bool        result = false;
    Datum       rfdatum;
    bool        rfisnull;
 
    /*
     * FULL means all columns are in the REPLICA IDENTITY, so all columns are
     * allowed in the row filter and we can skip the validation.
     */
    if (relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
        return false;
 
    /*
     * For a partition, if pubviaroot is true, find the topmost ancestor that
     * is published via this publication as we need to use its row filter
     * expression to filter the partition's changes.
     *
     * Note that even though the row filter used is for an ancestor, the
     * REPLICA IDENTITY used will be for the actual child table.
     */
    if (pubviaroot && relation->rd_rel->relispartition)
    {
        publish_as_relid
            = GetTopMostAncestorInPublication(pubid, ancestors, NULL);
 
        if (!OidIsValid(publish_as_relid))
            publish_as_relid = relid;
    }
 
    rftuple = SearchSysCache2(PUBLICATIONRELMAP,
                              ObjectIdGetDatum(publish_as_relid),
                              ObjectIdGetDatum(pubid));
 
    if (!HeapTupleIsValid(rftuple))
        return false;
 
    rfdatum = SysCacheGetAttr(PUBLICATIONRELMAP, rftuple,
                              Anum_pg_publication_rel_prqual,
                              &rfisnull);
 
    if (!rfisnull)
    {
        rf_context  context = {0};
        Node       *rfnode;
        Bitmapset  *bms = NULL;
 
        context.pubviaroot = pubviaroot;
        context.parentid = publish_as_relid;
        context.relid = relid;
 
        /* Remember columns that are part of the REPLICA IDENTITY */
        bms = RelationGetIndexAttrBitmap(relation,
                                         INDEX_ATTR_BITMAP_IDENTITY_KEY);
 
        context.bms_replident = bms;
        rfnode = stringToNode(TextDatumGetCString(rfdatum));
        result = contain_invalid_rfcolumn_walker(rfnode, &context);
    }
 
    ReleaseSysCache(rftuple);
 
    return result;
}

References rf_context::bms_replident, contain_invalid_rfcolumn_walker(), GetTopMostAncestorInPublication(), HeapTupleIsValid, INDEX_ATTR_BITMAP_IDENTITY_KEY, ObjectIdGetDatum(), OidIsValid, rf_context::parentid, PUBLICATIONRELMAP, rf_context::pubviaroot, RelationData::rd_rel, RelationGetIndexAttrBitmap(), RelationGetRelid, ReleaseSysCache(), rf_context::relid, SearchSysCache2(), stringToNode(), SysCacheGetAttr(), and TextDatumGetCString.

Referenced by RelationBuildPublicationDesc().

RemovePublicationById()

void RemovePublicationById

(

Oid

pubid

)

Definition at line 1489 of file publicationcmds.c.

{
    Relation    rel;
    HeapTuple   tup;
    Form_pg_publication pubform;
 
    rel = table_open(PublicationRelationId, RowExclusiveLock);
 
    tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for publication %u", pubid);
 
    pubform = (Form_pg_publication) GETSTRUCT(tup);
 
    /* Invalidate relcache so that publication info is rebuilt. */
    if (pubform->puballtables)
        CacheInvalidateRelcacheAll();
 
    CatalogTupleDelete(rel, &tup->t_self);
 
    ReleaseSysCache(tup);
 
    table_close(rel, RowExclusiveLock);
}

References CacheInvalidateRelcacheAll(), CatalogTupleDelete(), elog(), ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), PUBLICATIONOID, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

RemovePublicationRelById()

void RemovePublicationRelById

(

Oid

proid

)

Definition at line 1448 of file publicationcmds.c.

{
    Relation    rel;
    HeapTuple   tup;
    Form_pg_publication_rel pubrel;
    List       *relids = NIL;
 
    rel = table_open(PublicationRelRelationId, RowExclusiveLock);
 
    tup = SearchSysCache1(PUBLICATIONREL, ObjectIdGetDatum(proid));
 
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for publication table %u",
             proid);
 
    pubrel = (Form_pg_publication_rel) GETSTRUCT(tup);
 
    /*
     * Invalidate relcache so that publication info is rebuilt.
     *
     * For the partitioned tables, we must invalidate all partitions contained
     * in the respective partition hierarchies, not just the one explicitly
     * mentioned in the publication. This is required because we implicitly
     * publish the child tables when the parent table is published.
     */
    relids = GetPubPartitionOptionRelations(relids, PUBLICATION_PART_ALL,
                                            pubrel->prrelid);
 
    InvalidatePublicationRels(relids);
 
    CatalogTupleDelete(rel, &tup->t_self);
 
    ReleaseSysCache(tup);
 
    table_close(rel, RowExclusiveLock);
}

References CatalogTupleDelete(), elog(), ERROR, GetPubPartitionOptionRelations(), GETSTRUCT, HeapTupleIsValid, InvalidatePublicationRels(), NIL, ObjectIdGetDatum(), PUBLICATION_PART_ALL, PUBLICATIONREL, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

RemovePublicationSchemaById()

void RemovePublicationSchemaById

(

Oid

psoid

)

Definition at line 1518 of file publicationcmds.c.

{
    Relation    rel;
    HeapTuple   tup;
    List       *schemaRels = NIL;
    Form_pg_publication_namespace pubsch;
 
    rel = table_open(PublicationNamespaceRelationId, RowExclusiveLock);
 
    tup = SearchSysCache1(PUBLICATIONNAMESPACE, ObjectIdGetDatum(psoid));
 
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for publication schema %u", psoid);
 
    pubsch = (Form_pg_publication_namespace) GETSTRUCT(tup);
 
    /*
     * Invalidate relcache so that publication info is rebuilt. See
     * RemovePublicationRelById for why we need to consider all the
     * partitions.
     */
    schemaRels = GetSchemaPublicationRelations(pubsch->pnnspid,
                                               PUBLICATION_PART_ALL);
    InvalidatePublicationRels(schemaRels);
 
    CatalogTupleDelete(rel, &tup->t_self);
 
    ReleaseSysCache(tup);
 
    table_close(rel, RowExclusiveLock);
}

References CatalogTupleDelete(), elog(), ERROR, GetSchemaPublicationRelations(), GETSTRUCT, HeapTupleIsValid, InvalidatePublicationRels(), NIL, ObjectIdGetDatum(), PUBLICATION_PART_ALL, PUBLICATIONNAMESPACE, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().