PostgreSQL Source Code  git master
pg_publication.c File Reference
#include "postgres.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/partition.h"
#include "catalog/objectaccess.h"
#include "catalog/objectaddress.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_publication_namespace.h"
#include "catalog/pg_publication_rel.h"
#include "catalog/pg_type.h"
#include "commands/publicationcmds.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
Include dependency graph for pg_publication.c:

Go to the source code of this file.

Macros

#define NUM_PUBLICATOIN_TABLES_ELEM   3
 

Functions

static void publication_translate_columns (Relation targetrel, List *columns, int *natts, AttrNumber **attrs)
 
static void check_publication_add_relation (Relation targetrel)
 
static void check_publication_add_schema (Oid schemaid)
 
static bool is_publishable_class (Oid relid, Form_pg_class reltuple)
 
static Listfilter_partitions (List *relids)
 
bool is_publishable_relation (Relation rel)
 
bool is_schema_publication (Oid pubid)
 
Datum pg_relation_is_publishable (PG_FUNCTION_ARGS)
 
ListGetPubPartitionOptionRelations (List *result, PublicationPartOpt pub_partopt, Oid relid)
 
Oid GetTopMostAncestorInPublication (Oid puboid, List *ancestors, int *ancestor_level)
 
ObjectAddress publication_add_relation (Oid pubid, PublicationRelInfo *pri, bool if_not_exists)
 
static int compare_int16 (const void *a, const void *b)
 
Bitmapsetpub_collist_to_bitmapset (Bitmapset *columns, Datum pubcols, MemoryContext mcxt)
 
ObjectAddress publication_add_schema (Oid pubid, Oid schemaid, bool if_not_exists)
 
ListGetRelationPublications (Oid relid)
 
ListGetPublicationRelations (Oid pubid, PublicationPartOpt pub_partopt)
 
ListGetAllTablesPublications (void)
 
ListGetAllTablesPublicationRelations (bool pubviaroot)
 
ListGetPublicationSchemas (Oid pubid)
 
ListGetSchemaPublications (Oid schemaid)
 
ListGetSchemaPublicationRelations (Oid schemaid, PublicationPartOpt pub_partopt)
 
ListGetAllSchemaPublicationRelations (Oid pubid, PublicationPartOpt pub_partopt)
 
PublicationGetPublication (Oid pubid)
 
PublicationGetPublicationByName (const char *pubname, bool missing_ok)
 
Oid get_publication_oid (const char *pubname, bool missing_ok)
 
char * get_publication_name (Oid pubid, bool missing_ok)
 
Datum pg_get_publication_tables (PG_FUNCTION_ARGS)
 

Macro Definition Documentation

◆ NUM_PUBLICATOIN_TABLES_ELEM

#define NUM_PUBLICATOIN_TABLES_ELEM   3

Function Documentation

◆ check_publication_add_relation()

static void check_publication_add_relation ( Relation  targetrel)
static

Definition at line 56 of file pg_publication.c.

57 {
58  /* Must be a regular or partitioned table */
59  if (RelationGetForm(targetrel)->relkind != RELKIND_RELATION &&
60  RelationGetForm(targetrel)->relkind != RELKIND_PARTITIONED_TABLE)
61  ereport(ERROR,
62  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
63  errmsg("cannot add relation \"%s\" to publication",
64  RelationGetRelationName(targetrel)),
65  errdetail_relkind_not_supported(RelationGetForm(targetrel)->relkind)));
66 
67  /* Can't be system table */
68  if (IsCatalogRelation(targetrel))
69  ereport(ERROR,
70  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
71  errmsg("cannot add relation \"%s\" to publication",
72  RelationGetRelationName(targetrel)),
73  errdetail("This operation is not supported for system tables.")));
74 
75  /* UNLOGGED and TEMP relations cannot be part of publication. */
76  if (targetrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
77  ereport(ERROR,
78  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
79  errmsg("cannot add relation \"%s\" to publication",
80  RelationGetRelationName(targetrel)),
81  errdetail("This operation is not supported for temporary tables.")));
82  else if (targetrel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
83  ereport(ERROR,
84  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
85  errmsg("cannot add relation \"%s\" to publication",
86  RelationGetRelationName(targetrel)),
87  errdetail("This operation is not supported for unlogged tables.")));
88 }
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:105
int errdetail(const char *fmt,...)
Definition: elog.c:1037
int errcode(int sqlerrcode)
Definition: elog.c:693
int errmsg(const char *fmt,...)
Definition: elog.c:904
#define ERROR
Definition: elog.h:33
#define ereport(elevel,...)
Definition: elog.h:143
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
#define RelationGetForm(relation)
Definition: rel.h:483
#define RelationGetRelationName(relation)
Definition: rel.h:523
Form_pg_class rd_rel
Definition: rel.h:109

References ereport, errcode(), errdetail(), errdetail_relkind_not_supported(), errmsg(), ERROR, IsCatalogRelation(), RelationData::rd_rel, RelationGetForm, and RelationGetRelationName.

Referenced by publication_add_relation().

◆ check_publication_add_schema()

static void check_publication_add_schema ( Oid  schemaid)
static

Definition at line 95 of file pg_publication.c.

96 {
97  /* Can't be system namespace */
98  if (IsCatalogNamespace(schemaid) || IsToastNamespace(schemaid))
99  ereport(ERROR,
100  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
101  errmsg("cannot add schema \"%s\" to publication",
102  get_namespace_name(schemaid)),
103  errdetail("This operation is not supported for system schemas.")));
104 
105  /* Can't be temporary namespace */
106  if (isAnyTempNamespace(schemaid))
107  ereport(ERROR,
108  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
109  errmsg("cannot add schema \"%s\" to publication",
110  get_namespace_name(schemaid)),
111  errdetail("Temporary schemas cannot be replicated.")));
112 }
bool IsToastNamespace(Oid namespaceId)
Definition: catalog.c:202
bool IsCatalogNamespace(Oid namespaceId)
Definition: catalog.c:184
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3326
bool isAnyTempNamespace(Oid namespaceId)
Definition: namespace.c:3241

References ereport, errcode(), errdetail(), errmsg(), ERROR, get_namespace_name(), isAnyTempNamespace(), IsCatalogNamespace(), and IsToastNamespace().

Referenced by publication_add_schema().

◆ compare_int16()

static int compare_int16 ( const void *  a,
const void *  b 
)
static

Definition at line 463 of file pg_publication.c.

464 {
465  int av = *(const int16 *) a;
466  int bv = *(const int16 *) b;
467 
468  /* this can't overflow if int is wider than int16 */
469  return (av - bv);
470 }
signed short int16
Definition: c.h:428
int b
Definition: isn.c:70
int a
Definition: isn.c:69
struct @10::@11 av[32]

