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 pubid, Oid newOwnerId)
void	InvalidatePublicationRels (List *relids)
bool	pub_rf_contains_invalid_column (Oid pubid, Relation relation, List *ancestors, bool pubviaroot)
bool	pub_contains_invalid_column (Oid pubid, Relation relation, List *ancestors, bool pubviaroot, char pubgencols_type, bool *invalid_column_list, bool *invalid_gen_col)
void	InvalidatePubRelSyncCache (Oid pubid, bool puballtables)

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 1540 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, RowExclusiveLock, SearchSysCacheCopy1, stmt, table_close(), and table_open().

Referenced by ProcessUtilitySlow().

AlterPublicationOwner()

ObjectAddress AlterPublicationOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 2108 of file publicationcmds.c.

{
    Oid         pubid;
    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);
    pubid = pubform->oid;
 
    AlterPublicationOwner_internal(rel, tup, newOwnerId);
 
    ObjectAddressSet(address, PublicationRelationId, pubid);
 
    heap_freetuple(tup);
 
    table_close(rel, RowExclusiveLock);
 
    return address;
}

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

Referenced by ExecAlterOwnerStmt().

AlterPublicationOwner_oid()

void AlterPublicationOwner_oid	(	Oid	pubid,
		Oid	newOwnerId
	)

Definition at line 2143 of file publicationcmds.c.

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

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

Referenced by shdepReassignOwned_Owner().

CreatePublication()

ObjectAddress CreatePublication	(	ParseState *	pstate,
		CreatePublicationStmt *	stmt
	)

Definition at line 831 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;
    bool        publish_generated_columns_given;
    char        publish_generated_columns;
    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 and FOR ALL SEQUENCES requires superuser */
    if (!superuser())
    {
        if (stmt->for_all_tables || stmt->for_all_sequences)
            ereport(ERROR,
                    errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                    errmsg("must be superuser to create a FOR ALL TABLES or ALL SEQUENCES 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,
                              &publish_generated_columns_given,
                              &publish_generated_columns);
 
    if (stmt->for_all_sequences &&
        (publish_given || publish_via_partition_root_given ||
         publish_generated_columns_given))
        ereport(NOTICE,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("publication parameters are not applicable to sequence synchronization and will be ignored for sequences"));
 
    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_puballsequences - 1] =
        BoolGetDatum(stmt->for_all_sequences);
    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);
    values[Anum_pg_publication_pubgencols - 1] =
        CharGetDatum(publish_generated_columns);
 
    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. Sequences
         * publication doesn't require invalidation, as replica identity
         * checks don't apply to them.
         */
        CacheInvalidateRelcacheAll();
    }
    else if (!stmt->for_all_sequences)
    {
        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);
 
    /*
     * We don't need this warning message when wal_level >= 'replica' since
     * logical decoding is automatically enabled up on a logical slot
     * creation.
     */
    if (wal_level < WAL_LEVEL_REPLICA)
        ereport(WARNING,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("logical decoding must be enabled to publish logical changes"),
                 errhint("Before creating subscriptions, ensure that \"wal_level\" is set to \"replica\" or higher.")));
 
    return myself;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, BoolGetDatum(), CacheInvalidateRelcacheAll(), CatalogTupleInsert(), CharGetDatum(), 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, NOTICE, object_aclcheck(), OBJECT_DATABASE, ObjectAddressSet, ObjectIdGetDatum(), ObjectsInPublicationToOids(), OidIsValid, OpenTableList(), ParseState::p_sourcetext, parse_publication_options(), PublicationActions::pubdelete, PublicationActions::pubinsert, PublicationAddSchemas(), PublicationAddTables(), PublicationActions::pubtruncate, PublicationActions::pubupdate, recordDependencyOnOwner(), RelationGetDescr, RowExclusiveLock, stmt, superuser(), table_close(), table_open(), TransformPubWhereClauses(), values, wal_level, WAL_LEVEL_REPLICA, and WARNING.

Referenced by ProcessUtilitySlow().

InvalidatePublicationRels()

void InvalidatePublicationRels

(

List *

relids

)

Definition at line 1205 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().

InvalidatePubRelSyncCache()

void InvalidatePubRelSyncCache	(	Oid	pubid,
		bool	puballtables
	)

Definition at line 505 of file publicationcmds.c.

