65 #include "catalog/schemapg.h"
84 #include "utils/fmgroids.h"
93 #define RELCACHE_INIT_FILEMAGIC 0x573266
99 #if defined(RECOVER_RELATION_BUILD_MEMORY) && (RECOVER_RELATION_BUILD_MEMORY != 0)
100 #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
102 #define RECOVER_RELATION_BUILD_MEMORY 0
103 #ifdef DISCARD_CACHES_ENABLED
104 #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
184 #define MAX_EOXACT_LIST 32
189 #define EOXactListAdd(rel) \
191 if (eoxact_list_len < MAX_EOXACT_LIST) \
192 eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
194 eoxact_list_overflowed = true; \
209 #define RelationCacheInsert(RELATION, replace_allowed) \
211 RelIdCacheEnt *hentry; bool found; \
212 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
213 &((RELATION)->rd_id), \
214 HASH_ENTER, &found); \
218 Relation _old_rel = hentry->reldesc; \
219 Assert(replace_allowed); \
220 hentry->reldesc = (RELATION); \
221 if (RelationHasReferenceCountZero(_old_rel)) \
222 RelationDestroyRelation(_old_rel, false); \
223 else if (!IsBootstrapProcessingMode()) \
224 elog(WARNING, "leaking still-referenced relcache entry for \"%s\"", \
225 RelationGetRelationName(_old_rel)); \
228 hentry->reldesc = (RELATION); \
231 #define RelationIdCacheLookup(ID, RELATION) \
233 RelIdCacheEnt *hentry; \
234 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
238 RELATION = hentry->reldesc; \
243 #define RelationCacheDelete(RELATION) \
245 RelIdCacheEnt *hentry; \
246 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
247 &((RELATION)->rd_id), \
248 HASH_REMOVE, NULL); \
249 if (hentry == NULL) \
250 elog(WARNING, "failed to delete relcache entry for OID %u", \
251 (RELATION)->rd_id); \
284 #ifdef USE_ASSERT_CHECKING
285 static void AssertPendingSyncConsistency(
Relation relation);
294 static void formrdesc(
const char *relationName,
Oid relationReltype,
353 elog(
FATAL,
"cannot read pg_class without having selected a database");
378 if (force_non_historic)
398 return pg_class_tuple;
442 relation->
rd_rel = relationForm;
474 switch (relation->
rd_rel->relkind)
476 case RELKIND_RELATION:
477 case RELKIND_TOASTVALUE:
479 case RELKIND_MATVIEW:
480 case RELKIND_PARTITIONED_TABLE:
484 case RELKIND_PARTITIONED_INDEX:
533 relation->
rd_rel->reltype ? relation->
rd_rel->reltype : RECORDOID;
547 Anum_pg_attribute_attrelid,
551 Anum_pg_attribute_attnum,
562 AttributeRelidNumIndexId,
581 elog(
ERROR,
"invalid attribute number %d for relation \"%s\"",
589 if (attp->attnotnull)
591 if (attp->attgenerated == ATTRIBUTE_GENERATED_STORED)
597 if (attp->atthasmissing)
604 Anum_pg_attribute_attmissingval,
605 pg_attribute_desc->
rd_att,
615 if (attrmiss == NULL)
618 relation->
rd_rel->relnatts *
659 elog(
ERROR,
"pg_attribute catalog is missing %d attribute(s) for relation OID %u",
667 #ifdef USE_ASSERT_CHECKING
691 relation->
rd_rel->relchecks > 0)
702 if (relation->
rd_rel->relchecks > 0)
769 Anum_pg_rewrite_ev_class,
784 RewriteRelRulenameIndexId,
800 rule->ruleId = rewrite_form->oid;
802 rule->event = rewrite_form->ev_type -
'0';
803 rule->enabled = rewrite_form->ev_enabled;
804 rule->isInstead = rewrite_form->is_instead;
813 Anum_pg_rewrite_ev_action,
824 Anum_pg_rewrite_ev_qual,
843 relation->
rd_rel->relkind == RELKIND_VIEW &&
847 check_as_user = relation->
rd_rel->relowner;
863 if (numlocks >= maxlocks)
941 else if (rlock2 != NULL)
986 else if (policy2 != NULL)
1003 if (rsdesc1 == NULL && rsdesc2 == NULL)
1006 if ((rsdesc1 != NULL && rsdesc2 == NULL) ||
1007 (rsdesc1 == NULL && rsdesc2 != NULL))
1041 int in_progress_offset;
1062 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1069 "RelationBuildDesc workspace",
1100 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1118 Assert(relid == targetRelId);
1141 switch (relation->
rd_rel->relpersistence)
1143 case RELPERSISTENCE_UNLOGGED:
1144 case RELPERSISTENCE_PERMANENT:
1148 case RELPERSISTENCE_TEMP:
1176 elog(
ERROR,
"invalid relpersistence: %c",
1177 relation->
rd_rel->relpersistence);
1205 if (relation->
rd_rel->relkind == RELKIND_INDEX ||
1206 relation->
rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
1208 else if (RELKIND_HAS_TABLE_AM(relation->
rd_rel->relkind) ||
1209 relation->
rd_rel->relkind == RELKIND_SEQUENCE)
1211 else if (relation->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1230 if (relation->
rd_rel->relhasrules)
1238 if (relation->
rd_rel->relhastriggers)
1243 if (relation->
rd_rel->relrowsecurity)
1299 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1324 if (!RELKIND_HAS_STORAGE(relation->
rd_rel->relkind))
1327 if (relation->
rd_rel->reltablespace)
1336 if (relation->
rd_rel->relfilenode)
1359 elog(
ERROR,
"could not find pg_class entry for %u",
1363 relation->
rd_rel->reltablespace = physrel->reltablespace;
1364 relation->
rd_rel->relfilenode = physrel->relfilenode;
1375 relation->
rd_rel->relisshared);
1377 elog(
ERROR,
"could not find relation mapping for relation \"%s\", OID %u",
1430 Datum indclassDatum;
1431 Datum indoptionDatum;
1450 elog(
ERROR,
"cache lookup failed for index %u",
1464 elog(
ERROR,
"cache lookup failed for access method %u",
1465 relation->
rd_rel->relam);
1472 elog(
ERROR,
"relnatts disagrees with indnatts for index %u",
1505 int nsupport = indnatts * amsupport;
1530 Anum_pg_index_indcollation,
1543 Anum_pg_index_indclass,
1556 amsupport, indnkeyatts);
1562 Anum_pg_index_indoption,
1605 for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
1617 opFamily[attIndex] = opcentry->
opcfamily;
1618 opcInType[attIndex] = opcentry->
opcintype;
1619 if (maxSupportNumber > 0)
1620 memcpy(&indexSupport[attIndex * maxSupportNumber],
1667 ctl.keysize =
sizeof(
Oid);
1680 opcentry->
valid =
false;
1698 #ifdef DISCARD_CACHES_ENABLED
1700 opcentry->
valid =
false;
1703 if (opcentry->
valid)
1721 (operatorClassOid != OID_BTREE_OPS_OID &&
1722 operatorClassOid != INT2_BTREE_OPS_OID);
1731 Anum_pg_opclass_oid,
1742 opcentry->
opcfamily = opclassform->opcfamily;
1743 opcentry->
opcintype = opclassform->opcintype;
1746 elog(
ERROR,
"could not find tuple for opclass %u", operatorClassOid);
1758 Anum_pg_amproc_amprocfamily,
1762 Anum_pg_amproc_amproclefttype,
1766 Anum_pg_amproc_amprocrighttype,
1777 if (amprocform->amprocnum <= 0 ||
1779 elog(
ERROR,
"invalid amproc number %d for opclass %u",
1780 amprocform->amprocnum, operatorClassOid);
1790 opcentry->
valid =
true;
1814 if (relation->
rd_rel->relkind == RELKIND_SEQUENCE)
1842 elog(
ERROR,
"cache lookup failed for access method %u",
1843 relation->
rd_rel->relam);
1919 relation->
rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
1920 relation->
rd_rel->reltype = relationReltype;
1926 relation->
rd_rel->relisshared = isshared;
1928 relation->
rd_rel->reltablespace = GLOBALTABLESPACE_OID;
1931 relation->
rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;
1934 relation->
rd_rel->relispopulated =
true;
1936 relation->
rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
1937 relation->
rd_rel->relpages = 0;
1938 relation->
rd_rel->reltuples = -1;
1939 relation->
rd_rel->relallvisible = 0;
1940 relation->
rd_rel->relkind = RELKIND_RELATION;
1942 relation->
rd_rel->relam = HEAP_TABLE_AM_OID;
1960 has_not_null =
false;
1961 for (
i = 0;
i < natts;
i++)
1966 has_not_null |= attrs[
i].attnotnull;
2013 relation->
rd_rel->relam = HEAP_TABLE_AM_OID;
2022 relation->
rd_rel->relhasindex =
false;
2027 relation->
rd_rel->relhasindex =
true;
2092 if (rd->
rd_rel->relkind == RELKIND_INDEX ||
2093 rd->
rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
2132 .
name =
"relcache reference",
2220 #ifdef RELCACHE_FORCE_RELEASE
2264 relation->
rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
2298 elog(
ERROR,
"could not find pg_class tuple for index %u",
2327 elog(
ERROR,
"cache lookup failed for index %u",
2338 relation->
rd_index->indnullsnotdistinct =
index->indnullsnotdistinct;
2392 if (relation->
rd_rel->relkind == RELKIND_INDEX)
2474 if (remember_tupdesc)
2585 if ((relation->
rd_rel->relkind == RELKIND_INDEX ||
2586 relation->
rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
2702 elog(
ERROR,
"relation %u deleted while still in use", save_relid);
2716 keep_partkey = (relation->
rd_partkey != NULL);
2728 #define SWAPFIELD(fldtype, fldname) \
2730 fldtype _tmp = newrel->fldname; \
2731 newrel->fldname = relation->fldname; \
2732 relation->fldname = _tmp; \
2883 elog(
ERROR,
"relation %u is still open", rid);
3035 rebuildFirstList =
lcons(relation, rebuildFirstList);
3037 rebuildFirstList =
lappend(rebuildFirstList, relation);
3039 rebuildList =
lcons(relation, rebuildList);
3041 rebuildList =
lappend(rebuildList, relation);
3052 foreach(l, rebuildFirstList)
3058 foreach(l, rebuildList)
3099 #ifdef USE_ASSERT_CHECKING
3101 AssertPendingSyncConsistency(
Relation relation)
3103 bool relcache_verdict =
3106 RELKIND_HAS_STORAGE(relation->
rd_rel->relkind)) ||
3142 rels =
palloc(maxrels *
sizeof(*rels));
3150 if (locallock->
nLocks <= 0)
3159 if (nrels >= maxrels)
3162 rels =
repalloc(rels, maxrels *
sizeof(*rels));
3169 AssertPendingSyncConsistency(idhentry->
reldesc);
3171 for (
i = 0;
i < nrels;
i++)
3234 if (idhentry != NULL)
3266 bool clear_relcache =
false;
3282 #ifdef USE_ASSERT_CHECKING
3285 int expected_refcnt;
3332 elog(
WARNING,
"cannot remove relcache entry for \"%s\" because it has nonzero refcount",
3372 mySubid, parentSubid);
3383 if (idhentry != NULL)
3385 mySubid, parentSubid);
3442 elog(
WARNING,
"cannot remove relcache entry for \"%s\" because it has nonzero refcount",
3490 bool shared_relation,
3491 bool mapped_relation,
3492 char relpersistence,
3497 int natts = tupDesc->
natts;
3512 case DatabaseRelationId:
3513 case AuthIdRelationId:
3514 case AuthMemRelationId:
3515 case RelationRelationId:
3516 case AttributeRelationId:
3517 case ProcedureRelationId:
3518 case TypeRelationId:
3533 elog(
ERROR,
"shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
3537 Assert(mapped_relation || !shared_relation);
3575 has_not_null =
false;
3576 for (
i = 0;
i < natts;
i++)
3581 datt->attidentity = satt->attidentity;
3582 datt->attgenerated = satt->attgenerated;
3583 datt->attnotnull = satt->attnotnull;
3584 has_not_null |= satt->attnotnull;
3601 rel->
rd_rel->relnamespace = relnamespace;
3603 rel->
rd_rel->relkind = relkind;
3604 rel->
rd_rel->relnatts = natts;
3607 rel->
rd_rel->relowner = BOOTSTRAP_SUPERUSERID;
3610 rel->
rd_rel->relpersistence = relpersistence;
3611 switch (relpersistence)
3613 case RELPERSISTENCE_UNLOGGED:
3614 case RELPERSISTENCE_PERMANENT:
3618 case RELPERSISTENCE_TEMP:
3624 elog(
ERROR,
"invalid relpersistence: %c", relpersistence);
3629 if (relkind == RELKIND_MATVIEW)
3630 rel->
rd_rel->relispopulated =
false;
3632 rel->
rd_rel->relispopulated =
true;
3636 (relkind == RELKIND_RELATION ||
3637 relkind == RELKIND_MATVIEW ||
3638 relkind == RELKIND_PARTITIONED_TABLE))
3639 rel->
rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
3641 rel->
rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
3648 rel->
rd_rel->relisshared = shared_relation;
3652 for (
i = 0;
i < natts;
i++)
3655 rel->
rd_rel->reltablespace = reltablespace;
3657 if (mapped_relation)
3664 rel->
rd_rel->relfilenode = relfilenumber;
3670 rel->
rd_rel->relam = accessmtd;
3679 if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
3742 else if (relation->
rd_rel->relkind == RELKIND_INDEX)
3746 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3747 errmsg(
"index relfilenumber value not set when in binary upgrade mode")));
3752 else if (relation->
rd_rel->relkind == RELKIND_RELATION)
3756 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3757 errmsg(
"heap relfilenumber value not set when in binary upgrade mode")));
3764 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3765 errmsg(
"unexpected request for new relfilenumber in binary upgrade mode")));
3775 elog(
ERROR,
"could not find tuple for relation %u",
3821 newrlocator.
relNumber = newrelfilenumber;
3823 if (RELKIND_HAS_TABLE_AM(relation->
rd_rel->relkind))
3827 &freezeXid, &minmulti);
3829 else if (RELKIND_HAS_STORAGE(relation->
rd_rel->relkind))
3840 elog(
ERROR,
"relation \"%s\" does not have storage",
3859 Assert(classform->relfrozenxid == freezeXid);
3860 Assert(classform->relminmxid == minmulti);
3861 Assert(classform->relpersistence == persistence);
3874 relation->
rd_rel->relisshared,
3883 classform->relfilenode = newrelfilenumber;
3886 if (relation->
rd_rel->relkind != RELKIND_SEQUENCE)
3888 classform->relpages = 0;
3889 classform->reltuples = -1;
3890 classform->relallvisible = 0;
3892 classform->relfrozenxid = freezeXid;
3893 classform->relminmxid = minmulti;
3894 classform->relpersistence = persistence;
3948 #define INITRELCACHESIZE 400
3965 ctl.keysize =
sizeof(
Oid);
4024 formrdesc(
"pg_database", DatabaseRelation_Rowtype_Id,
true,
4026 formrdesc(
"pg_authid", AuthIdRelation_Rowtype_Id,
true,
4028 formrdesc(
"pg_auth_members", AuthMemRelation_Rowtype_Id,
true,
4030 formrdesc(
"pg_shseclabel", SharedSecLabelRelation_Rowtype_Id,
true,
4032 formrdesc(
"pg_subscription", SubscriptionRelation_Rowtype_Id,
true,
4035 #define NUM_CRITICAL_SHARED_RELS 5
4081 needNewCacheFile =
true;
4083 formrdesc(
"pg_class", RelationRelation_Rowtype_Id,
false,
4085 formrdesc(
"pg_attribute", AttributeRelation_Rowtype_Id,
false,
4087 formrdesc(
"pg_proc", ProcedureRelation_Rowtype_Id,
false,
4089 formrdesc(
"pg_type", TypeRelation_Rowtype_Id,
false,
4092 #define NUM_CRITICAL_LOCAL_RELS 4
4129 RelationRelationId);
4131 AttributeRelationId);
4135 OperatorClassRelationId);
4137 AccessMethodProcedureRelationId);
4143 #define NUM_CRITICAL_LOCAL_INDEXES 7
4163 DatabaseRelationId);
4165 DatabaseRelationId);
4173 SharedSecLabelRelationId);
4175 #define NUM_CRITICAL_SHARED_INDEXES 6
4201 bool restart =
false;
4220 errcode(ERRCODE_UNDEFINED_OBJECT),
4249 elog(
ERROR,
"invalid relowner in pg_class entry for \"%s\"",
4267 relation->
rd_rel->relhasrules =
false;
4270 if (relation->
rd_rel->relhastriggers && relation->
trigdesc == NULL)
4274 relation->
rd_rel->relhastriggers =
false;
4295 (RELKIND_HAS_TABLE_AM(relation->
rd_rel->relkind) || relation->
rd_rel->relkind == RELKIND_SEQUENCE))
4318 if (needNewCacheFile)
4357 errmsg_internal(
"could not open critical system index %u", indexoid));
4391 for (
i = 0;
i < natts;
i++)
4414 if (pgclassdesc == NULL)
4427 if (pgindexdesc == NULL)
4460 Anum_pg_attrdef_adrelid,
4477 elog(
WARNING,
"unexpected pg_attrdef record found for attribute %d of relation \"%s\"",
4483 Anum_pg_attrdef_adbin,
4486 elog(
WARNING,
"null adbin for attribute %d of relation \"%s\"",
4493 attrdef[found].
adnum = adform->adnum;
4504 elog(
WARNING,
"%d pg_attrdef record(s) missing for relation \"%s\"",
4542 int ncheck = relation->
rd_rel->relchecks;
4556 Anum_pg_constraint_conrelid,
4571 if (conform->contype != CONSTRAINT_CHECK)
4575 if (found >= ncheck)
4577 elog(
WARNING,
"unexpected pg_constraint record found for relation \"%s\"",
4582 check[found].
ccvalid = conform->convalidated;
4589 Anum_pg_constraint_conbin,
4590 conrel->
rd_att, &isnull);
4608 if (found != ncheck)
4609 elog(
WARNING,
"%d pg_constraint record(s) missing for relation \"%s\"",
4666 if (!relation->
rd_rel->relhastriggers &&
4667 relation->
rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
4680 Anum_pg_constraint_conrelid,
4694 if (constraint->contype != CONSTRAINT_FOREIGN)
4698 info->
conoid = constraint->oid;
4699 info->
conrelid = constraint->conrelid;
4700 info->
confrelid = constraint->confrelid;
4706 NULL, NULL, NULL, NULL);
4709 result =
lappend(result, info);
4768 char replident = relation->
rd_rel->relreplident;
4771 bool pkdeferrable =
false;
4788 Anum_pg_index_indrelid,
4806 if (!
index->indislive)
4818 if (!
index->indisunique ||
4840 if (
index->indisprimary &&
4841 (
index->indisvalid ||
4842 relation->
rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
4844 pkeyIndex =
index->indexrelid;
4845 pkdeferrable = !
index->indimmediate;
4848 if (!
index->indimmediate)
4851 if (!
index->indisvalid)
4855 if (
index->indisreplident)
4856 candidateIndex =
index->indexrelid;
4872 if (replident == REPLICA_IDENTITY_DEFAULT &&
OidIsValid(pkeyIndex) && !pkdeferrable)
4874 else if (replident == REPLICA_IDENTITY_INDEX &&
OidIsValid(candidateIndex))
4936 Anum_pg_statistic_ext_stxrelid,
5048 Anum_pg_index_indexprs,
5100 Anum_pg_index_indexprs,
5110 foreach(lc, rawExprs)
5161 Anum_pg_index_indpred,
5239 List *newindexoidlist;
5261 elog(
ERROR,
"unknown attrKind %u", attrKind);
5276 if (indexoidlist ==
NIL)
5300 pkindexattrs = NULL;
5301 idindexattrs = NULL;
5302 hotblockingattrs = NULL;
5303 summarizedattrs = NULL;
5304 foreach(l, indexoidlist)
5310 Node *indexExpressions;
5311 Node *indexPredicate;
5334 indexExpressions = NULL;
5341 indexPredicate = NULL;
5344 isKey = indexDesc->
rd_index->indisunique &&
5345 indexExpressions == NULL &&
5346 indexPredicate == NULL;
5349 isPK = (indexOid == relpkindex);
5352 isIDKey = (indexOid == relreplindex);
5360 attrs = &summarizedattrs;
5362 attrs = &hotblockingattrs;
5365 for (
i = 0;
i < indexDesc->
rd_index->indnatts;
i++)
5367 int attrnum = indexDesc->
rd_index->indkey.values[
i];
5388 if (isKey && i < indexDesc->rd_index->indnkeyatts)
5392 if (isPK && i < indexDesc->rd_index->indnkeyatts)
5396 if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
5418 if (
equal(indexoidlist, newindexoidlist) &&
5475 return pkindexattrs;
5477 return idindexattrs;
5479 return hotblockingattrs;
5481 return summarizedattrs;
5483 elog(
ERROR,
"unknown attrKind %u", attrKind);
5533 elog(
ERROR,
"could not open relation with OID %u",
5537 for (
i = 0;
i < indexDesc->
rd_index->indnatts;
i++)
5539 int attrnum = indexDesc->
rd_index->indkey.values[
i];
5547 if (i < indexDesc->rd_index->indnkeyatts)
5565 return idindexattrs;
5601 *operators = ops = (
Oid *)
palloc(
sizeof(
Oid) * indnkeyatts);
5602 *procs = funcs = (
Oid *)
palloc(
sizeof(
Oid) * indnkeyatts);
5608 memcpy(ops, indexRelation->
rd_exclops,
sizeof(
Oid) * indnkeyatts);
5609 memcpy(funcs, indexRelation->
rd_exclprocs,
sizeof(
Oid) * indnkeyatts);
5624 Anum_pg_constraint_conrelid,
5642 if ((conform->contype != CONSTRAINT_EXCLUSION &&
5643 !(conform->conperiod && (
5644 conform->contype == CONSTRAINT_PRIMARY
5645 || conform->contype == CONSTRAINT_UNIQUE))) ||
5651 elog(
ERROR,
"unexpected exclusion constraint record found for rel %s",
5657 Anum_pg_constraint_conexclop,
5658 conrel->
rd_att, &isnull);
5660 elog(
ERROR,
"null conexclop for rel %s",
5666 nelem != indnkeyatts ||
5669 elog(
ERROR,
"conexclop is not a 1-D Oid array");
5678 elog(
ERROR,
"exclusion constraint record missing for rel %s",
5682 for (
i = 0;
i < indnkeyatts;
i++)
5689 elog(
ERROR,
"could not find strategy for operator %u in family %u",
5698 memcpy(indexRelation->
rd_exclops, ops,
sizeof(
Oid) * indnkeyatts);
5699 memcpy(indexRelation->
rd_exclprocs, funcs,
sizeof(
Oid) * indnkeyatts);
5756 if (relation->
rd_rel->relispartition)
5761 foreach(lc, ancestors)
5774 foreach(lc, puboids)
5783 elog(
ERROR,
"cache lookup failed for publication %u", pubid);
5799 if (!pubform->puballtables &&
5800 (pubform->pubupdate || pubform->pubdelete) &&
5802 pubform->pubviaroot))
5804 if (pubform->pubupdate)
5806 if (pubform->pubdelete)
5816 if (!pubform->puballtables &&
5817 (pubform->pubupdate || pubform->pubdelete) &&
5819 pubform->pubviaroot))
5821 if (pubform->pubupdate)
5823 if (pubform->pubdelete)
5868 for (
int i = 0;
i < natts;
i++)
5900 for (
i = 0;
i < natts;
i++)
5908 if (attoptions != (
Datum) 0)
5921 for (
i = 0;
i < natts;
i++)
5965 const char *colname;
5968 if (
attnum > 0 && attnum <= reldesc->natts)
6077 snprintf(initfilename,
sizeof(initfilename),
"global/%s",
6080 snprintf(initfilename,
sizeof(initfilename),
"%s/%s",
6095 nailed_rels = nailed_indexes = 0;
6098 if (fread(&magic, 1,
sizeof(magic), fp) !=
sizeof(magic))
6103 for (relno = 0;; relno++)
6112 nread = fread(&
len, 1,
sizeof(
len), fp);
6113 if (nread !=
sizeof(
len))
6125 if (num_rels >= max_rels)
6134 if (fread(rel, 1,
len, fp) !=
len)
6138 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6142 if (fread(relform, 1,
len, fp) !=
len)
6151 rel->
rd_att->
tdtypeid = relform->reltype ? relform->reltype : RECORDOID;
6155 has_not_null =
false;
6156 for (
i = 0;
i < relform->relnatts;
i++)
6160 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6164 if (fread(attr, 1,
len, fp) !=
len)
6167 has_not_null |= attr->attnotnull;
6171 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6199 if (rel->
rd_rel->relkind == RELKIND_INDEX)
6214 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6245 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6249 if (fread(opfamily, 1,
len, fp) !=
len)
6255 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6259 if (fread(opcintype, 1,
len, fp) !=
len)
6265 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6268 if (fread(support, 1,
len, fp) !=
len)
6274 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6278 if (fread(indcollation, 1,
len, fp) !=
len)
6284 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6288 if (fread(indoption, 1,
len, fp) !=
len)
6297 for (
i = 0;
i < relform->relnatts;
i++)
6299 if (fread(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6322 if (RELKIND_HAS_TABLE_AM(rel->
rd_rel->relkind) || rel->
rd_rel->relkind == RELKIND_SEQUENCE)
6421 elog(
WARNING,
"found %d nailed shared rels and %d nailed shared indexes in init file, but expected %d and %d respectively",
6422 nailed_rels, nailed_indexes,
6435 elog(
WARNING,
"found %d nailed rels and %d nailed indexes in init file, but expected %d and %d respectively",
6436 nailed_rels, nailed_indexes,
6448 for (relno = 0; relno < num_rels; relno++)
6503 snprintf(tempfilename,
sizeof(tempfilename),
"global/%s.%d",
6505 snprintf(finalfilename,
sizeof(finalfilename),
"global/%s",
6510 snprintf(tempfilename,
sizeof(tempfilename),
"%s/%s.%d",
6512 snprintf(finalfilename,
sizeof(finalfilename),
"%s/%s",
6516 unlink(tempfilename);
6527 errmsg(
"could not create relation-cache initialization file \"%s\": %m",
6529 errdetail(
"Continuing anyway, but there's something wrong.")));
6538 if (fwrite(&magic, 1,
sizeof(magic), fp) !=
sizeof(magic))
6554 if (relform->relisshared != shared)
6581 for (
i = 0;
i < relform->relnatts;
i++)
6596 if (rel->
rd_rel->relkind == RELKIND_INDEX)
6606 relform->relnatts *
sizeof(
Oid),
6611 relform->relnatts *
sizeof(
Oid),
6621 relform->relnatts *
sizeof(
Oid),
6626 relform->relnatts *
sizeof(
int16),
6632 for (
i = 0;
i < relform->relnatts;
i++)
6677 if (rename(tempfilename, finalfilename) < 0)
6678 unlink(tempfilename);
6683 unlink(tempfilename);
6693 if (fwrite(&
len, 1,
sizeof(
len), fp) !=
sizeof(
len))
6716 if (relationId == SharedSecLabelRelationId ||
6717 relationId == TriggerRelidNameIndexId ||
6718 relationId == DatabaseNameIndexId ||
6719 relationId == SharedSecLabelObjectIndexId)
6760 snprintf(localinitfname,
sizeof(localinitfname),
"%s/%s",
6762 snprintf(sharedinitfname,
sizeof(sharedinitfname),
"global/%s",
6796 const char *tblspcdir =
"pg_tblspc";
6801 snprintf(path,
sizeof(path),
"global/%s",
6813 if (strspn(de->
d_name,
"0123456789") == strlen(de->
d_name))
6816 snprintf(path,
sizeof(path),
"%s/%s/%s",
6838 if (strspn(de->
d_name,
"0123456789") == strlen(de->
d_name))
6841 snprintf(initfilename,
sizeof(initfilename),
"%s/%s/%s",
6853 if (unlink(initfilename) < 0)
6856 if (errno != ENOENT)
6859 errmsg(
"could not remove cache file \"%s\": %m",
IndexAmRoutine * GetIndexAmRoutine(Oid amhandler)
bytea *(* amoptions_function)(Datum reloptions, bool validate)
#define DatumGetArrayTypeP(X)
Datum array_get_element(Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
void bms_free(Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_copy(const Bitmapset *a)
#define TextDatumGetCString(d)
#define TopSubTransactionId
#define InvalidSubTransactionId
#define Assert(condition)
TransactionId MultiXactId
#define PointerIsValid(pointer)
#define OidIsValid(objectId)
bool IsSystemRelation(Relation relation)
RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
bool IsCatalogNamespace(Oid namespaceId)
bool IsCatalogRelation(Relation relation)
bool IsSharedRelation(Oid relationId)
void CreateCacheMemoryContext(void)
Node * eval_const_expressions(PlannerInfo *root, Node *node)
Datum datumCopy(Datum value, bool typByVal, int typLen)
static void PGresult * res
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
void hash_seq_term(HASH_SEQ_STATUS *status)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
void * hash_seq_search(HASH_SEQ_STATUS *status)
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
int err_generic_string(int field, const char *str)
int errmsg_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errdetail(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
bool equal(const void *a, const void *b)
FILE * AllocateFile(const char *name, const char *mode)
struct dirent * ReadDirExtended(DIR *dir, const char *dirname, int elevel)
DIR * AllocateDir(const char *dirname)
void systable_endscan(SysScanDesc sysscan)
HeapTuple systable_getnext(SysScanDesc sysscan)
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber
const TableAmRoutine * GetHeapamTableAmRoutine(void)
HeapTuple heap_copytuple(HeapTuple tuple)
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
void heap_freetuple(HeapTuple htup)
HeapTupleData * HeapTuple
HeapTupleHeaderData * HeapTupleHeader
#define HeapTupleIsValid(tuple)
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
#define HeapTupleHeaderSetXmin(tup, xid)
#define HeapTupleHeaderGetXmin(tup)
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
#define IsParallelWorker()
RelFileNumber binary_upgrade_next_index_pg_class_relfilenumber
void index_close(Relation relation, LOCKMODE lockmode)
Relation index_open(Oid relationId, LOCKMODE lockmode)
bytea * index_opclass_options(Relation indrel, AttrNumber attnum, Datum attoptions, bool validate)
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
static int pg_cmp_s16(int16 a, int16 b)
void AcceptInvalidationMessages(void)
void CacheInvalidateRelcache(Relation relation)
void list_sort(List *list, list_sort_comparator cmp)
List * list_concat_unique_oid(List *list1, const List *list2)
List * lappend(List *list, void *datum)
List * lappend_oid(List *list, Oid datum)
List * list_copy(const List *oldlist)
int list_oid_cmp(const ListCell *p1, const ListCell *p2)
void list_free(List *list)
List * lcons(void *datum, List *list)
void list_free_deep(List *list)
void UnlockRelationOid(Oid relid, LOCKMODE lockmode)
void RelationInitLockInfo(Relation relation)
void LockRelationOid(Oid relid, LOCKMODE lockmode)
char * get_namespace_name(Oid nspid)
Datum get_attoptions(Oid relid, int16 attnum)
Oid get_rel_namespace(Oid relid)
RegProcedure get_opcode(Oid opno)
int get_op_opfamily_strategy(Oid opno, Oid opfamily)
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
List * make_ands_implicit(Expr *clause)
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
void MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
void pfree(void *pointer)
void MemoryContextDeleteChildren(MemoryContext context)
void * palloc0(Size size)
void * MemoryContextAllocZero(MemoryContext context, Size size)
MemoryContext CurrentMemoryContext
void * repalloc(void *pointer, Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
char * MemoryContextStrdup(MemoryContext context, const char *string)
MemoryContext CacheMemoryContext
void MemoryContextDelete(MemoryContext context)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
#define ALLOCSET_SMALL_SIZES
#define MemoryContextCopyAndSetIdentifier(cxt, id)
#define IsBootstrapProcessingMode()
#define InvalidMultiXactId
void namestrcpy(Name name, const char *str)
bool isTempOrTempToastNamespace(Oid namespaceId)
ProcNumber GetTempNamespaceProcNumber(Oid namespaceId)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
void fix_opfuncids(Node *node)
List * get_partition_ancestors(Oid relid)
FormData_pg_am * Form_pg_am
static AmcheckOptions opts
FormData_pg_amproc * Form_pg_amproc
FormData_pg_attrdef * Form_pg_attrdef
#define ATTRIBUTE_FIXED_PART_SIZE
FormData_pg_attribute * Form_pg_attribute
#define ERRCODE_DATA_CORRUPTED
FormData_pg_class * Form_pg_class
void DeconstructFkConstraintRow(HeapTuple tuple, int *numfks, AttrNumber *conkey, AttrNumber *confkey, Oid *pf_eq_oprs, Oid *pp_eq_oprs, Oid *ff_eq_oprs, int *num_fk_del_set_cols, AttrNumber *fk_del_set_cols)
FormData_pg_constraint * Form_pg_constraint
FormData_pg_index * Form_pg_index
static int list_length(const List *l)
#define forboth(cell1, list1, cell2, list2)
FormData_pg_opclass * Form_pg_opclass
List * GetSchemaPublications(Oid schemaid)
List * GetRelationPublications(Oid relid)
List * GetAllTablesPublications(void)
bool is_publishable_relation(Relation rel)
FormData_pg_publication * Form_pg_publication
FormData_pg_rewrite * Form_pg_rewrite
FormData_pg_statistic_ext * Form_pg_statistic_ext
void pgstat_unlink_relation(Relation rel)
void RelationBuildRowSecurity(Relation relation)
#define qsort(a, b, c, d)
static Datum PointerGetDatum(const void *X)
static Datum Int16GetDatum(int16 X)
static Datum ObjectIdGetDatum(Oid X)
static Pointer DatumGetPointer(Datum X)
#define PG_DIAG_SCHEMA_NAME
#define PG_DIAG_CONSTRAINT_NAME
#define PG_DIAG_TABLE_NAME
#define PG_DIAG_COLUMN_NAME
Expr * canonicalize_qual(Expr *qual, bool is_check)
#define ProcNumberForTempRelations()
#define INVALID_PROC_NUMBER
char * psprintf(const char *fmt,...)
bool pub_rf_contains_invalid_column(Oid pubid, Relation relation, List *ancestors, bool pubviaroot)
bool pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestors, bool pubviaroot)
MemoryContextSwitchTo(old_ctx)
void * stringToNode(const char *str)
#define RelationGetForm(relation)
#define RelationHasReferenceCountZero(relation)
#define RelationGetRelid(relation)
#define RelationHasSecurityInvoker(relation)
#define RelationGetDescr(relation)
#define RelationIsMapped(relation)
#define RelationGetNumberOfAttributes(relation)
#define RelationGetRelationName(relation)
#define RelationIsAccessibleInLogicalDecoding(relation)
#define RelationIsValid(relation)
#define RelationGetNamespace(relation)
#define IndexRelationGetNumberOfAttributes(relation)
#define IndexRelationGetNumberOfKeyAttributes(relation)
#define RelationIsPermanent(relation)
static void RelationCloseSmgr(Relation relation)
#define RECOVER_RELATION_BUILD_MEMORY
static int NextEOXactTupleDescNum
static bool load_relcache_init_file(bool shared)
void RelationBuildPublicationDesc(Relation relation, PublicationDesc *pubdesc)
static void RelationParseRelOptions(Relation relation, HeapTuple tuple)
List * RelationGetIndexList(Relation relation)
void RelationCacheInvalidate(bool debug_discard)
#define NUM_CRITICAL_LOCAL_RELS
#define NUM_CRITICAL_SHARED_INDEXES
#define RelationCacheInsert(RELATION, replace_allowed)
void RelationDecrementReferenceCount(Relation rel)
static Relation RelationBuildDesc(Oid targetRelId, bool insertIt)
bool criticalRelcachesBuilt
static TupleDesc BuildHardcodedDescriptor(int natts, const FormData_pg_attribute *attrs)
static const FormData_pg_attribute Desc_pg_shseclabel[Natts_pg_shseclabel]
bool criticalSharedRelcachesBuilt
static Oid eoxact_list[MAX_EOXACT_LIST]
static void formrdesc(const char *relationName, Oid relationReltype, bool isshared, int natts, const FormData_pg_attribute *attrs)
Oid RelationGetPrimaryKeyIndex(Relation relation)
static void ResOwnerReleaseRelation(Datum res)
static Relation AllocateRelationDesc(Form_pg_class relp)
static const FormData_pg_attribute Desc_pg_database[Natts_pg_database]
static void unlink_initfile(const char *initfilename, int elevel)
int errtableconstraint(Relation rel, const char *conname)
int errtablecol(Relation rel, int attnum)
void RelationInitIndexAccessInfo(Relation relation)
static void InitIndexAmRoutine(Relation relation)
static void write_item(const void *data, Size len, FILE *fp)
List * RelationGetIndexPredicate(Relation relation)
static const FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute]
List * RelationGetStatExtList(Relation relation)
static bool equalRuleLocks(RuleLock *rlock1, RuleLock *rlock2)
static int in_progress_list_maxlen
static int CheckConstraintCmp(const void *a, const void *b)
void AtEOSubXact_RelationCache(bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
static void ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel)
static const FormData_pg_attribute Desc_pg_class[Natts_pg_class]
static void RelationReloadNailed(Relation relation)
static const FormData_pg_attribute Desc_pg_authid[Natts_pg_authid]
static TupleDesc GetPgClassDescriptor(void)
static void AttrDefaultFetch(Relation relation, int ndef)
static HTAB * OpClassCache
static const ResourceOwnerDesc relref_resowner_desc
static void IndexSupportInitialize(oidvector *indclass, RegProcedure *indexSupport, Oid *opFamily, Oid *opcInType, StrategyNumber maxSupportNumber, AttrNumber maxAttributeNumber)
void RelationIncrementReferenceCount(Relation rel)
#define RelationCacheDelete(RELATION)
void RelationCacheInitFilePostInvalidate(void)
Bitmapset * RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
void RelationCacheInitializePhase3(void)
#define NUM_CRITICAL_SHARED_RELS
List * RelationGetDummyIndexExpressions(Relation relation)
static void RelationDestroyRelation(Relation relation, bool remember_tupdesc)
static void RelationClearRelation(Relation relation, bool rebuild)
List * RelationGetFKeyList(Relation relation)
#define EOXactListAdd(rel)
#define RelationIdCacheLookup(ID, RELATION)
void RelationInitTableAccessMethod(Relation relation)
static const FormData_pg_attribute Desc_pg_subscription[Natts_pg_subscription]
static void RelationFlushRelation(Relation relation)
static void RelationBuildRuleLock(Relation relation)
static void ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel)
static int in_progress_list_len
static const FormData_pg_attribute Desc_pg_proc[Natts_pg_proc]
void RelationSetNewRelfilenumber(Relation relation, char persistence)
static const FormData_pg_attribute Desc_pg_index[Natts_pg_index]
static int EOXactTupleDescArrayLen
Oid RelationGetReplicaIndex(Relation relation)
Relation RelationIdGetRelation(Oid relationId)
static TupleDesc GetPgIndexDescriptor(void)
static void RelationCloseCleanup(Relation relation)
#define NUM_CRITICAL_LOCAL_INDEXES
static const FormData_pg_attribute Desc_pg_auth_members[Natts_pg_auth_members]
static void RelationCacheInitFileRemoveInDir(const char *tblspcpath)
static char * ResOwnerPrintRelCache(Datum res)
void AtEOXact_RelationCache(bool isCommit)
static void CheckConstraintFetch(Relation relation)
void RelationForgetRelation(Oid rid)
static void AtEOSubXact_cleanup(Relation relation, bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void RelationCacheInitialize(void)
void RelationCacheInitFilePreInvalidate(void)
static bytea ** CopyIndexAttOptions(bytea **srcopts, int natts)
static void write_relcache_init_file(bool shared)
Relation RelationBuildLocalRelation(const char *relname, Oid relnamespace, TupleDesc tupDesc, Oid relid, Oid accessmtd, RelFileNumber relfilenumber, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)
void RelationAssumeNewRelfilelocator(Relation relation)
static void RememberToFreeTupleDescAtEOX(TupleDesc td)
static HeapTuple ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic)
static void RelationInitPhysicalAddr(Relation relation)
static void RelationBuildTupleDesc(Relation relation)
static bool equalRSDesc(RowSecurityDesc *rsdesc1, RowSecurityDesc *rsdesc2)
void RelationCacheInitFileRemove(void)
static void AtEOXact_cleanup(Relation relation, bool isCommit)
int errtablecolname(Relation rel, const char *colname)
struct relidcacheent RelIdCacheEnt
static const FormData_pg_attribute Desc_pg_type[Natts_pg_type]
void RelationCacheInitializePhase2(void)
static InProgressEnt * in_progress_list
bool RelationIdIsInInitFile(Oid relationId)
static void RelationReloadIndexInfo(Relation relation)
static long relcacheInvalsReceived
static void load_critical_index(Oid indexoid, Oid heapoid)
static void InitTableAmRoutine(Relation relation)
int errtable(Relation rel)
void RelationCacheInvalidateEntry(Oid relationId)
static bool equalPolicy(RowSecurityPolicy *policy1, RowSecurityPolicy *policy2)
bytea ** RelationGetIndexAttOptions(Relation relation, bool copy)
Bitmapset * RelationGetIdentityKeyBitmap(Relation relation)
static int eoxact_list_len
struct opclasscacheent OpClassCacheEnt
static OpClassCacheEnt * LookupOpclassInfo(Oid operatorClassOid, StrategyNumber numSupport)
static TupleDesc * EOXactTupleDescArray
static bool eoxact_list_overflowed
void RelationGetExclusionInfo(Relation indexRelation, Oid **operators, Oid **procs, uint16 **strategies)
static int AttrDefaultCmp(const void *a, const void *b)
#define SWAPFIELD(fldtype, fldname)
#define RELCACHE_INIT_FILEMAGIC
List * RelationGetIndexExpressions(Relation relation)
static HTAB * RelationIdCache
struct inprogressent InProgressEnt
void RelationClose(Relation relation)
struct RelationData * Relation
#define RELCACHE_INIT_FILENAME
@ INDEX_ATTR_BITMAP_HOT_BLOCKING
@ INDEX_ATTR_BITMAP_PRIMARY_KEY
@ INDEX_ATTR_BITMAP_SUMMARIZED
@ INDEX_ATTR_BITMAP_IDENTITY_KEY
#define AssertPendingSyncs_RelationCache()
void RelationMapInvalidateAll(void)
void RelationMapInitialize(void)
void RelationMapInitializePhase2(void)
RelFileNumber RelationMapOidToFilenumber(Oid relationId, bool shared)
void RelationMapUpdateMap(Oid relationId, RelFileNumber fileNumber, bool shared, bool immediate)
void RelationMapInitializePhase3(void)
bytea * extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions)
#define InvalidRelFileNumber
#define TABLESPACE_VERSION_DIRECTORY
#define RelFileNumberIsValid(relnumber)
ResourceOwner CurrentResourceOwner
void ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerEnlarge(ResourceOwner owner)
@ RESOURCE_RELEASE_BEFORE_LOCKS
#define RELEASE_PRIO_RELCACHE_REFS
void setRuleCheckAsUser(Node *node, Oid userid)
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
SMgrRelation smgropen(RelFileLocator rlocator, ProcNumber backend)
void smgrreleaseall(void)
void smgrclose(SMgrRelation reln)
void smgrdounlinkall(SMgrRelation *rels, int nrels, bool isRedo)
Snapshot GetTransactionSnapshot(void)
void PushActiveSnapshot(Snapshot snapshot)
bool HistoricSnapshotActive(void)
void PopActiveSnapshot(void)
Snapshot GetNonHistoricCatalogSnapshot(Oid relid)
bool RelFileLocatorSkippingWAL(RelFileLocator rlocator)
SMgrRelation RelationCreateStorage(RelFileLocator rlocator, char relpersistence, bool register_delete)
void RelationDropStorage(Relation rel)
#define BTGreaterStrategyNumber
#define BTEqualStrategyNumber
amoptions_function amoptions
PublicationActions pubactions
bool cols_valid_for_delete
bool cols_valid_for_update
MemoryContext rd_partkeycxt
const struct TableAmRoutine * rd_tableam
TransactionId rd_partdesc_nodetached_xmin
struct IndexAmRoutine * rd_indam
SubTransactionId rd_firstRelfilelocatorSubid
struct RowSecurityDesc * rd_rsdesc
PartitionDesc rd_partdesc
RegProcedure * rd_support
PartitionDesc rd_partdesc_nodetached
PublicationDesc * rd_pubdesc
struct FdwRoutine * rd_fdwroutine
struct HeapTupleData * rd_indextuple
MemoryContext rd_partcheckcxt
Bitmapset * rd_hotblockingattr
SubTransactionId rd_newRelfilelocatorSubid
SubTransactionId rd_createSubid
MemoryContext rd_indexcxt
RelFileLocator rd_locator
struct FmgrInfo * rd_supportinfo
SubTransactionId rd_droppedSubid
MemoryContext rd_rulescxt
Bitmapset * rd_summarizedattr
struct PgStat_TableStatus * pgstat_info
bool has_generated_stored
struct AttrMissing * missing
int16 values[FLEXIBLE_ARRAY_MEMBER]
Oid values[FLEXIBLE_ARRAY_MEMBER]
StrategyNumber numSupport
RegProcedure * supportProcs
#define FirstLowInvalidHeapAttributeNumber
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
bool RelationSupportsSysCache(Oid relid)
void InitCatalogCachePhase2(void)
#define SearchSysCacheCopy1(cacheId, key1)
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
static void table_relation_set_new_filelocator(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
const TableAmRoutine * GetTableAmRoutine(Oid amhandler)
#define InvalidTransactionId
void FreeTriggerDesc(TriggerDesc *trigdesc)
void RelationBuildTriggers(Relation relation)
void FreeTupleDesc(TupleDesc tupdesc)
TupleDesc CreateTemplateTupleDesc(int natts)
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
bool equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
#define TupleDescAttr(tupdesc, i)
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
SubTransactionId GetCurrentSubTransactionId(void)
bool IsTransactionState(void)
void CommandCounterIncrement(void)
TransactionId GetCurrentTransactionId(void)
static struct rule * rules