References a, av, and b.

Referenced by publication_translate_columns().

◆ filter_partitions()

static List* filter_partitions ( List relids)
static

Definition at line 148 of file pg_publication.c.

149 {
150  List *result = NIL;
151  ListCell *lc;
152  ListCell *lc2;
153 
154  foreach(lc, relids)
155  {
156  bool skip = false;
157  List *ancestors = NIL;
158  Oid relid = lfirst_oid(lc);
159 
160  if (get_rel_relispartition(relid))
161  ancestors = get_partition_ancestors(relid);
162 
163  foreach(lc2, ancestors)
164  {
165  Oid ancestor = lfirst_oid(lc2);
166 
167  /* Check if the parent table exists in the published table list. */
168  if (list_member_oid(relids, ancestor))
169  {
170  skip = true;
171  break;
172  }
173  }
174 
175  if (!skip)
176  result = lappend_oid(result, relid);
177  }
178 
179  return result;
180 }
List * lappend_oid(List *list, Oid datum)
Definition: list.c:372
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:701
bool get_rel_relispartition(Oid relid)
Definition: lsyscache.c:2008
List * get_partition_ancestors(Oid relid)
Definition: partition.c:133
static const struct exclude_list_item skip[]
Definition: pg_checksums.c:116
#define NIL
Definition: pg_list.h:65
#define lfirst_oid(lc)
Definition: pg_list.h:171
unsigned int Oid
Definition: postgres_ext.h:31
Definition: pg_list.h:51

References get_partition_ancestors(), get_rel_relispartition(), lappend_oid(), lfirst_oid, list_member_oid(), NIL, and skip.

Referenced by pg_get_publication_tables().

◆ get_publication_name()

char* get_publication_name ( Oid  pubid,
bool  missing_ok 
)

Definition at line 1056 of file pg_publication.c.

1057 {
1058  HeapTuple tup;
1059  char *pubname;
1060  Form_pg_publication pubform;
1061 
1063 
1064  if (!HeapTupleIsValid(tup))
1065  {
1066  if (!missing_ok)
1067  elog(ERROR, "cache lookup failed for publication %u", pubid);
1068  return NULL;
1069  }
1070 
1071  pubform = (Form_pg_publication) GETSTRUCT(tup);
1072  pubname = pstrdup(NameStr(pubform->pubname));
1073 
1074  ReleaseSysCache(tup);
1075 
1076  return pubname;
1077 }
#define NameStr(name)
Definition: c.h:681
#define elog(elevel,...)
Definition: elog.h:218
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:649
char * pstrdup(const char *in)
Definition: mcxt.c:1305
FormData_pg_publication * Form_pg_publication
#define ObjectIdGetDatum(X)
Definition: postgres.h:551
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1221
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1173
@ PUBLICATIONOID
Definition: syscache.h:83

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum, pstrdup(), PUBLICATIONOID, ReleaseSysCache(), and SearchSysCache1().

Referenced by AlterTableNamespace(), getObjectDescription(), getObjectIdentityParts(), and getPublicationSchemaInfo().

◆ get_publication_oid()

Oid get_publication_oid ( const char *  pubname,
bool  missing_ok 
)

Definition at line 1036 of file pg_publication.c.

1037 {
1038  Oid oid;
1039 
1040  oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
1041  CStringGetDatum(pubname));
1042  if (!OidIsValid(oid) && !missing_ok)
1043  ereport(ERROR,
1044  (errcode(ERRCODE_UNDEFINED_OBJECT),
1045  errmsg("publication \"%s\" does not exist", pubname)));
1046  return oid;
1047 }
#define OidIsValid(objectId)
Definition: c.h:710
#define CStringGetDatum(X)
Definition: postgres.h:622
@ PUBLICATIONNAME
Definition: syscache.h:80
#define GetSysCacheOid1(cacheId, oidcol, key1)
Definition: syscache.h:197

References CStringGetDatum, ereport, errcode(), errmsg(), ERROR, GetSysCacheOid1, OidIsValid, and PUBLICATIONNAME.

Referenced by get_object_address_unqualified(), and GetPublicationByName().

◆ GetAllSchemaPublicationRelations()

List* GetAllSchemaPublicationRelations ( Oid  pubid,
PublicationPartOpt  pub_partopt 
)

Definition at line 964 of file pg_publication.c.

965 {
966  List *result = NIL;
967  List *pubschemalist = GetPublicationSchemas(pubid);
968  ListCell *cell;
969 
970  foreach(cell, pubschemalist)
971  {
972  Oid schemaid = lfirst_oid(cell);
973  List *schemaRels = NIL;
974 
975  schemaRels = GetSchemaPublicationRelations(schemaid, pub_partopt);
976  result = list_concat(result, schemaRels);
977  }
978 
979  return result;
980 }
List * list_concat(List *list1, const List *list2)
Definition: list.c:540
List * GetPublicationSchemas(Oid pubid)
List * GetSchemaPublicationRelations(Oid schemaid, PublicationPartOpt pub_partopt)

References GetPublicationSchemas(), GetSchemaPublicationRelations(), lfirst_oid, list_concat(), and NIL.

Referenced by AlterPublicationOptions(), and pg_get_publication_tables().

◆ GetAllTablesPublicationRelations()

List* GetAllTablesPublicationRelations ( bool  pubviaroot)

Definition at line 782 of file pg_publication.c.

783 {
784  Relation classRel;
785  ScanKeyData key[1];
786  TableScanDesc scan;
787  HeapTuple tuple;
788  List *result = NIL;
789 
790  classRel = table_open(RelationRelationId, AccessShareLock);
791 
792  ScanKeyInit(&key[0],
793  Anum_pg_class_relkind,
794  BTEqualStrategyNumber, F_CHAREQ,
795  CharGetDatum(RELKIND_RELATION));
796 
797  scan = table_beginscan_catalog(classRel, 1, key);
798 
799  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
800  {
801  Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
802  Oid relid = relForm->oid;
803 
804  if (is_publishable_class(relid, relForm) &&
805  !(relForm->relispartition && pubviaroot))
806  result = lappend_oid(result, relid);
807  }
808 
809  table_endscan(scan);
810 
811  if (pubviaroot)
812  {
813  ScanKeyInit(&key[0],
814  Anum_pg_class_relkind,
815  BTEqualStrategyNumber, F_CHAREQ,
816  CharGetDatum(RELKIND_PARTITIONED_TABLE));
817 
818  scan = table_beginscan_catalog(classRel, 1, key);
819 
820  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
821  {
822  Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
823  Oid relid = relForm->oid;
824 
825  if (is_publishable_class(relid, relForm) &&
826  !relForm->relispartition)
827  result = lappend_oid(result, relid);
828  }
829 
830  table_endscan(scan);
831  }
832 
833  table_close(classRel, AccessShareLock);
834  return result;
835 }
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1296
#define AccessShareLock
Definition: lockdefs.h:36
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
static bool is_publishable_class(Oid relid, Form_pg_class reltuple)
#define CharGetDatum(X)
Definition: postgres.h:460
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
@ ForwardScanDirection
Definition: sdir.h:26
#define BTEqualStrategyNumber
Definition: stratnum.h:31
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:167
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
Definition: tableam.c:112
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:993

