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-2022, 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/namespace.h"
31 #include "catalog/pg_authid.h"
32 #include "catalog/pg_database.h"
34 #include "catalog/pg_largeobject.h"
35 #include "catalog/pg_namespace.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 "miscadmin.h"
45 #include "storage/fd.h"
46 #include "utils/fmgroids.h"
47 #include "utils/fmgrprotos.h"
48 #include "utils/rel.h"
49 #include "utils/snapmgr.h"
50 #include "utils/syscache.h"
51 
52 /*
53  * Parameters to determine when to emit a log message in
54  * GetNewOidWithIndex()
55  */
56 #define GETNEWOID_LOG_THRESHOLD 1000000
57 #define GETNEWOID_LOG_MAX_INTERVAL 128000000
58 
59 /*
60  * IsSystemRelation
61  * True iff the relation is either a system catalog or a toast table.
62  * See IsCatalogRelation for the exact definition of a system catalog.
63  *
64  * We treat toast tables of user relations as "system relations" for
65  * protection purposes, e.g. you can't change their schemas without
66  * special permissions. Therefore, most uses of this function are
67  * checking whether allow_system_table_mods restrictions apply.
68  * For other purposes, consider whether you shouldn't be using
69  * IsCatalogRelation instead.
70  *
71  * This function does not perform any catalog accesses.
72  * Some callers rely on that!
73  */
74 bool
76 {
77  return IsSystemClass(RelationGetRelid(relation), relation->rd_rel);
78 }
79 
80 /*
81  * IsSystemClass
82  * Like the above, but takes a Form_pg_class as argument.
83  * Used when we do not want to open the relation and have to
84  * search pg_class directly.
85  */
86 bool
88 {
89  /* IsCatalogRelationOid is a bit faster, so test that first */
90  return (IsCatalogRelationOid(relid) || IsToastClass(reltuple));
91 }
92 
93 /*
94  * IsCatalogRelation
95  * True iff the relation is a system catalog.
96  *
97  * By a system catalog, we mean one that is created during the bootstrap
98  * phase of initdb. That includes not just the catalogs per se, but
99  * also their indexes, and TOAST tables and indexes if any.
100  *
101  * This function does not perform any catalog accesses.
102  * Some callers rely on that!
103  */
104 bool
106 {
107  return IsCatalogRelationOid(RelationGetRelid(relation));
108 }
109 
110 /*
111  * IsCatalogRelationOid
112  * True iff the relation identified by this OID is a system catalog.
113  *
114  * By a system catalog, we mean one that is created during the bootstrap
115  * phase of initdb. That includes not just the catalogs per se, but
116  * also their indexes, and TOAST tables and indexes if any.
117  *
118  * This function does not perform any catalog accesses.
119  * Some callers rely on that!
120  */
121 bool
123 {
124  /*
125  * We consider a relation to be a system catalog if it has a pinned OID.
126  * This includes all the defined catalogs, their indexes, and their TOAST
127  * tables and indexes.
128  *
129  * This rule excludes the relations in information_schema, which are not
130  * integral to the system and can be treated the same as user relations.
131  * (Since it's valid to drop and recreate information_schema, any rule
132  * that did not act this way would be wrong.)
133  *
134  * This test is reliable since an OID wraparound will skip this range of
135  * OIDs; see GetNewObjectId().
136  */
137  return (relid < (Oid) FirstUnpinnedObjectId);
138 }
139 
140 /*
141  * IsToastRelation
142  * True iff relation is a TOAST support relation (or index).
143  *
144  * Does not perform any catalog accesses.
145  */
146 bool
148 {
149  /*
150  * What we actually check is whether the relation belongs to a pg_toast
151  * namespace. This should be equivalent because of restrictions that are
152  * enforced elsewhere against creating user relations in, or moving
153  * relations into/out of, a pg_toast namespace. Notice also that this
154  * will not say "true" for toast tables belonging to other sessions' temp
155  * tables; we expect that other mechanisms will prevent access to those.
156  */
157  return IsToastNamespace(RelationGetNamespace(relation));
158 }
159 
160 /*
161  * IsToastClass
162  * Like the above, but takes a Form_pg_class as argument.
163  * Used when we do not want to open the relation and have to
164  * search pg_class directly.
165  */
166 bool
168 {
169  Oid relnamespace = reltuple->relnamespace;
170 
171  return IsToastNamespace(relnamespace);
172 }
173 
174 /*
175  * IsCatalogNamespace
176  * True iff namespace is pg_catalog.
177  *
178  * Does not perform any catalog accesses.
179  *
180  * NOTE: the reason this isn't a macro is to avoid having to include
181  * catalog/pg_namespace.h in a lot of places.
182  */
183 bool
185 {
186  return namespaceId == PG_CATALOG_NAMESPACE;
187 }
188 
189 /*
190  * IsToastNamespace
191  * True iff namespace is pg_toast or my temporary-toast-table namespace.
192  *
193  * Does not perform any catalog accesses.
194  *
195  * Note: this will return false for temporary-toast-table namespaces belonging
196  * to other backends. Those are treated the same as other backends' regular
197  * temp table namespaces, and access is prevented where appropriate.
198  * If you need to check for those, you may be able to use isAnyTempNamespace,
199  * but beware that that does involve a catalog access.
200  */
201 bool
202 IsToastNamespace(Oid namespaceId)
203 {
204  return (namespaceId == PG_TOAST_NAMESPACE) ||
205  isTempToastNamespace(namespaceId);
206 }
207 
208 
209 /*
210  * IsReservedName
211  * True iff name starts with the pg_ prefix.
212  *
213  * For some classes of objects, the prefix pg_ is reserved for
214  * system objects only. As of 8.0, this was only true for
215  * schema and tablespace names. With 9.6, this is also true
216  * for roles.
217  */
218 bool
219 IsReservedName(const char *name)
220 {
221  /* ugly coding for speed */
222  return (name[0] == 'p' &&
223  name[1] == 'g' &&
224  name[2] == '_');
225 }
226 
227 
228 /*
229  * IsSharedRelation
230  * Given the OID of a relation, determine whether it's supposed to be
231  * shared across an entire database cluster.
232  *
233  * In older releases, this had to be hard-wired so that we could compute the
234  * locktag for a relation and lock it before examining its catalog entry.
235  * Since we now have MVCC catalog access, the race conditions that made that
236  * a hard requirement are gone, so we could look at relaxing this restriction.
237  * However, if we scanned the pg_class entry to find relisshared, and only
238  * then locked the relation, pg_class could get updated in the meantime,
239  * forcing us to scan the relation again, which would definitely be complex
240  * and might have undesirable performance consequences. Fortunately, the set
241  * of shared relations is fairly static, so a hand-maintained list of their
242  * OIDs isn't completely impractical.
243  */
244 bool
246 {
247  /* These are the shared catalogs (look for BKI_SHARED_RELATION) */
248  if (relationId == AuthIdRelationId ||
249  relationId == AuthMemRelationId ||
250  relationId == DatabaseRelationId ||
251  relationId == DbRoleSettingRelationId ||
252  relationId == ParameterAclRelationId ||
253  relationId == ReplicationOriginRelationId ||
254  relationId == SharedDependRelationId ||
255  relationId == SharedDescriptionRelationId ||
256  relationId == SharedSecLabelRelationId ||
257  relationId == SubscriptionRelationId ||
258  relationId == TableSpaceRelationId)
259  return true;
260  /* These are their indexes */
261  if (relationId == AuthIdOidIndexId ||
262  relationId == AuthIdRolnameIndexId ||
263  relationId == AuthMemMemRoleIndexId ||
264  relationId == AuthMemRoleMemIndexId ||
265  relationId == AuthMemOidIndexId ||
266  relationId == AuthMemGrantorIndexId ||
267  relationId == DatabaseNameIndexId ||
268  relationId == DatabaseOidIndexId ||
269  relationId == DbRoleSettingDatidRolidIndexId ||
270  relationId == ParameterAclOidIndexId ||
271  relationId == ParameterAclParnameIndexId ||
272  relationId == ReplicationOriginIdentIndex ||
273  relationId == ReplicationOriginNameIndex ||
274  relationId == SharedDependDependerIndexId ||
275  relationId == SharedDependReferenceIndexId ||
276  relationId == SharedDescriptionObjIndexId ||
277  relationId == SharedSecLabelObjectIndexId ||
278  relationId == SubscriptionNameIndexId ||
279  relationId == SubscriptionObjectIndexId ||
280  relationId == TablespaceNameIndexId ||
281  relationId == TablespaceOidIndexId)
282  return true;
283  /* These are their toast tables and toast indexes */
284  if (relationId == PgAuthidToastTable ||
285  relationId == PgAuthidToastIndex ||
286  relationId == PgDatabaseToastTable ||
287  relationId == PgDatabaseToastIndex ||
288  relationId == PgDbRoleSettingToastTable ||
289  relationId == PgDbRoleSettingToastIndex ||
290  relationId == PgParameterAclToastTable ||
291  relationId == PgParameterAclToastIndex ||
292  relationId == PgReplicationOriginToastTable ||
293  relationId == PgReplicationOriginToastIndex ||
294  relationId == PgShdescriptionToastTable ||
295  relationId == PgShdescriptionToastIndex ||
296  relationId == PgShseclabelToastTable ||
297  relationId == PgShseclabelToastIndex ||
298  relationId == PgSubscriptionToastTable ||
299  relationId == PgSubscriptionToastIndex ||
300  relationId == PgTablespaceToastTable ||
301  relationId == PgTablespaceToastIndex)
302  return true;
303  return false;
304 }
305 
306 /*
307  * IsPinnedObject
308  * Given the class + OID identity of a database object, report whether
309  * it is "pinned", that is not droppable because the system requires it.
310  *
311  * We used to represent this explicitly in pg_depend, but that proved to be
312  * an undesirable amount of overhead, so now we rely on an OID range test.
313  */
314 bool
315 IsPinnedObject(Oid classId, Oid objectId)
316 {
317  /*
318  * Objects with OIDs above FirstUnpinnedObjectId are never pinned. Since
319  * the OID generator skips this range when wrapping around, this check
320  * guarantees that user-defined objects are never considered pinned.
321  */
322  if (objectId >= FirstUnpinnedObjectId)
323  return false;
324 
325  /*
326  * Large objects are never pinned. We need this special case because
327  * their OIDs can be user-assigned.
328  */
329  if (classId == LargeObjectRelationId)
330  return false;
331 
332  /*
333  * There are a few objects defined in the catalog .dat files that, as a
334  * matter of policy, we prefer not to treat as pinned. We used to handle
335  * that by excluding them from pg_depend, but it's just as easy to
336  * hard-wire their OIDs here. (If the user does indeed drop and recreate
337  * them, they'll have new but certainly-unpinned OIDs, so no problem.)
338  *
339  * Checking both classId and objectId is overkill, since OIDs below
340  * FirstGenbkiObjectId should be globally unique, but do it anyway for
341  * robustness.
342  */
343 
344  /* the public namespace is not pinned */
345  if (classId == NamespaceRelationId &&
346  objectId == PG_PUBLIC_NAMESPACE)
347  return false;
348 
349  /*
350  * Databases are never pinned. It might seem that it'd be prudent to pin
351  * at least template0; but we do this intentionally so that template0 and
352  * template1 can be rebuilt from each other, thus letting them serve as
353  * mutual backups (as long as you've not modified template1, anyway).
354  */
355  if (classId == DatabaseRelationId)
356  return false;
357 
358  /*
359  * All other initdb-created objects are pinned. This is overkill (the
360  * system doesn't really depend on having every last weird datatype, for
361  * instance) but generating only the minimum required set of dependencies
362  * seems hard, and enforcing an accurate list would be much more expensive
363  * than the simple range test used here.
364  */
365  return true;
366 }
367 
368 
369 /*
370  * GetNewOidWithIndex
371  * Generate a new OID that is unique within the system relation.
372  *
373  * Since the OID is not immediately inserted into the table, there is a
374  * race condition here; but a problem could occur only if someone else
375  * managed to cycle through 2^32 OIDs and generate the same OID before we
376  * finish inserting our row. This seems unlikely to be a problem. Note
377  * that if we had to *commit* the row to end the race condition, the risk
378  * would be rather higher; therefore we use SnapshotAny in the test, so that
379  * we will see uncommitted rows. (We used to use SnapshotDirty, but that has
380  * the disadvantage that it ignores recently-deleted rows, creating a risk
381  * of transient conflicts for as long as our own MVCC snapshots think a
382  * recently-deleted row is live. The risk is far higher when selecting TOAST
383  * OIDs, because SnapshotToast considers dead rows as active indefinitely.)
384  *
385  * Note that we are effectively assuming that the table has a relatively small
386  * number of entries (much less than 2^32) and there aren't very long runs of
387  * consecutive existing OIDs. This is a mostly reasonable assumption for
388  * system catalogs.
389  *
390  * Caller must have a suitable lock on the relation.
391  */
392 Oid
393 GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
394 {
395  Oid newOid;
396  SysScanDesc scan;
398  bool collides;
399  uint64 retries = 0;
400  uint64 retries_before_log = GETNEWOID_LOG_THRESHOLD;
401 
402  /* Only system relations are supported */
403  Assert(IsSystemRelation(relation));
404 
405  /* In bootstrap mode, we don't have any indexes to use */
407  return GetNewObjectId();
408 
409  /*
410  * We should never be asked to generate a new pg_type OID during
411  * pg_upgrade; doing so would risk collisions with the OIDs it wants to
412  * assign. Hitting this assert means there's some path where we failed to
413  * ensure that a type OID is determined by commands in the dump script.
414  */
415  Assert(!IsBinaryUpgrade || RelationGetRelid(relation) != TypeRelationId);
416 
417  /* Generate new OIDs until we find one not in the table */
418  do
419  {
421 
422  newOid = GetNewObjectId();
423 
424  ScanKeyInit(&key,
425  oidcolumn,
426  BTEqualStrategyNumber, F_OIDEQ,
427  ObjectIdGetDatum(newOid));
428 
429  /* see notes above about using SnapshotAny */
430  scan = systable_beginscan(relation, indexId, true,
431  SnapshotAny, 1, &key);
432 
433  collides = HeapTupleIsValid(systable_getnext(scan));
434 
435  systable_endscan(scan);
436 
437  /*
438  * Log that we iterate more than GETNEWOID_LOG_THRESHOLD but have not
439  * yet found OID unused in the relation. Then repeat logging with
440  * exponentially increasing intervals until we iterate more than
441  * GETNEWOID_LOG_MAX_INTERVAL. Finally repeat logging every
442  * GETNEWOID_LOG_MAX_INTERVAL unless an unused OID is found. This
443  * logic is necessary not to fill up the server log with the similar
444  * messages.
445  */
446  if (retries >= retries_before_log)
447  {
448  ereport(LOG,
449  (errmsg("still searching for an unused OID in relation \"%s\"",
450  RelationGetRelationName(relation)),
451  errdetail_plural("OID candidates have been checked %llu time, but no unused OID has been found yet.",
452  "OID candidates have been checked %llu times, but no unused OID has been found yet.",
453  retries,
454  (unsigned long long) retries)));
455 
456  /*
457  * Double the number of retries to do before logging next until it
458  * reaches GETNEWOID_LOG_MAX_INTERVAL.
459  */
460  if (retries_before_log * 2 <= GETNEWOID_LOG_MAX_INTERVAL)
461  retries_before_log *= 2;
462  else
463  retries_before_log += GETNEWOID_LOG_MAX_INTERVAL;
464  }
465 
466  retries++;
467  } while (collides);
468 
469  /*
470  * If at least one log message is emitted, also log the completion of OID
471  * assignment.
472  */
473  if (retries > GETNEWOID_LOG_THRESHOLD)
474  {
475  ereport(LOG,
476  (errmsg_plural("new OID has been assigned in relation \"%s\" after %llu retry",
477  "new OID has been assigned in relation \"%s\" after %llu retries",
478  retries,
479  RelationGetRelationName(relation), (unsigned long long) retries)));
480  }
481 
482  return newOid;
483 }
484 
485 /*
486  * GetNewRelFileNumber
487  * Generate a new relfilenumber that is unique within the
488  * database of the given tablespace.
489  *
490  * If the relfilenumber will also be used as the relation's OID, pass the
491  * opened pg_class catalog, and this routine will guarantee that the result
492  * is also an unused OID within pg_class. If the result is to be used only
493  * as a relfilenumber for an existing relation, pass NULL for pg_class.
494  *
495  * As with GetNewOidWithIndex(), there is some theoretical risk of a race
496  * condition, but it doesn't seem worth worrying about.
497  *
498  * Note: we don't support using this in bootstrap mode. All relations
499  * created by bootstrap have preassigned OIDs, so there's no need.
500  */
502 GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
503 {
504  RelFileLocatorBackend rlocator;
505  char *rpath;
506  bool collides;
507  BackendId backend;
508 
509  /*
510  * If we ever get here during pg_upgrade, there's something wrong; all
511  * relfilenumber assignments during a binary-upgrade run should be
512  * determined by commands in the dump script.
513  */
515 
516  switch (relpersistence)
517  {
518  case RELPERSISTENCE_TEMP:
519  backend = BackendIdForTempRelations();
520  break;
521  case RELPERSISTENCE_UNLOGGED:
522  case RELPERSISTENCE_PERMANENT:
523  backend = InvalidBackendId;
524  break;
525  default:
526  elog(ERROR, "invalid relpersistence: %c", relpersistence);
527  return InvalidRelFileNumber; /* placate compiler */
528  }
529 
530  /* This logic should match RelationInitPhysicalAddr */
531  rlocator.locator.spcOid = reltablespace ? reltablespace : MyDatabaseTableSpace;
532  rlocator.locator.dbOid =
533  (rlocator.locator.spcOid == GLOBALTABLESPACE_OID) ?
535 
536  /*
537  * The relpath will vary based on the backend ID, so we must initialize
538  * that properly here to make sure that any collisions based on filename
539  * are properly detected.
540  */
541  rlocator.backend = backend;
542 
543  do
544  {
546 
547  /* Generate the OID */
548  if (pg_class)
549  rlocator.locator.relNumber = GetNewOidWithIndex(pg_class, ClassOidIndexId,
550  Anum_pg_class_oid);
551  else
552  rlocator.locator.relNumber = GetNewObjectId();
553 
554  /* Check for existing file of same name */
555  rpath = relpath(rlocator, MAIN_FORKNUM);
556 
557  if (access(rpath, F_OK) == 0)
558  {
559  /* definite collision */
560  collides = true;
561  }
562  else
563  {
564  /*
565  * Here we have a little bit of a dilemma: if errno is something
566  * other than ENOENT, should we declare a collision and loop? In
567  * practice it seems best to go ahead regardless of the errno. If
568  * there is a colliding file we will get an smgr failure when we
569  * attempt to create the new relation file.
570  */
571  collides = false;
572  }
573 
574  pfree(rpath);
575  } while (collides);
576 
577  return rlocator.locator.relNumber;
578 }
579 
580 /*
581  * SQL callable interface for GetNewOidWithIndex(). Outside of initdb's
582  * direct insertions into catalog tables, and recovering from corruption, this
583  * should rarely be needed.
584  *
585  * Function is intentionally not documented in the user facing docs.
586  */
587 Datum
589 {
590  Oid reloid = PG_GETARG_OID(0);
592  Oid idxoid = PG_GETARG_OID(2);
593  Relation rel;
594  Relation idx;
595  HeapTuple atttuple;
596  Form_pg_attribute attform;
597  AttrNumber attno;
598  Oid newoid;
599 
600  /*
601  * As this function is not intended to be used during normal running, and
602  * only supports system catalogs (which require superuser permissions to
603  * modify), just checking for superuser ought to not obstruct valid
604  * usecases.
605  */
606  if (!superuser())
607  ereport(ERROR,
608  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
609  errmsg("must be superuser to call %s()",
610  "pg_nextoid")));
611 
612  rel = table_open(reloid, RowExclusiveLock);
613  idx = index_open(idxoid, RowExclusiveLock);
614 
615  if (!IsSystemRelation(rel))
616  ereport(ERROR,
617  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
618  errmsg("pg_nextoid() can only be used on system catalogs")));
619 
620  if (idx->rd_index->indrelid != RelationGetRelid(rel))
621  ereport(ERROR,
622  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
623  errmsg("index \"%s\" does not belong to table \"%s\"",
625  RelationGetRelationName(rel))));
626 
627  atttuple = SearchSysCacheAttName(reloid, NameStr(*attname));
628  if (!HeapTupleIsValid(atttuple))
629  ereport(ERROR,
630  (errcode(ERRCODE_UNDEFINED_COLUMN),
631  errmsg("column \"%s\" of relation \"%s\" does not exist",
633 
634  attform = ((Form_pg_attribute) GETSTRUCT(atttuple));
635  attno = attform->attnum;
636 
637  if (attform->atttypid != OIDOID)
638  ereport(ERROR,
639  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
640  errmsg("column \"%s\" is not of type oid",
641  NameStr(*attname))));
642 
644  idx->rd_index->indkey.values[0] != attno)
645  ereport(ERROR,
646  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
647  errmsg("index \"%s\" is not the index for column \"%s\"",
649  NameStr(*attname))));
650 
651  newoid = GetNewOidWithIndex(rel, idxoid, attno);
652 
653  ReleaseSysCache(atttuple);
656 
657  PG_RETURN_OID(newoid);
658 }
659 
660 /*
661  * SQL callable interface for StopGeneratingPinnedObjectIds().
662  *
663  * This is only to be used by initdb, so it's intentionally not documented in
664  * the user facing docs.
665  */
666 Datum
668 {
669  /*
670  * Belt-and-suspenders check, since StopGeneratingPinnedObjectIds will
671  * fail anyway in non-single-user mode.
672  */
673  if (!superuser())
674  ereport(ERROR,
675  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
676  errmsg("must be superuser to call %s()",
677  "pg_stop_making_pinned_objects")));
678 
680 
681  PG_RETURN_VOID();
682 }
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
int16 AttrNumber
Definition: attnum.h:21
int BackendId
Definition: backendid.h:21
#define BackendIdForTempRelations()
Definition: backendid.h:34
#define InvalidBackendId
Definition: backendid.h:23
#define NameStr(name)
Definition: c.h:682
bool IsToastRelation(Relation relation)
Definition: catalog.c:147
#define GETNEWOID_LOG_THRESHOLD
Definition: catalog.c:56
bool IsToastNamespace(Oid namespaceId)
Definition: catalog.c:202
bool IsSystemRelation(Relation relation)
Definition: catalog.c:75
Oid GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
Definition: catalog.c:393
RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
Definition: catalog.c:502
bool IsCatalogNamespace(Oid namespaceId)
Definition: catalog.c:184
bool IsToastClass(Form_pg_class reltuple)
Definition: catalog.c:167
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:105
bool IsPinnedObject(Oid classId, Oid objectId)
Definition: catalog.c:315
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:245
bool IsCatalogRelationOid(Oid relid)
Definition: catalog.c:122
bool IsReservedName(const char *name)
Definition: catalog.c:219
#define GETNEWOID_LOG_MAX_INTERVAL
Definition: catalog.c:57
Datum pg_nextoid(PG_FUNCTION_ARGS)
Definition: catalog.c:588
bool IsSystemClass(Oid relid, Form_pg_class reltuple)
Definition: catalog.c:87
Datum pg_stop_making_pinned_objects(PG_FUNCTION_ARGS)
Definition: catalog.c:667
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1179
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1294
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define LOG
Definition: elog.h:31
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
const char * name
Definition: encode.c:561
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_NAME(n)
Definition: fmgr.h:278
#define PG_RETURN_OID(x)
Definition: fmgr.h:360
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:599
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:506
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:387
bool IsBinaryUpgrade
Definition: globals.c:114
Oid MyDatabaseTableSpace
Definition: globals.c:91
Oid MyDatabaseId
Definition: globals.c:89
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:649
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:158
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:132
Assert(fmt[strlen(fmt) - 1] !='\n')
#define RowExclusiveLock
Definition: lockdefs.h:38
void pfree(void *pointer)
Definition: mcxt.c:1306
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:402
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:121
bool isTempToastNamespace(Oid namespaceId)
Definition: namespace.c:3212
NameData attname
Definition: pg_attribute.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:207
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
uintptr_t Datum
Definition: postgres.h:412
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:600
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
short access
Definition: preproc-type.c:36
#define RelationGetRelid(relation)
Definition: rel.h:501
#define RelationGetRelationName(relation)
Definition: rel.h:535
#define RelationGetNamespace(relation)
Definition: rel.h:542
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:520
Oid RelFileNumber
Definition: relpath.h:25
@ MAIN_FORKNUM
Definition: relpath.h:50
#define relpath(rlocator, forknum)
Definition: relpath.h:94
#define InvalidRelFileNumber
Definition: relpath.h:26
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define SnapshotAny
Definition: snapmgr.h:67
#define BTEqualStrategyNumber
Definition: stratnum.h:31
RelFileLocator locator
RelFileNumber relNumber
Form_pg_class rd_rel
Definition: rel.h:110
Definition: c.h:677
bool superuser(void)
Definition: superuser.c:46
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1221
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
Definition: syscache.c:1314
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
#define FirstUnpinnedObjectId
Definition: transam.h:196
Oid GetNewObjectId(void)
Definition: varsup.c:528
void StopGeneratingPinnedObjectIds(void)
Definition: varsup.c:625