{
    if (puballtables)
    {
        CacheInvalidateRelSyncAll();
    }
    else
    {
        List       *relids = NIL;
        List       *schemarelids = NIL;
 
        /*
         * For partitioned tables, we must invalidate all partitions and
         * itself. WAL records for INSERT/UPDATE/DELETE specify leaf tables as
         * a target. However, WAL records for TRUNCATE specify both a root and
         * its leaves.
         */
        relids = GetPublicationRelations(pubid,
                                         PUBLICATION_PART_ALL);
        schemarelids = GetAllSchemaPublicationRelations(pubid,
                                                        PUBLICATION_PART_ALL);
 
        relids = list_concat_unique_oid(relids, schemarelids);
 
        /* Invalidate the relsyncache */
        foreach_oid(relid, relids)
            CacheInvalidateRelSync(relid);
    }
 
    return;
}

References CacheInvalidateRelSync(), CacheInvalidateRelSyncAll(), foreach_oid, GetAllSchemaPublicationRelations(), GetPublicationRelations(), list_concat_unique_oid(), NIL, and PUBLICATION_PART_ALL.

Referenced by AlterObjectRename_internal().

pub_contains_invalid_column()

bool pub_contains_invalid_column	(	Oid	pubid,
		Relation	relation,
		List *	ancestors,
		bool	pubviaroot,
		char	pubgencols_type,
		bool *	invalid_column_list,
		bool *	invalid_gen_col
	)

Definition at line 361 of file publicationcmds.c.

{
    Oid         relid = RelationGetRelid(relation);
    Oid         publish_as_relid = RelationGetRelid(relation);
    Bitmapset  *idattrs;
    Bitmapset  *columns = NULL;
    TupleDesc   desc = RelationGetDescr(relation);
    Publication *pub;
    int         x;
 
    *invalid_column_list = false;
    *invalid_gen_col = false;
 
    /*
     * 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;
    }
 
    /* Fetch the column list */
    pub = GetPublication(pubid);
    check_and_fetch_column_list(pub, publish_as_relid, NULL, &columns);
 
    if (relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
    {
        /* With REPLICA IDENTITY FULL, no column list is allowed. */
        *invalid_column_list = (columns != NULL);
 
        /*
         * As we don't allow a column list with REPLICA IDENTITY FULL, the
         * publish_generated_columns option must be set to stored if the table
         * has any stored generated columns.
         */
        if (pubgencols_type != PUBLISH_GENCOLS_STORED &&
            relation->rd_att->constr &&
            relation->rd_att->constr->has_generated_stored)
            *invalid_gen_col = true;
 
        /*
         * Virtual generated columns are currently not supported for logical
         * replication at all.
         */
        if (relation->rd_att->constr &&
            relation->rd_att->constr->has_generated_virtual)
            *invalid_gen_col = true;
 
        if (*invalid_gen_col && *invalid_column_list)
            return true;
    }
 
    /* 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);
        Form_pg_attribute att = TupleDescAttr(desc, attnum - 1);
 
        if (columns == NULL)
        {
            /*
             * The publish_generated_columns option must be set to stored if
             * the REPLICA IDENTITY contains any stored generated column.
             */
            if (att->attgenerated == ATTRIBUTE_GENERATED_STORED && pubgencols_type != PUBLISH_GENCOLS_STORED)
            {
                *invalid_gen_col = true;
                break;
            }
 
            /*
             * The equivalent setting for virtual generated columns does not
             * exist yet.
             */
            if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
            {
                *invalid_gen_col = true;
                break;
            }
 
            /* Skip validating the column list since it is not defined */
            continue;
        }
 
        /*
         * 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 */
        *invalid_column_list |= !bms_is_member(attnum, columns);
 
        if (*invalid_column_list && *invalid_gen_col)
            break;
    }
 
    bms_free(columns);
    bms_free(idattrs);
 
    return *invalid_column_list || *invalid_gen_col;
}

References attnum, bms_free(), bms_is_member(), bms_next_member(), check_and_fetch_column_list(), TupleDescData::constr, FirstLowInvalidHeapAttributeNumber, get_attname(), get_attnum(), GetPublication(), GetTopMostAncestorInPublication(), TupleConstr::has_generated_stored, TupleConstr::has_generated_virtual, INDEX_ATTR_BITMAP_IDENTITY_KEY, OidIsValid, RelationData::rd_att, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationGetRelid, TupleDescAttr(), 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 275 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, 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 1651 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(), ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

RemovePublicationRelById()

void RemovePublicationRelById

(

Oid

proid

)

Definition at line 1610 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, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

RemovePublicationSchemaById()

void RemovePublicationSchemaById

(

Oid

psoid

)

Definition at line 1680 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, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().