References AccessShareLock, BTEqualStrategyNumber, CharGetDatum, ForwardScanDirection, GETSTRUCT, heap_getnext(), is_publishable_class(), sort-test::key, lappend_oid(), NIL, ScanKeyInit(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by pg_get_publication_tables().

◆ GetAllTablesPublications()

List* GetAllTablesPublications ( void  )

Definition at line 741 of file pg_publication.c.

742 {
743  List *result;
744  Relation rel;
745  ScanKeyData scankey;
746  SysScanDesc scan;
747  HeapTuple tup;
748 
749  /* Find all publications that are marked as for all tables. */
750  rel = table_open(PublicationRelationId, AccessShareLock);
751 
752  ScanKeyInit(&scankey,
753  Anum_pg_publication_puballtables,
754  BTEqualStrategyNumber, F_BOOLEQ,
755  BoolGetDatum(true));
756 
757  scan = systable_beginscan(rel, InvalidOid, false,
758  NULL, 1, &scankey);
759 
760  result = NIL;
761  while (HeapTupleIsValid(tup = systable_getnext(scan)))
762  {
763  Oid oid = ((Form_pg_publication) GETSTRUCT(tup))->oid;
764 
765  result = lappend_oid(result, oid);
766  }
767 
768  systable_endscan(scan);
770 
771  return result;
772 }
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:598
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:505
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:386
#define BoolGetDatum(X)
Definition: postgres.h:446
#define InvalidOid
Definition: postgres_ext.h:36

References AccessShareLock, BoolGetDatum, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, InvalidOid, lappend_oid(), NIL, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by RelationBuildPublicationDesc().

◆ GetPublication()

Publication* GetPublication ( Oid  pubid)

Definition at line 988 of file pg_publication.c.

989 {
990  HeapTuple tup;
991  Publication *pub;
992  Form_pg_publication pubform;
993 
995  if (!HeapTupleIsValid(tup))
996  elog(ERROR, "cache lookup failed for publication %u", pubid);
997 
998  pubform = (Form_pg_publication) GETSTRUCT(tup);
999 
1000  pub = (Publication *) palloc(sizeof(Publication));
1001  pub->oid = pubid;
1002  pub->name = pstrdup(NameStr(pubform->pubname));
1003  pub->alltables = pubform->puballtables;
1004  pub->pubactions.pubinsert = pubform->pubinsert;
1005  pub->pubactions.pubupdate = pubform->pubupdate;
1006  pub->pubactions.pubdelete = pubform->pubdelete;
1007  pub->pubactions.pubtruncate = pubform->pubtruncate;
1008  pub->pubviaroot = pubform->pubviaroot;
1009 
1010  ReleaseSysCache(tup);
1011 
1012  return pub;
1013 }
void * palloc(Size size)
Definition: mcxt.c:1068
PublicationActions pubactions

References Publication::alltables, elog, ERROR, GETSTRUCT, HeapTupleIsValid, Publication::name, NameStr, ObjectIdGetDatum, Publication::oid, palloc(), pstrdup(), Publication::pubactions, PublicationActions::pubdelete, PublicationActions::pubinsert, PUBLICATIONOID, PublicationActions::pubtruncate, PublicationActions::pubupdate, Publication::pubviaroot, ReleaseSysCache(), and SearchSysCache1().

Referenced by GetPublicationByName(), publication_add_relation(), and publication_add_schema().

◆ GetPublicationByName()

Publication* GetPublicationByName ( const char *  pubname,
bool  missing_ok 
)

Definition at line 1020 of file pg_publication.c.

1021 {
1022  Oid oid;
1023 
1024  oid = get_publication_oid(pubname, missing_ok);
1025 
1026  return OidIsValid(oid) ? GetPublication(oid) : NULL;
1027 }
Publication * GetPublication(Oid pubid)
Oid get_publication_oid(const char *pubname, bool missing_ok)

References get_publication_oid(), GetPublication(), and OidIsValid.

Referenced by get_object_address_publication_rel(), get_object_address_publication_schema(), LoadPublications(), and pg_get_publication_tables().

◆ GetPublicationRelations()

List* GetPublicationRelations ( Oid  pubid,
PublicationPartOpt  pub_partopt 
)

Definition at line 698 of file pg_publication.c.

699 {
700  List *result;
701  Relation pubrelsrel;
702  ScanKeyData scankey;
703  SysScanDesc scan;
704  HeapTuple tup;
705 
706  /* Find all publications associated with the relation. */
707  pubrelsrel = table_open(PublicationRelRelationId, AccessShareLock);
708 
709  ScanKeyInit(&scankey,
710  Anum_pg_publication_rel_prpubid,
711  BTEqualStrategyNumber, F_OIDEQ,
712  ObjectIdGetDatum(pubid));
713 
714  scan = systable_beginscan(pubrelsrel, PublicationRelPrpubidIndexId,
715  true, NULL, 1, &scankey);
716 
717  result = NIL;
718  while (HeapTupleIsValid(tup = systable_getnext(scan)))
719  {
721 
722  pubrel = (Form_pg_publication_rel) GETSTRUCT(tup);
723  result = GetPubPartitionOptionRelations(result, pub_partopt,
724  pubrel->prrelid);
725  }
726 
727  systable_endscan(scan);
728  table_close(pubrelsrel, AccessShareLock);
729 
730  /* Now sort and de-duplicate the result list */
731  list_sort(result, list_oid_cmp);
732  list_deduplicate_oid(result);
733 
734  return result;
735 }
void list_sort(List *list, list_sort_comparator cmp)
Definition: list.c:1612
void list_deduplicate_oid(List *list)
Definition: list.c:1454
int list_oid_cmp(const ListCell *p1, const ListCell *p2)
Definition: list.c:1645
List * GetPubPartitionOptionRelations(List *result, PublicationPartOpt pub_partopt, Oid relid)
FormData_pg_publication_rel * Form_pg_publication_rel

References AccessShareLock, BTEqualStrategyNumber, GetPubPartitionOptionRelations(), GETSTRUCT, HeapTupleIsValid, list_deduplicate_oid(), list_oid_cmp(), list_sort(), NIL, ObjectIdGetDatum, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterPublicationOptions(), AlterPublicationSchemas(), AlterPublicationTables(), and pg_get_publication_tables().

◆ GetPublicationSchemas()

List* GetPublicationSchemas ( Oid  pubid)

Definition at line 843 of file pg_publication.c.

844 {
845  List *result = NIL;
846  Relation pubschsrel;
847  ScanKeyData scankey;
848  SysScanDesc scan;
849  HeapTuple tup;
850 
851  /* Find all schemas associated with the publication */
852  pubschsrel = table_open(PublicationNamespaceRelationId, AccessShareLock);
853 
854  ScanKeyInit(&scankey,
855  Anum_pg_publication_namespace_pnpubid,
856  BTEqualStrategyNumber, F_OIDEQ,
857  ObjectIdGetDatum(pubid));
858 
859  scan = systable_beginscan(pubschsrel,
860  PublicationNamespacePnnspidPnpubidIndexId,
861  true, NULL, 1, &scankey);
862  while (HeapTupleIsValid(tup = systable_getnext(scan)))
863  {
865 
867 
868  result = lappend_oid(result, pubsch->pnnspid);
869  }
870 
871  systable_endscan(scan);
872  table_close(pubschsrel, AccessShareLock);
873 
874  return result;
875 }
FormData_pg_publication_namespace * Form_pg_publication_namespace

References AccessShareLock, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, lappend_oid(), NIL, ObjectIdGetDatum, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterPublicationSchemas(), AlterPublicationTables(), and GetAllSchemaPublicationRelations().

◆ GetPubPartitionOptionRelations()

List* GetPubPartitionOptionRelations ( List result,
PublicationPartOpt  pub_partopt,
Oid  relid 
)

Definition at line 249 of file pg_publication.c.

251 {
252  if (get_rel_relkind(relid) == RELKIND_PARTITIONED_TABLE &&
253  pub_partopt != PUBLICATION_PART_ROOT)
254  {
255  List *all_parts = find_all_inheritors(relid, NoLock,
256  NULL);
257 
258  if (pub_partopt == PUBLICATION_PART_ALL)
259  result = list_concat(result, all_parts);
260  else if (pub_partopt == PUBLICATION_PART_LEAF)
261  {
262  ListCell *lc;
263 
264  foreach(lc, all_parts)
265  {
266  Oid partOid = lfirst_oid(lc);
267 
268  if (get_rel_relkind(partOid) != RELKIND_PARTITIONED_TABLE)
269  result = lappend_oid(result, partOid);
270  }
271  }
272  else
273  Assert(false);
274  }
275  else
276  result = lappend_oid(result, relid);
277 
278  return result;
279 }
Assert(fmt[strlen(fmt) - 1] !='\n')
#define NoLock
Definition: lockdefs.h:34
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:1984
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:256
@ PUBLICATION_PART_LEAF
@ PUBLICATION_PART_ROOT
@ PUBLICATION_PART_ALL

References Assert(), find_all_inheritors(), get_rel_relkind(), lappend_oid(), lfirst_oid, list_concat(), NoLock, PUBLICATION_PART_ALL, PUBLICATION_PART_LEAF, and PUBLICATION_PART_ROOT.

Referenced by AlterPublicationOptions(), GetPublicationRelations(), GetSchemaPublicationRelations(), publication_add_relation(), and RemovePublicationRelById().

◆ GetRelationPublications()

List* GetRelationPublications ( Oid  relid)

Definition at line 669 of file pg_publication.c.

670 {
671  List *result = NIL;
672  CatCList *pubrellist;
673  int i;
674 
675  /* Find all publications associated with the relation. */
677  ObjectIdGetDatum(relid));
678  for (i = 0; i < pubrellist->n_members; i++)
679  {
680  HeapTuple tup = &pubrellist->members[i]->tuple;
681  Oid pubid = ((Form_pg_publication_rel) GETSTRUCT(tup))->prpubid;
682 
683  result = lappend_oid(result, pubid);
684  }
685 
686  ReleaseSysCacheList(pubrellist);
687 
688  return result;
689 }
int i
Definition: isn.c:73
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:178
int n_members
Definition: catcache.h:176
HeapTupleData tuple
Definition: catcache.h:121
@ PUBLICATIONRELMAP
Definition: syscache.h:85
#define ReleaseSysCacheList(x)
Definition: syscache.h:222
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:215

