PostgreSQL Source Code  git master
catalog.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * catalog.c
4  * routines concerned with catalog naming conventions and other
5  * bits of hard-wired knowledge
6  *
7  *
8  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
9  * Portions Copyright (c) 1994, Regents of the University of California
10  *
11  *
12  * IDENTIFICATION
13  * src/backend/catalog/catalog.c
14  *
15  *-------------------------------------------------------------------------
16  */
17 
18 #include "postgres.h"
19 
20 #include <fcntl.h>
21 #include <unistd.h>
22 
23 #include "access/genam.h"
24 #include "access/htup_details.h"
25 #include "access/sysattr.h"
26 #include "access/table.h"
27 #include "access/transam.h"
28 #include "catalog/catalog.h"
29 #include "catalog/indexing.h"
30 #include "catalog/namespace.h"
32 #include "catalog/pg_authid.h"
33 #include "catalog/pg_database.h"
34 #include "catalog/pg_namespace.h"
35 #include "catalog/pg_pltemplate.h"
38 #include "catalog/pg_shdepend.h"
40 #include "catalog/pg_shseclabel.h"
42 #include "catalog/pg_tablespace.h"
43 #include "catalog/pg_type.h"
44 #include "catalog/toasting.h"
45 #include "miscadmin.h"
46 #include "storage/fd.h"
47 #include "utils/fmgroids.h"
48 #include "utils/fmgrprotos.h"
49 #include "utils/rel.h"
50 #include "utils/snapmgr.h"
51 #include "utils/syscache.h"
52 
53 
54 /*
55  * IsSystemRelation
56  * True iff the relation is either a system catalog or a toast table.
57  * See IsCatalogRelation for the exact definition of a system catalog.
58  *
59  * We treat toast tables of user relations as "system relations" for
60  * protection purposes, e.g. you can't change their schemas without
61  * special permissions. Therefore, most uses of this function are
62  * checking whether allow_system_table_mods restrictions apply.
63  * For other purposes, consider whether you shouldn't be using
64  * IsCatalogRelation instead.
65  *
66  * This function does not perform any catalog accesses.
67  * Some callers rely on that!
68  */
69 bool
71 {
72  return IsSystemClass(RelationGetRelid(relation), relation->rd_rel);
73 }
74 
75 /*
76  * IsSystemClass
77  * Like the above, but takes a Form_pg_class as argument.
78  * Used when we do not want to open the relation and have to
79  * search pg_class directly.
80  */
81 bool
83 {
84  /* IsCatalogRelationOid is a bit faster, so test that first */
85  return (IsCatalogRelationOid(relid) || IsToastClass(reltuple));
86 }
87 
88 /*
89  * IsCatalogRelation
90  * True iff the relation is a system catalog.
91  *
92  * By a system catalog, we mean one that is created during the bootstrap
93  * phase of initdb. That includes not just the catalogs per se, but
94  * also their indexes, and TOAST tables and indexes if any.
95  *
96  * This function does not perform any catalog accesses.
97  * Some callers rely on that!
98  */
99 bool
101 {
102  return IsCatalogRelationOid(RelationGetRelid(relation));
103 }
104 
105 /*
106  * IsCatalogRelationOid
107  * True iff the relation identified by this OID is a system catalog.
108  *
109  * By a system catalog, we mean one that is created during the bootstrap
110  * phase of initdb. That includes not just the catalogs per se, but
111  * also their indexes, and TOAST tables and indexes if any.
112  *
113  * This function does not perform any catalog accesses.
114  * Some callers rely on that!
115  */
116 bool
118 {
119  /*
120  * We consider a relation to be a system catalog if it has an OID that was
121  * manually assigned or assigned by genbki.pl. This includes all the
122  * defined catalogs, their indexes, and their TOAST tables and indexes.
123  *
124  * This rule excludes the relations in information_schema, which are not
125  * integral to the system and can be treated the same as user relations.
126  * (Since it's valid to drop and recreate information_schema, any rule
127  * that did not act this way would be wrong.)
128  *
129  * This test is reliable since an OID wraparound will skip this range of
130  * OIDs; see GetNewObjectId().
131  */
132  return (relid < (Oid) FirstBootstrapObjectId);
133 }
134 
135 /*
136  * IsToastRelation
137  * True iff relation is a TOAST support relation (or index).
138  *
139  * Does not perform any catalog accesses.
140  */
141 bool
143 {
144  /*
145  * What we actually check is whether the relation belongs to a pg_toast
146  * namespace. This should be equivalent because of restrictions that are
147  * enforced elsewhere against creating user relations in, or moving
148  * relations into/out of, a pg_toast namespace. Notice also that this
149  * will not say "true" for toast tables belonging to other sessions' temp
150  * tables; we expect that other mechanisms will prevent access to those.
151  */
152  return IsToastNamespace(RelationGetNamespace(relation));
153 }
154 
155 /*
156  * IsToastClass
157  * Like the above, but takes a Form_pg_class as argument.
158  * Used when we do not want to open the relation and have to
159  * search pg_class directly.
160  */
161 bool
163 {
164  Oid relnamespace = reltuple->relnamespace;
165 
166  return IsToastNamespace(relnamespace);
167 }
168 
169 /*
170  * IsCatalogNamespace
171  * True iff namespace is pg_catalog.
172  *
173  * Does not perform any catalog accesses.
174  *
175  * NOTE: the reason this isn't a macro is to avoid having to include
176  * catalog/pg_namespace.h in a lot of places.
177  */
178 bool
180 {
181  return namespaceId == PG_CATALOG_NAMESPACE;
182 }
183 
184 /*
185  * IsToastNamespace
186  * True iff namespace is pg_toast or my temporary-toast-table namespace.
187  *
188  * Does not perform any catalog accesses.
189  *
190  * Note: this will return false for temporary-toast-table namespaces belonging
191  * to other backends. Those are treated the same as other backends' regular
192  * temp table namespaces, and access is prevented where appropriate.
193  * If you need to check for those, you may be able to use isAnyTempNamespace,
194  * but beware that that does involve a catalog access.
195  */
196 bool
197 IsToastNamespace(Oid namespaceId)
198 {
199  return (namespaceId == PG_TOAST_NAMESPACE) ||
200  isTempToastNamespace(namespaceId);
201 }
202 
203 
204 /*
205  * IsReservedName
206  * True iff name starts with the pg_ prefix.
207  *
208  * For some classes of objects, the prefix pg_ is reserved for
209  * system objects only. As of 8.0, this was only true for
210  * schema and tablespace names. With 9.6, this is also true
211  * for roles.
212  */
213 bool
214 IsReservedName(const char *name)
215 {
216  /* ugly coding for speed */
217  return (name[0] == 'p' &&
218  name[1] == 'g' &&
219  name[2] == '_');
220 }
221 
222 
223 /*
224  * IsSharedRelation
225  * Given the OID of a relation, determine whether it's supposed to be
226  * shared across an entire database cluster.
227  *
228  * In older releases, this had to be hard-wired so that we could compute the
229  * locktag for a relation and lock it before examining its catalog entry.
230  * Since we now have MVCC catalog access, the race conditions that made that
231  * a hard requirement are gone, so we could look at relaxing this restriction.
232  * However, if we scanned the pg_class entry to find relisshared, and only
233  * then locked the relation, pg_class could get updated in the meantime,
234  * forcing us to scan the relation again, which would definitely be complex
235  * and might have undesirable performance consequences. Fortunately, the set
236  * of shared relations is fairly static, so a hand-maintained list of their
237  * OIDs isn't completely impractical.
238  */
239 bool
241 {
242  /* These are the shared catalogs (look for BKI_SHARED_RELATION) */
243  if (relationId == AuthIdRelationId ||
244  relationId == AuthMemRelationId ||
245  relationId == DatabaseRelationId ||
246  relationId == PLTemplateRelationId ||
247  relationId == SharedDescriptionRelationId ||
248  relationId == SharedDependRelationId ||
249  relationId == SharedSecLabelRelationId ||
250  relationId == TableSpaceRelationId ||
251  relationId == DbRoleSettingRelationId ||
252  relationId == ReplicationOriginRelationId ||
253  relationId == SubscriptionRelationId)
254  return true;
255  /* These are their indexes (see indexing.h) */
256  if (relationId == AuthIdRolnameIndexId ||
257  relationId == AuthIdOidIndexId ||
258  relationId == AuthMemRoleMemIndexId ||
259  relationId == AuthMemMemRoleIndexId ||
260  relationId == DatabaseNameIndexId ||
261  relationId == DatabaseOidIndexId ||
262  relationId == PLTemplateNameIndexId ||
263  relationId == SharedDescriptionObjIndexId ||
264  relationId == SharedDependDependerIndexId ||
265  relationId == SharedDependReferenceIndexId ||
266  relationId == SharedSecLabelObjectIndexId ||
267  relationId == TablespaceOidIndexId ||
268  relationId == TablespaceNameIndexId ||
269  relationId == DbRoleSettingDatidRolidIndexId ||
270  relationId == ReplicationOriginIdentIndex ||
271  relationId == ReplicationOriginNameIndex ||
272  relationId == SubscriptionObjectIndexId ||
273  relationId == SubscriptionNameIndexId)
274  return true;
275  /* These are their toast tables and toast indexes (see toasting.h) */
276  if (relationId == PgAuthidToastTable ||
277  relationId == PgAuthidToastIndex ||
278  relationId == PgDatabaseToastTable ||
279  relationId == PgDatabaseToastIndex ||
280  relationId == PgDbRoleSettingToastTable ||
281  relationId == PgDbRoleSettingToastIndex ||
282  relationId == PgPlTemplateToastTable ||
283  relationId == PgPlTemplateToastIndex ||
284  relationId == PgReplicationOriginToastTable ||
285  relationId == PgReplicationOriginToastIndex ||
286  relationId == PgShdescriptionToastTable ||
287  relationId == PgShdescriptionToastIndex ||
288  relationId == PgShseclabelToastTable ||
289  relationId == PgShseclabelToastIndex ||
290  relationId == PgSubscriptionToastTable ||
291  relationId == PgSubscriptionToastIndex ||
292  relationId == PgTablespaceToastTable ||
293  relationId == PgTablespaceToastIndex)
294  return true;
295  return false;
296 }
297 
298 
299 /*
300  * GetNewOidWithIndex
301  * Generate a new OID that is unique within the system relation.
302  *
303  * Since the OID is not immediately inserted into the table, there is a
304  * race condition here; but a problem could occur only if someone else
305  * managed to cycle through 2^32 OIDs and generate the same OID before we
306  * finish inserting our row. This seems unlikely to be a problem. Note
307  * that if we had to *commit* the row to end the race condition, the risk
308  * would be rather higher; therefore we use SnapshotAny in the test, so that
309  * we will see uncommitted rows. (We used to use SnapshotDirty, but that has
310  * the disadvantage that it ignores recently-deleted rows, creating a risk
311  * of transient conflicts for as long as our own MVCC snapshots think a
312  * recently-deleted row is live. The risk is far higher when selecting TOAST
313  * OIDs, because SnapshotToast considers dead rows as active indefinitely.)
314  *
315  * Note that we are effectively assuming that the table has a relatively small
316  * number of entries (much less than 2^32) and there aren't very long runs of
317  * consecutive existing OIDs. This is a mostly reasonable assumption for
318  * system catalogs.
319  *
320  * Caller must have a suitable lock on the relation.
321  */
322 Oid
323 GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
324 {
325  Oid newOid;
326  SysScanDesc scan;
328  bool collides;
329 
330  /* Only system relations are supported */
331  Assert(IsSystemRelation(relation));
332 
333  /* In bootstrap mode, we don't have any indexes to use */
335  return GetNewObjectId();
336 
337  /*
338  * We should never be asked to generate a new pg_type OID during
339  * pg_upgrade; doing so would risk collisions with the OIDs it wants to
340  * assign. Hitting this assert means there's some path where we failed to
341  * ensure that a type OID is determined by commands in the dump script.
342  */
343  Assert(!IsBinaryUpgrade || RelationGetRelid(relation) != TypeRelationId);
344 
345  /* Generate new OIDs until we find one not in the table */
346  do
347  {
349 
350  newOid = GetNewObjectId();
351 
352  ScanKeyInit(&key,
353  oidcolumn,
354  BTEqualStrategyNumber, F_OIDEQ,
355  ObjectIdGetDatum(newOid));
356 
357  /* see notes above about using SnapshotAny */
358  scan = systable_beginscan(relation, indexId, true,
359  SnapshotAny, 1, &key);
360 
361  collides = HeapTupleIsValid(systable_getnext(scan));
362 
363  systable_endscan(scan);
364  } while (collides);
365 
366  return newOid;
367 }
368 
369 /*
370  * GetNewRelFileNode
371  * Generate a new relfilenode number that is unique within the
372  * database of the given tablespace.
373  *
374  * If the relfilenode will also be used as the relation's OID, pass the
375  * opened pg_class catalog, and this routine will guarantee that the result
376  * is also an unused OID within pg_class. If the result is to be used only
377  * as a relfilenode for an existing relation, pass NULL for pg_class.
378  *
379  * As with GetNewOidWithIndex(), there is some theoretical risk of a race
380  * condition, but it doesn't seem worth worrying about.
381  *
382  * Note: we don't support using this in bootstrap mode. All relations
383  * created by bootstrap have preassigned OIDs, so there's no need.
384  */
385 Oid
386 GetNewRelFileNode(Oid reltablespace, Relation pg_class, char relpersistence)
387 {
388  RelFileNodeBackend rnode;
389  char *rpath;
390  bool collides;
391  BackendId backend;
392 
393  /*
394  * If we ever get here during pg_upgrade, there's something wrong; all
395  * relfilenode assignments during a binary-upgrade run should be
396  * determined by commands in the dump script.
397  */
399 
400  switch (relpersistence)
401  {
402  case RELPERSISTENCE_TEMP:
403  backend = BackendIdForTempRelations();
404  break;
405  case RELPERSISTENCE_UNLOGGED:
406  case RELPERSISTENCE_PERMANENT:
407  backend = InvalidBackendId;
408  break;
409  default:
410  elog(ERROR, "invalid relpersistence: %c", relpersistence);
411  return InvalidOid; /* placate compiler */
412  }
413 
414  /* This logic should match RelationInitPhysicalAddr */
415  rnode.node.spcNode = reltablespace ? reltablespace : MyDatabaseTableSpace;
416  rnode.node.dbNode = (rnode.node.spcNode == GLOBALTABLESPACE_OID) ? InvalidOid : MyDatabaseId;
417 
418  /*
419  * The relpath will vary based on the backend ID, so we must initialize
420  * that properly here to make sure that any collisions based on filename
421  * are properly detected.
422  */
423  rnode.backend = backend;
424 
425  do
426  {
428 
429  /* Generate the OID */
430  if (pg_class)
432  Anum_pg_class_oid);
433  else
434  rnode.node.relNode = GetNewObjectId();
435 
436  /* Check for existing file of same name */
437  rpath = relpath(rnode, MAIN_FORKNUM);
438 
439  if (access(rpath, F_OK) == 0)
440  {
441  /* definite collision */
442  collides = true;
443  }
444  else
445  {
446  /*
447  * Here we have a little bit of a dilemma: if errno is something
448  * other than ENOENT, should we declare a collision and loop? In
449  * practice it seems best to go ahead regardless of the errno. If
450  * there is a colliding file we will get an smgr failure when we
451  * attempt to create the new relation file.
452  */
453  collides = false;
454  }
455 
456  pfree(rpath);
457  } while (collides);
458 
459  return rnode.node.relNode;
460 }
461 
462 /*
463  * SQL callable interface for GetNewOidWithIndex(). Outside of initdb's
464  * direct insertions into catalog tables, and recovering from corruption, this
465  * should rarely be needed.
466  *
467  * Function is intentionally not documented in the user facing docs.
468  */
469 Datum
471 {
472  Oid reloid = PG_GETARG_OID(0);
474  Oid idxoid = PG_GETARG_OID(2);
475  Relation rel;
476  Relation idx;
477  HeapTuple atttuple;
478  Form_pg_attribute attform;
479  AttrNumber attno;
480  Oid newoid;
481 
482  /*
483  * As this function is not intended to be used during normal running, and
484  * only supports system catalogs (which require superuser permissions to
485  * modify), just checking for superuser ought to not obstruct valid
486  * usecases.
487  */
488  if (!superuser())
489  ereport(ERROR,
490  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
491  errmsg("must be superuser to call pg_nextoid()")));
492 
493  rel = table_open(reloid, RowExclusiveLock);
494  idx = index_open(idxoid, RowExclusiveLock);
495 
496  if (!IsSystemRelation(rel))
497  ereport(ERROR,
498  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
499  errmsg("pg_nextoid() can only be used on system catalogs")));
500 
501  if (idx->rd_index->indrelid != RelationGetRelid(rel))
502  ereport(ERROR,
503  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
504  errmsg("index \"%s\" does not belong to table \"%s\"",
506  RelationGetRelationName(rel))));
507 
508  atttuple = SearchSysCacheAttName(reloid, NameStr(*attname));
509  if (!HeapTupleIsValid(atttuple))
510  ereport(ERROR,
511  (errcode(ERRCODE_UNDEFINED_COLUMN),
512  errmsg("column \"%s\" of relation \"%s\" does not exist",
513  NameStr(*attname), RelationGetRelationName(rel))));
514 
515  attform = ((Form_pg_attribute) GETSTRUCT(atttuple));
516  attno = attform->attnum;
517 
518  if (attform->atttypid != OIDOID)
519  ereport(ERROR,
520  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
521  errmsg("column \"%s\" is not of type oid",
522  NameStr(*attname))));
523 
525  idx->rd_index->indkey.values[0] != attno)
526  ereport(ERROR,
527  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
528  errmsg("index \"%s\" is not the index for column \"%s\"",
530  NameStr(*attname))));
531 
532  newoid = GetNewOidWithIndex(rel, idxoid, attno);
533 
534  ReleaseSysCache(atttuple);
537 
538  return newoid;
539 }
Oid GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
Definition: catalog.c:323
bool IsToastRelation(Relation relation)
Definition: catalog.c:142
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:100
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:133
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:525
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
#define PgShseclabelToastIndex
Definition: toasting.h:100
bool IsSystemRelation(Relation relation)
Definition: catalog.c:70
#define SharedDependDependerIndexId
Definition: indexing.h:226
#define PgAuthidToastTable
Definition: toasting.h:81
#define PgTablespaceToastTable
Definition: toasting.h:105
#define DbRoleSettingDatidRolidIndexId
Definition: indexing.h:317
int errcode(int sqlerrcode)
Definition: elog.c:570
bool superuser(void)
Definition: superuser.c:47
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:264
#define PgShseclabelToastTable
Definition: toasting.h:99
#define AuthIdOidIndexId
Definition: indexing.h:101
#define PgSubscriptionToastTable
Definition: toasting.h:102
bool IsToastNamespace(Oid namespaceId)
Definition: catalog.c:197
Form_pg_class rd_rel
Definition: rel.h:83
unsigned int Oid
Definition: postgres_ext.h:31
bool IsReservedName(const char *name)
Definition: catalog.c:214
#define PgDatabaseToastTable
Definition: toasting.h:84
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:352
bool IsBinaryUpgrade
Definition: globals.c:110
Oid MyDatabaseTableSpace
Definition: globals.c:87
bool IsSystemClass(Oid relid, Form_pg_class reltuple)
Definition: catalog.c:82
bool IsCatalogRelationOid(Oid relid)
Definition: catalog.c:117
#define PgTablespaceToastIndex
Definition: toasting.h:106
Oid GetNewObjectId(void)
Definition: varsup.c:509
Form_pg_index rd_index
Definition: rel.h:143
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:444
void pfree(void *pointer)
Definition: mcxt.c:1031
bool IsToastClass(Form_pg_class reltuple)
Definition: catalog.c:162
#define ReplicationOriginIdentIndex
Definition: indexing.h:340
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
NameData attname
Definition: pg_attribute.h:40
char relpersistence
Definition: pg_class.h:78
#define TablespaceOidIndexId
Definition: indexing.h:244
#define PgPlTemplateToastTable
Definition: toasting.h:90
Definition: c.h:603
#define BackendIdForTempRelations()
Definition: backendid.h:34
#define PgShdescriptionToastTable
Definition: toasting.h:96
#define PgReplicationOriginToastTable
Definition: toasting.h:93
#define PG_GETARG_OID(n)
Definition: fmgr.h:270
#define RowExclusiveLock
Definition: lockdefs.h:38
#define RelationGetRelationName(relation)
Definition: rel.h:450
#define DatabaseOidIndexId
Definition: indexing.h:146
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
#define FirstBootstrapObjectId
Definition: transam.h:140
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:435
#define ClassOidIndexId
Definition: indexing.h:114
#define ereport(elevel, rest)
Definition: elog.h:141
#define PgShdescriptionToastIndex
Definition: toasting.h:97
#define PgDbRoleSettingToastTable
Definition: toasting.h:87
bool isTempToastNamespace(Oid namespaceId)
Definition: namespace.c:3161
#define AuthMemRoleMemIndexId
Definition: indexing.h:104
#define InvalidBackendId
Definition: backendid.h:23
uintptr_t Datum
Definition: postgres.h:367
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1172
int BackendId
Definition: backendid.h:21
Oid MyDatabaseId
Definition: globals.c:85
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:240
#define PLTemplateNameIndexId
Definition: indexing.h:210
#define InvalidOid
Definition: postgres_ext.h:36
#define PgPlTemplateToastIndex
Definition: toasting.h:91
#define SharedDescriptionObjIndexId
Definition: indexing.h:156
RelFileNode node
Definition: relfilenode.h:74
#define PgDatabaseToastIndex
Definition: toasting.h:85
#define PgAuthidToastIndex
Definition: toasting.h:82
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define PgReplicationOriginToastIndex
Definition: toasting.h:94
#define Assert(condition)
Definition: c.h:732
#define AuthMemMemRoleIndexId
Definition: indexing.h:106
BackendId backend
Definition: relfilenode.h:75
Oid GetNewRelFileNode(Oid reltablespace, Relation pg_class, char relpersistence)
Definition: catalog.c:386
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
Definition: syscache.c:1265
#define DatabaseNameIndexId
Definition: indexing.h:144
const char * name
Definition: encode.c:521
#define SnapshotAny
Definition: snapmgr.h:70
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:152
#define SharedSecLabelObjectIndexId
Definition: indexing.h:323
bool IsCatalogNamespace(Oid namespaceId)
Definition: catalog.c:179
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:374
FormData_pg_class * Form_pg_class
Definition: pg_class.h:150
#define TablespaceNameIndexId
Definition: indexing.h:246
#define SubscriptionNameIndexId
Definition: indexing.h:364
int errmsg(const char *fmt,...)
Definition: elog.c:784
#define PgSubscriptionToastIndex
Definition: toasting.h:103
#define elog(elevel,...)
Definition: elog.h:226
#define relpath(rnode, forknum)
Definition: relpath.h:87
#define NameStr(name)
Definition: c.h:609
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define PG_FUNCTION_ARGS
Definition: fmgr.h:188
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
#define ReplicationOriginNameIndex
Definition: indexing.h:343
#define SharedDependReferenceIndexId
Definition: indexing.h:228
Datum pg_nextoid(PG_FUNCTION_ARGS)
Definition: catalog.c:470
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39
#define PgDbRoleSettingToastIndex
Definition: toasting.h:88
#define AuthIdRolnameIndexId
Definition: indexing.h:99
int16 AttrNumber
Definition: attnum.h:21
#define RelationGetRelid(relation)
Definition: rel.h:416
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:126
#define BTEqualStrategyNumber
Definition: stratnum.h:31
#define PG_GETARG_NAME(n)
Definition: fmgr.h:273
#define RelationGetNamespace(relation)
Definition: rel.h:457
#define SubscriptionObjectIndexId
Definition: indexing.h:361