References GETSTRUCT, i, lappend_oid(), catclist::members, catclist::n_members, NIL, ObjectIdGetDatum, PUBLICATIONRELMAP, ReleaseSysCacheList, SearchSysCacheList1, and catctup::tuple.

Referenced by AlterTableNamespace(), ATPrepChangePersistence(), get_rel_sync_entry(), GetTopMostAncestorInPublication(), and RelationBuildPublicationDesc().

◆ GetSchemaPublicationRelations()

List* GetSchemaPublicationRelations ( Oid  schemaid,
PublicationPartOpt  pub_partopt 
)

Definition at line 907 of file pg_publication.c.

908 {
909  Relation classRel;
910  ScanKeyData key[1];
911  TableScanDesc scan;
912  HeapTuple tuple;
913  List *result = NIL;
914 
915  Assert(OidIsValid(schemaid));
916 
917  classRel = table_open(RelationRelationId, AccessShareLock);
918 
919  ScanKeyInit(&key[0],
920  Anum_pg_class_relnamespace,
921  BTEqualStrategyNumber, F_OIDEQ,
922  schemaid);
923 
924  /* get all the relations present in the specified schema */
925  scan = table_beginscan_catalog(classRel, 1, key);
926  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
927  {
928  Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
929  Oid relid = relForm->oid;
930  char relkind;
931 
932  if (!is_publishable_class(relid, relForm))
933  continue;
934 
935  relkind = get_rel_relkind(relid);
936  if (relkind == RELKIND_RELATION)
937  result = lappend_oid(result, relid);
938  else if (relkind == RELKIND_PARTITIONED_TABLE)
939  {
940  List *partitionrels = NIL;
941 
942  /*
943  * It is quite possible that some of the partitions are in a
944  * different schema than the parent table, so we need to get such
945  * partitions separately.
946  */
947  partitionrels = GetPubPartitionOptionRelations(partitionrels,
948  pub_partopt,
949  relForm->oid);
950  result = list_concat_unique_oid(result, partitionrels);
951  }
952  }
953 
954  table_endscan(scan);
955  table_close(classRel, AccessShareLock);
956  return result;
957 }
List * list_concat_unique_oid(List *list1, const List *list2)
Definition: list.c:1428

References AccessShareLock, Assert(), BTEqualStrategyNumber, ForwardScanDirection, get_rel_relkind(), GetPubPartitionOptionRelations(), GETSTRUCT, heap_getnext(), is_publishable_class(), sort-test::key, lappend_oid(), list_concat_unique_oid(), NIL, OidIsValid, ScanKeyInit(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by GetAllSchemaPublicationRelations(), publication_add_schema(), and RemovePublicationSchemaById().

◆ GetSchemaPublications()

List* GetSchemaPublications ( Oid  schemaid)

Definition at line 881 of file pg_publication.c.

882 {
883  List *result = NIL;
884  CatCList *pubschlist;
885  int i;
886 
887  /* Find all publications associated with the schema */
889  ObjectIdGetDatum(schemaid));
890  for (i = 0; i < pubschlist->n_members; i++)
891  {
892  HeapTuple tup = &pubschlist->members[i]->tuple;
893  Oid pubid = ((Form_pg_publication_namespace) GETSTRUCT(tup))->pnpubid;
894 
895  result = lappend_oid(result, pubid);
896  }
897 
898  ReleaseSysCacheList(pubschlist);
899 
900  return result;
901 }
@ PUBLICATIONNAMESPACEMAP
Definition: syscache.h:82

References GETSTRUCT, i, lappend_oid(), catclist::members, catclist::n_members, NIL, ObjectIdGetDatum, PUBLICATIONNAMESPACEMAP, ReleaseSysCacheList, SearchSysCacheList1, and catctup::tuple.

Referenced by AlterTableNamespace(), get_rel_sync_entry(), GetTopMostAncestorInPublication(), and RelationBuildPublicationDesc().

◆ GetTopMostAncestorInPublication()

Oid GetTopMostAncestorInPublication ( Oid  puboid,
List ancestors,
int *  ancestor_level 
)

Definition at line 293 of file pg_publication.c.

294 {
295  ListCell *lc;
296  Oid topmost_relid = InvalidOid;
297  int level = 0;
298 
299  /*
300  * Find the "topmost" ancestor that is in this publication.
301  */
302  foreach(lc, ancestors)
303  {
304  Oid ancestor = lfirst_oid(lc);
305  List *apubids = GetRelationPublications(ancestor);
306  List *aschemaPubids = NIL;
307 
308  level++;
309 
310  if (list_member_oid(apubids, puboid))
311  {
312  topmost_relid = ancestor;
313 
314  if (ancestor_level)
315  *ancestor_level = level;
316  }
317  else
318  {
319  aschemaPubids = GetSchemaPublications(get_rel_namespace(ancestor));
320  if (list_member_oid(aschemaPubids, puboid))
321  {
322  topmost_relid = ancestor;
323 
324  if (ancestor_level)
325  *ancestor_level = level;
326  }
327  }
328 
329  list_free(apubids);
330  list_free(aschemaPubids);
331  }
332 
333  return topmost_relid;
334 }
void list_free(List *list)
Definition: list.c:1505
Oid get_rel_namespace(Oid relid)
Definition: lsyscache.c:1933
List * GetSchemaPublications(Oid schemaid)
List * GetRelationPublications(Oid relid)

References get_rel_namespace(), GetRelationPublications(), GetSchemaPublications(), InvalidOid, lfirst_oid, list_free(), list_member_oid(), and NIL.

Referenced by get_rel_sync_entry(), pub_collist_contains_invalid_column(), and pub_rf_contains_invalid_column().

◆ is_publishable_class()

static bool is_publishable_class ( Oid  relid,
Form_pg_class  reltuple 
)
static

Definition at line 134 of file pg_publication.c.

135 {
136  return (reltuple->relkind == RELKIND_RELATION ||
137  reltuple->relkind == RELKIND_PARTITIONED_TABLE) &&
138  !IsCatalogRelationOid(relid) &&
139  reltuple->relpersistence == RELPERSISTENCE_PERMANENT &&
140  relid >= FirstNormalObjectId;
141 }
bool IsCatalogRelationOid(Oid relid)
Definition: catalog.c:122
#define FirstNormalObjectId
Definition: transam.h:197

References FirstNormalObjectId, and IsCatalogRelationOid().

Referenced by GetAllTablesPublicationRelations(), GetSchemaPublicationRelations(), is_publishable_relation(), and pg_relation_is_publishable().

◆ is_publishable_relation()

bool is_publishable_relation ( Relation  rel)

Definition at line 186 of file pg_publication.c.

187 {
188  return is_publishable_class(RelationGetRelid(rel), rel->rd_rel);
189 }
#define RelationGetRelid(relation)
Definition: rel.h:489

References is_publishable_class(), RelationData::rd_rel, and RelationGetRelid.

Referenced by pgoutput_change(), pgoutput_truncate(), and RelationBuildPublicationDesc().

◆ is_schema_publication()

bool is_schema_publication ( Oid  pubid)

Definition at line 196 of file pg_publication.c.

197 {
198  Relation pubschsrel;
199  ScanKeyData scankey;
200  SysScanDesc scan;
201  HeapTuple tup;
202  bool result = false;
203 
204  pubschsrel = table_open(PublicationNamespaceRelationId, AccessShareLock);
205  ScanKeyInit(&scankey,
206  Anum_pg_publication_namespace_pnpubid,
207  BTEqualStrategyNumber, F_OIDEQ,
208  ObjectIdGetDatum(pubid));
209 
210  scan = systable_beginscan(pubschsrel,
211  PublicationNamespacePnnspidPnpubidIndexId,
212  true, NULL, 1, &scankey);
213  tup = systable_getnext(scan);
214  result = HeapTupleIsValid(tup);
215 
216  systable_endscan(scan);
217  table_close(pubschsrel, AccessShareLock);
218 
219  return result;
220 }

References AccessShareLock, BTEqualStrategyNumber, HeapTupleIsValid, ObjectIdGetDatum, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterPublicationOwner_internal().

◆ pg_get_publication_tables()

Datum pg_get_publication_tables ( PG_FUNCTION_ARGS  )

Definition at line 1083 of file pg_publication.c.

1084 {
1085 #define NUM_PUBLICATOIN_TABLES_ELEM 3
1086  FuncCallContext *funcctx;
1087  char *pubname = text_to_cstring(PG_GETARG_TEXT_PP(0));
1088  Publication *publication;
1089  List *tables;
1090 
1091  /* stuff done only on the first call of the function */
1092  if (SRF_IS_FIRSTCALL())
1093  {
1094  TupleDesc tupdesc;
1095  MemoryContext oldcontext;
1096 
1097  /* create a function context for cross-call persistence */
1098  funcctx = SRF_FIRSTCALL_INIT();
1099 
1100  /* switch to memory context appropriate for multiple function calls */
1101  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1102 
1103  publication = GetPublicationByName(pubname, false);
1104 
1105  /*
1106  * Publications support partitioned tables, although all changes are
1107  * replicated using leaf partition identity and schema, so we only
1108  * need those.
1109  */
1110  if (publication->alltables)
1111  {
1112  tables = GetAllTablesPublicationRelations(publication->pubviaroot);
1113  }
1114  else
1115  {
1116  List *relids,
1117  *schemarelids;
1118 
1119  relids = GetPublicationRelations(publication->oid,
1120  publication->pubviaroot ?
1123  schemarelids = GetAllSchemaPublicationRelations(publication->oid,
1124  publication->pubviaroot ?
1127  tables = list_concat_unique_oid(relids, schemarelids);
1128 
1129  /*
1130  * If the publication publishes partition changes via their
1131  * respective root partitioned tables, we must exclude partitions
1132  * in favor of including the root partitioned tables. Otherwise,
1133  * the function could return both the child and parent tables
1134  * which could cause data of the child table to be
1135  * double-published on the subscriber side.
1136  */
1137  if (publication->pubviaroot)
1138  tables = filter_partitions(tables);
1139  }
1140 
1141  /* Construct a tuple descriptor for the result rows. */
1143  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "relid",
1144  OIDOID, -1, 0);
1145  TupleDescInitEntry(tupdesc, (AttrNumber) 2, "attrs",
1146  INT2VECTOROID, -1, 0);
1147  TupleDescInitEntry(tupdesc, (AttrNumber) 3, "qual",
1148  PG_NODE_TREEOID, -1, 0);
1149 
1150  funcctx->tuple_desc = BlessTupleDesc(tupdesc);
1151  funcctx->user_fctx = (void *) tables;
1152 
1153  MemoryContextSwitchTo(oldcontext);
1154  }
1155 
1156  /* stuff done on every call of the function */
1157  funcctx = SRF_PERCALL_SETUP();
1158  tables = (List *) funcctx->user_fctx;
1159 
1160  if (funcctx->call_cntr < list_length(tables))
1161  {
1162  HeapTuple pubtuple = NULL;
1163  HeapTuple rettuple;
1164  Oid relid = list_nth_oid(tables, funcctx->call_cntr);
1166  bool nulls[NUM_PUBLICATOIN_TABLES_ELEM];
1167 
1168  /*
1169  * Form tuple with appropriate data.
1170  */
1171  MemSet(nulls, 0, sizeof(nulls));
1172  MemSet(values, 0, sizeof(values));
1173 
1174  publication = GetPublicationByName(pubname, false);
1175 
1176  values[0] = ObjectIdGetDatum(relid);
1177 
1179  ObjectIdGetDatum(relid),
1180  ObjectIdGetDatum(publication->oid));
1181 
1182  if (HeapTupleIsValid(pubtuple))
1183  {
1184  /* Lookup the column list attribute. */
1185  values[1] = SysCacheGetAttr(PUBLICATIONRELMAP, pubtuple,
1186  Anum_pg_publication_rel_prattrs,
1187  &(nulls[1]));
1188 
1189  /* Null indicates no filter. */
1190  values[2] = SysCacheGetAttr(PUBLICATIONRELMAP, pubtuple,
1191  Anum_pg_publication_rel_prqual,
1192  &(nulls[2]));
1193  }
1194  else
1195  {
1196  nulls[1] = true;
1197  nulls[2] = true;
1198  }
1199 
1200  rettuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
1201 
1202  SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(rettuple));
1203  }
1204 
1205  SRF_RETURN_DONE(funcctx);
1206 }
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:156
#define MemSet(start, val, len)
Definition: c.h:1008
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2071
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:299
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:303
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:220
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:305
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:301
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:323
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
static int list_length(const List *l)
Definition: pg_list.h:149
static Oid list_nth_oid(const List *list, int n)
Definition: pg_list.h:300
Publication * GetPublicationByName(const char *pubname, bool missing_ok)
List * GetPublicationRelations(Oid pubid, PublicationPartOpt pub_partopt)
#define NUM_PUBLICATOIN_TABLES_ELEM
List * GetAllTablesPublicationRelations(bool pubviaroot)
static List * filter_partitions(List *relids)
List * GetAllSchemaPublicationRelations(Oid pubid, PublicationPartOpt pub_partopt)
uintptr_t Datum
Definition: postgres.h:411
void * user_fctx
Definition: funcapi.h:82
uint64 call_cntr
Definition: funcapi.h:65
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
TupleDesc tuple_desc
Definition: funcapi.h:112
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:1434
#define SearchSysCacheCopy2(cacheId, key1, key2)
Definition: syscache.h:181
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:45
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:583
char * text_to_cstring(const text *t)
Definition: varlena.c:221

References Publication::alltables, BlessTupleDesc(), FuncCallContext::call_cntr, CreateTemplateTupleDesc(), filter_partitions(), GetAllSchemaPublicationRelations(), GetAllTablesPublicationRelations(), GetPublicationByName(), GetPublicationRelations(), heap_form_tuple(), HeapTupleGetDatum, HeapTupleIsValid, if(), list_concat_unique_oid(), list_length(), list_nth_oid(), MemoryContextSwitchTo(), MemSet, FuncCallContext::multi_call_memory_ctx, NUM_PUBLICATOIN_TABLES_ELEM, ObjectIdGetDatum, Publication::oid, PG_GETARG_TEXT_PP, PUBLICATION_PART_LEAF, PUBLICATION_PART_ROOT, PUBLICATIONRELMAP, Publication::pubviaroot, SearchSysCacheCopy2, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, SysCacheGetAttr(), text_to_cstring(), FuncCallContext::tuple_desc, TupleDescInitEntry(), FuncCallContext::user_fctx, and values.

◆ pg_relation_is_publishable()

Datum pg_relation_is_publishable ( PG_FUNCTION_ARGS  )

Definition at line 230 of file pg_publication.c.

231 {
232  Oid relid = PG_GETARG_OID(0);
233  HeapTuple tuple;
234  bool result;
235 
236  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
237  if (!HeapTupleIsValid(tuple))
238  PG_RETURN_NULL();
239  result = is_publishable_class(relid, (Form_pg_class) GETSTRUCT(tuple));
240  ReleaseSysCache(tuple);
241  PG_RETURN_BOOL(result);
242 }
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
@ RELOID
Definition: syscache.h:89

References GETSTRUCT, HeapTupleIsValid, is_publishable_class(), ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, ReleaseSysCache(), RELOID, and SearchSysCache1().

◆ pub_collist_to_bitmapset()

Bitmapset* pub_collist_to_bitmapset ( Bitmapset columns,
Datum  pubcols,
MemoryContext  mcxt 
)

Definition at line 552 of file pg_publication.c.

553 {
554  Bitmapset *result = NULL;
555  ArrayType *arr;
556  int nelems;
557  int16 *elems;
558  MemoryContext oldcxt = NULL;
559 
560  /*
561  * If an existing bitmap was provided, use it. Otherwise just use NULL and
562  * build a new bitmap.
563  */
564  if (columns)
565  result = columns;
566 
567  arr = DatumGetArrayTypeP(pubcols);
568  nelems = ARR_DIMS(arr)[0];
569  elems = (int16 *) ARR_DATA_PTR(arr);
570 
571  /* If a memory context was specified, switch to it. */
572  if (mcxt)
573  oldcxt = MemoryContextSwitchTo(mcxt);
574 
575  for (int i = 0; i < nelems; i++)
576  result = bms_add_member(result, elems[i]);
577 
578  if (mcxt)
579  MemoryContextSwitchTo(oldcxt);
580 
581  return result;
582 }
#define ARR_DATA_PTR(a)
Definition: array.h:315
#define DatumGetArrayTypeP(X)
Definition: array.h:254
#define ARR_DIMS(a)
Definition: array.h:287
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:738

References ARR_DATA_PTR, ARR_DIMS, bms_add_member(), DatumGetArrayTypeP, i, and MemoryContextSwitchTo().

Referenced by AlterPublicationTables(), pgoutput_column_list_init(), and pub_collist_contains_invalid_column().

◆ publication_add_relation()

ObjectAddress publication_add_relation ( Oid  pubid,
PublicationRelInfo pri,
bool  if_not_exists 
)

Definition at line 340 of file pg_publication.c.

342 {
343  Relation rel;
344  HeapTuple tup;
345  Datum values[Natts_pg_publication_rel];
346  bool nulls[Natts_pg_publication_rel];
347  Relation targetrel = pri->relation;
348  Oid relid = RelationGetRelid(targetrel);
349  Oid pubreloid;
350  Publication *pub = GetPublication(pubid);
351  AttrNumber *attarray = NULL;
352  int natts = 0;
353  ObjectAddress myself,
354  referenced;
355  List *relids = NIL;
356 
357  rel = table_open(PublicationRelRelationId, RowExclusiveLock);
358 
359  /*
360  * Check for duplicates. Note that this does not really prevent
361  * duplicates, it's here just to provide nicer error message in common
362  * case. The real protection is the unique key on the catalog.
363  */
365  ObjectIdGetDatum(pubid)))
366  {
368 
369  if (if_not_exists)
370  return InvalidObjectAddress;
371 
372  ereport(ERROR,
374  errmsg("relation \"%s\" is already member of publication \"%s\"",
375  RelationGetRelationName(targetrel), pub->name)));
376  }
377 
379 
380  /*
381  * Translate column names to attnums and make sure the column list
382  * contains only allowed elements (no system or generated columns etc.).
383  * Also build an array of attnums, for storing in the catalog.
384  */
386  &natts, &attarray);
387 
388  /* Form a tuple. */
389  memset(values, 0, sizeof(values));
390  memset(nulls, false, sizeof(nulls));
391 
392  pubreloid = GetNewOidWithIndex(rel, PublicationRelObjectIndexId,
393  Anum_pg_publication_rel_oid);
394  values[Anum_pg_publication_rel_oid - 1] = ObjectIdGetDatum(pubreloid);
395  values[Anum_pg_publication_rel_prpubid - 1] =
396  ObjectIdGetDatum(pubid);
397  values[Anum_pg_publication_rel_prrelid - 1] =
398  ObjectIdGetDatum(relid);
399 
400  /* Add qualifications, if available */
401  if (pri->whereClause != NULL)
402  values[Anum_pg_publication_rel_prqual - 1] = CStringGetTextDatum(nodeToString(pri->whereClause));
403  else
404  nulls[Anum_pg_publication_rel_prqual - 1] = true;
405 
406  /* Add column list, if available */
407  if (pri->columns)
408  values[Anum_pg_publication_rel_prattrs - 1] = PointerGetDatum(buildint2vector(attarray, natts));
409  else
410  nulls[Anum_pg_publication_rel_prattrs - 1] = true;
411 
412  tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
413 
414  /* Insert tuple into catalog. */
415  CatalogTupleInsert(rel, tup);
416  heap_freetuple(tup);
417 
418  /* Register dependencies as needed */
419  ObjectAddressSet(myself, PublicationRelRelationId, pubreloid);
420 
421  /* Add dependency on the publication */
422  ObjectAddressSet(referenced, PublicationRelationId, pubid);
423  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
424 
425  /* Add dependency on the relation */
426  ObjectAddressSet(referenced, RelationRelationId, relid);
427  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
428 
429  /* Add dependency on the objects mentioned in the qualifications */
430  if (pri->whereClause)
431  recordDependencyOnSingleRelExpr(&myself, pri->whereClause, relid,
433  false);
434 
435  /* Add dependency on the columns, if any are listed */
436  for (int i = 0; i < natts; i++)
437  {
438  ObjectAddressSubSet(referenced, RelationRelationId, relid, attarray[i]);
439  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
440  }
441 
442  /* Close the table. */
444 
445  /*
446  * Invalidate relcache so that publication info is rebuilt.
447  *
448  * For the partitioned tables, we must invalidate all partitions contained
449  * in the respective partition hierarchies, not just the one explicitly
450  * mentioned in the publication. This is required because we implicitly
451  * publish the child tables when the parent table is published.
452  */
454  relid);
455 
457 
458  return myself;
459 }
#define CStringGetTextDatum(s)
Definition: builtins.h:85
Oid GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
Definition: catalog.c:391
void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)
Definition: dependency.c:1631
@ DEPENDENCY_AUTO
Definition: dependency.h:34
@ DEPENDENCY_NORMAL
Definition: dependency.h:33
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
Definition: indexing.c:221
int2vector * buildint2vector(const int16 *int2s, int n)
Definition: int.c:114
#define RowExclusiveLock
Definition: lockdefs.h:38
const ObjectAddress InvalidObjectAddress
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)
Definition: objectaddress.h:33
char * nodeToString(const void *obj)
Definition: outfuncs.c:4785
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:44
static void check_publication_add_relation(Relation targetrel)
static void publication_translate_columns(Relation targetrel, List *columns, int *natts, AttrNumber **attrs)
#define PointerGetDatum(X)
Definition: postgres.h:600
void InvalidatePublicationRels(List *relids)
#define RelationGetDescr(relation)
Definition: rel.h:515
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:32
#define SearchSysCacheExists2(cacheId, key1, key2)
Definition: syscache.h:190

References buildint2vector(), CatalogTupleInsert(), check_publication_add_relation(), PublicationRelInfo::columns, CStringGetTextDatum, DEPENDENCY_AUTO, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, GetNewOidWithIndex(), GetPublication(), GetPubPartitionOptionRelations(), heap_form_tuple(), heap_freetuple(), i, InvalidatePublicationRels(), InvalidObjectAddress, Publication::name, NIL, nodeToString(), ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum, PointerGetDatum, PUBLICATION_PART_ALL, publication_translate_columns(), PUBLICATIONRELMAP, recordDependencyOn(), recordDependencyOnSingleRelExpr(), PublicationRelInfo::relation, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheExists2, table_close(), table_open(), values, and PublicationRelInfo::whereClause.

Referenced by PublicationAddTables().

◆ publication_add_schema()

ObjectAddress publication_add_schema ( Oid  pubid,
Oid  schemaid,
bool  if_not_exists 
)

Definition at line 588 of file pg_publication.c.

589 {
590  Relation rel;
591  HeapTuple tup;
592  Datum values[Natts_pg_publication_namespace];
593  bool nulls[Natts_pg_publication_namespace];
594  Oid psschid;
595  Publication *pub = GetPublication(pubid);
596  List *schemaRels = NIL;
597  ObjectAddress myself,
598  referenced;
599 
600  rel = table_open(PublicationNamespaceRelationId, RowExclusiveLock);
601 
602  /*
603  * Check for duplicates. Note that this does not really prevent
604  * duplicates, it's here just to provide nicer error message in common
605  * case. The real protection is the unique key on the catalog.
606  */
608  ObjectIdGetDatum(schemaid),
609  ObjectIdGetDatum(pubid)))
610  {
612 
613  if (if_not_exists)
614  return InvalidObjectAddress;
615 
616  ereport(ERROR,
618  errmsg("schema \"%s\" is already member of publication \"%s\"",
619  get_namespace_name(schemaid), pub->name)));
620  }
621 
623 
624  /* Form a tuple */
625  memset(values, 0, sizeof(values));
626  memset(nulls, false, sizeof(nulls));
627 
628  psschid = GetNewOidWithIndex(rel, PublicationNamespaceObjectIndexId,
629  Anum_pg_publication_namespace_oid);
630  values[Anum_pg_publication_namespace_oid - 1] = ObjectIdGetDatum(psschid);
631  values[Anum_pg_publication_namespace_pnpubid - 1] =
632  ObjectIdGetDatum(pubid);
633  values[Anum_pg_publication_namespace_pnnspid - 1] =
634  ObjectIdGetDatum(schemaid);
635 
636  tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
637 
638  /* Insert tuple into catalog */
639  CatalogTupleInsert(rel, tup);
640  heap_freetuple(tup);
641 
642  ObjectAddressSet(myself, PublicationNamespaceRelationId, psschid);
643 
644  /* Add dependency on the publication */
645  ObjectAddressSet(referenced, PublicationRelationId, pubid);
646  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
647 
648  /* Add dependency on the schema */
649  ObjectAddressSet(referenced, NamespaceRelationId, schemaid);
650  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
651 
652  /* Close the table */
654 
655  /*
656  * Invalidate relcache so that publication info is rebuilt. See
657  * publication_add_relation for why we need to consider all the
658  * partitions.
659  */
660  schemaRels = GetSchemaPublicationRelations(schemaid,
662  InvalidatePublicationRels(schemaRels);
663 
664  return myself;
665 }
static void check_publication_add_schema(Oid schemaid)

References CatalogTupleInsert(), check_publication_add_schema(), DEPENDENCY_AUTO, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_namespace_name(), GetNewOidWithIndex(), GetPublication(), GetSchemaPublicationRelations(), heap_form_tuple(), heap_freetuple(), InvalidatePublicationRels(), InvalidObjectAddress, Publication::name, NIL, ObjectAddressSet, ObjectIdGetDatum, PUBLICATION_PART_ALL, PUBLICATIONNAMESPACEMAP, recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheExists2, table_close(), table_open(), and values.

Referenced by PublicationAddSchemas().

◆ publication_translate_columns()

static void publication_translate_columns ( Relation  targetrel,
List columns,
int *  natts,
AttrNumber **  attrs 
)
static

Definition at line 484 of file pg_publication.c.

486 {
487  AttrNumber *attarray = NULL;
488  Bitmapset *set = NULL;
489  ListCell *lc;
490  int n = 0;
491  TupleDesc tupdesc = RelationGetDescr(targetrel);
492 
493  /* Bail out when no column list defined. */
494  if (!columns)
495  return;
496 
497  /*
498  * Translate list of columns to attnums. We prohibit system attributes and
499  * make sure there are no duplicate columns.
500  */
501  attarray = palloc(sizeof(AttrNumber) * list_length(columns));
502  foreach(lc, columns)
503  {
504  char *colname = strVal(lfirst(lc));
505  AttrNumber attnum = get_attnum(RelationGetRelid(targetrel), colname);
506 
507  if (attnum == InvalidAttrNumber)
508  ereport(ERROR,
509  errcode(ERRCODE_UNDEFINED_COLUMN),
510  errmsg("column \"%s\" of relation \"%s\" does not exist",
511  colname, RelationGetRelationName(targetrel)));
512 
514  ereport(ERROR,
515  errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
516  errmsg("cannot reference system column \"%s\" in publication column list",
517  colname));
518 
519  if (TupleDescAttr(tupdesc, attnum - 1)->attgenerated)
520  ereport(ERROR,
521  errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
522  errmsg("cannot reference generated column \"%s\" in publication column list",
523  colname));
524 
525  if (bms_is_member(attnum, set))
526  ereport(ERROR,
528  errmsg("duplicate column \"%s\" in publication column list",
529  colname));
530 
531  set = bms_add_member(set, attnum);
532  attarray[n++] = attnum;
533  }
534 
535  /* Be tidy, so that the catalog representation is always sorted */
536  qsort(attarray, n, sizeof(AttrNumber), compare_int16);
537 
538  *natts = n;
539  *attrs = attarray;
540 
541  bms_free(set);
542 }
#define AttrNumberIsForUserDefinedAttr(attributeNumber)
Definition: attnum.h:41
#define InvalidAttrNumber
Definition: attnum.h:23
void bms_free(Bitmapset *a)
Definition: bitmapset.c:208
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:856
int16 attnum
Definition: pg_attribute.h:83
#define lfirst(lc)
Definition: pg_list.h:169
static int compare_int16(const void *a, const void *b)
#define qsort(a, b, c, d)
Definition: port.h:495
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define strVal(v)
Definition: value.h:72

References attnum, AttrNumberIsForUserDefinedAttr, bms_add_member(), bms_free(), bms_is_member(), compare_int16(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_attnum(), InvalidAttrNumber, lfirst, list_length(), palloc(), qsort, RelationGetDescr, RelationGetRelationName, RelationGetRelid, strVal, and TupleDescAttr.

Referenced by publication_add_relation().