PostgreSQL Source Code  git master
heap.c File Reference
#include "postgres.h"
#include "access/genam.h"
#include "access/multixact.h"
#include "access/relation.h"
#include "access/table.h"
#include "access/tableam.h"
#include "catalog/binary_upgrade.h"
#include "catalog/catalog.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/objectaccess.h"
#include "catalog/partition.h"
#include "catalog/pg_am.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_foreign_table.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_partitioned_table.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_subscription_rel.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_type.h"
#include "catalog/storage.h"
#include "commands/tablecmds.h"
#include "commands/typecmds.h"
#include "common/int.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parsetree.h"
#include "partitioning/partdesc.h"
#include "pgstat.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
Include dependency graph for heap.c:

Go to the source code of this file.

Functions

static void AddNewRelationTuple (Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Oid new_type_oid, Oid reloftype, Oid relowner, char relkind, TransactionId relfrozenxid, TransactionId relminmxid, Datum relacl, Datum reloptions)
 
static ObjectAddress AddNewRelationType (const char *typeName, Oid typeNamespace, Oid new_rel_oid, char new_rel_kind, Oid ownerid, Oid new_row_type, Oid new_array_type)
 
static void RelationRemoveInheritance (Oid relid)
 
static Oid StoreRelCheck (Relation rel, const char *ccname, Node *expr, bool is_validated, bool is_local, int16 inhcount, bool is_no_inherit, bool is_internal)
 
static void StoreConstraints (Relation rel, List *cooked_constraints, bool is_internal)
 
static bool MergeWithExistingConstraint (Relation rel, const char *ccname, Node *expr, bool allow_merge, bool is_local, bool is_initially_valid, bool is_no_inherit)
 
static void SetRelationNumChecks (Relation rel, int numchecks)
 
static NodecookConstraint (ParseState *pstate, Node *raw_constraint, char *relname)
 
const FormData_pg_attributeSystemAttributeDefinition (AttrNumber attno)
 
const FormData_pg_attributeSystemAttributeByName (const char *attname)
 
Relation heap_create (const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, RelFileNumber relfilenumber, Oid accessmtd, TupleDesc tupDesc, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, bool allow_system_table_mods, TransactionId *relfrozenxid, MultiXactId *relminmxid, bool create_storage)
 
void CheckAttributeNamesTypes (TupleDesc tupdesc, char relkind, int flags)
 
void CheckAttributeType (const char *attname, Oid atttypid, Oid attcollation, List *containing_rowtypes, int flags)
 
void InsertPgAttributeTuples (Relation pg_attribute_rel, TupleDesc tupdesc, Oid new_rel_oid, const FormExtraData_pg_attribute tupdesc_extra[], CatalogIndexState indstate)
 
static void AddNewAttributeTuples (Oid new_rel_oid, TupleDesc tupdesc, char relkind)
 
void InsertPgClassTuple (Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Datum relacl, Datum reloptions)
 
Oid heap_create_with_catalog (const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, Oid reltypeid, Oid reloftypeid, Oid ownerid, Oid accessmtd, TupleDesc tupdesc, List *cooked_constraints, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, OnCommitAction oncommit, Datum reloptions, bool use_user_acl, bool allow_system_table_mods, bool is_internal, Oid relrewrite, ObjectAddress *typaddress)
 
void DeleteRelationTuple (Oid relid)
 
void DeleteAttributeTuples (Oid relid)
 
void DeleteSystemAttributeTuples (Oid relid)
 
void RemoveAttributeById (Oid relid, AttrNumber attnum)
 
void heap_drop_with_catalog (Oid relid)
 
void RelationClearMissing (Relation rel)
 
void SetAttrMissing (Oid relid, char *attname, char *value)
 
ListAddRelationNewConstraints (Relation rel, List *newColDefaults, List *newConstraints, bool allow_merge, bool is_local, bool is_internal, const char *queryString)
 
static bool check_nested_generated_walker (Node *node, void *context)
 
static void check_nested_generated (ParseState *pstate, Node *node)
 
NodecookDefault (ParseState *pstate, Node *raw_default, Oid atttypid, int32 atttypmod, const char *attname, char attgenerated)
 
void CopyStatistics (Oid fromrelid, Oid torelid)
 
void RemoveStatistics (Oid relid, AttrNumber attnum)
 
static void RelationTruncateIndexes (Relation heapRelation)
 
void heap_truncate (List *relids)
 
void heap_truncate_one_rel (Relation rel)
 
void heap_truncate_check_FKs (List *relations, bool tempTables)
 
Listheap_truncate_find_FKs (List *relationIds)
 
void StorePartitionKey (Relation rel, char strategy, int16 partnatts, AttrNumber *partattrs, List *partexprs, Oid *partopclass, Oid *partcollation)
 
void RemovePartitionKeyByRelId (Oid relid)
 
void StorePartitionBound (Relation rel, Relation parent, PartitionBoundSpec *bound)
 

Variables

Oid binary_upgrade_next_heap_pg_class_oid = InvalidOid
 
Oid binary_upgrade_next_toast_pg_class_oid = InvalidOid
 
RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber = InvalidRelFileNumber
 
RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber = InvalidRelFileNumber
 
static const FormData_pg_attribute a1
 
static const FormData_pg_attribute a2
 
static const FormData_pg_attribute a3
 
static const FormData_pg_attribute a4
 
static const FormData_pg_attribute a5
 
static const FormData_pg_attribute a6
 
static const FormData_pg_attribute *const SysAtt [] = {&a1, &a2, &a3, &a4, &a5, &a6}
 

Function Documentation

◆ AddNewAttributeTuples()

static void AddNewAttributeTuples ( Oid  new_rel_oid,
TupleDesc  tupdesc,
char  relkind 
)
static

Definition at line 820 of file heap.c.

823 {
824  Relation rel;
825  CatalogIndexState indstate;
826  int natts = tupdesc->natts;
827  ObjectAddress myself,
828  referenced;
829 
830  /*
831  * open pg_attribute and its indexes.
832  */
833  rel = table_open(AttributeRelationId, RowExclusiveLock);
834 
835  indstate = CatalogOpenIndexes(rel);
836 
837  InsertPgAttributeTuples(rel, tupdesc, new_rel_oid, NULL, indstate);
838 
839  /* add dependencies on their datatypes and collations */
840  for (int i = 0; i < natts; i++)
841  {
842  Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
843 
844  /* Add dependency info */
845  ObjectAddressSubSet(myself, RelationRelationId, new_rel_oid, i + 1);
846  ObjectAddressSet(referenced, TypeRelationId, attr->atttypid);
847  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
848 
849  /* The default collation is pinned, so don't bother recording it */
850  if (OidIsValid(attr->attcollation) &&
851  attr->attcollation != DEFAULT_COLLATION_OID)
852  {
853  ObjectAddressSet(referenced, CollationRelationId,
854  attr->attcollation);
855  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
856  }
857  }
858 
859  /*
860  * Next we add the system attributes. Skip all for a view or type
861  * relation. We don't bother with making datatype dependencies here,
862  * since presumably all these types are pinned.
863  */
864  if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
865  {
866  TupleDesc td;
867 
869 
870  InsertPgAttributeTuples(rel, td, new_rel_oid, NULL, indstate);
871  FreeTupleDesc(td);
872  }
873 
874  /*
875  * clean up
876  */
877  CatalogCloseIndexes(indstate);
878 
880 }
#define lengthof(array)
Definition: c.h:791
#define OidIsValid(objectId)
Definition: c.h:778
@ DEPENDENCY_NORMAL
Definition: dependency.h:33
static const FormData_pg_attribute *const SysAtt[]
Definition: heap.c:232
void InsertPgAttributeTuples(Relation pg_attribute_rel, TupleDesc tupdesc, Oid new_rel_oid, const FormExtraData_pg_attribute tupdesc_extra[], CatalogIndexState indstate)
Definition: heap.c:702
void CatalogCloseIndexes(CatalogIndexState indstate)
Definition: indexing.c:61
CatalogIndexState CatalogOpenIndexes(Relation heapRel)
Definition: indexing.c:43
int i
Definition: isn.c:73
#define RowExclusiveLock
Definition: lockdefs.h:38
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)
Definition: objectaddress.h:33
FormData_pg_attribute
Definition: pg_attribute.h:193
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:46
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void FreeTupleDesc(TupleDesc tupdesc)
Definition: tupdesc.c:331
TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs)
Definition: tupdesc.c:112
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

References CatalogCloseIndexes(), CatalogOpenIndexes(), CreateTupleDesc(), DEPENDENCY_NORMAL, FormData_pg_attribute, FreeTupleDesc(), i, InsertPgAttributeTuples(), lengthof, TupleDescData::natts, ObjectAddressSet, ObjectAddressSubSet, OidIsValid, recordDependencyOn(), RowExclusiveLock, SysAtt, table_close(), table_open(), and TupleDescAttr.

Referenced by heap_create_with_catalog().

◆ AddNewRelationTuple()

static void AddNewRelationTuple ( Relation  pg_class_desc,
Relation  new_rel_desc,
Oid  new_rel_oid,
Oid  new_type_oid,
Oid  reloftype,
Oid  relowner,
char  relkind,
TransactionId  relfrozenxid,
TransactionId  relminmxid,
Datum  relacl,
Datum  reloptions 
)
static

Definition at line 969 of file heap.c.

980 {
981  Form_pg_class new_rel_reltup;
982 
983  /*
984  * first we update some of the information in our uncataloged relation's
985  * relation descriptor.
986  */
987  new_rel_reltup = new_rel_desc->rd_rel;
988 
989  /* The relation is empty */
990  new_rel_reltup->relpages = 0;
991  new_rel_reltup->reltuples = -1;
992  new_rel_reltup->relallvisible = 0;
993 
994  /* Sequences always have a known size */
995  if (relkind == RELKIND_SEQUENCE)
996  {
997  new_rel_reltup->relpages = 1;
998  new_rel_reltup->reltuples = 1;
999  }
1000 
1001  new_rel_reltup->relfrozenxid = relfrozenxid;
1002  new_rel_reltup->relminmxid = relminmxid;
1003  new_rel_reltup->relowner = relowner;
1004  new_rel_reltup->reltype = new_type_oid;
1005  new_rel_reltup->reloftype = reloftype;
1006 
1007  /* relispartition is always set by updating this tuple later */
1008  new_rel_reltup->relispartition = false;
1009 
1010  /* fill rd_att's type ID with something sane even if reltype is zero */
1011  new_rel_desc->rd_att->tdtypeid = new_type_oid ? new_type_oid : RECORDOID;
1012  new_rel_desc->rd_att->tdtypmod = -1;
1013 
1014  /* Now build and insert the tuple */
1015  InsertPgClassTuple(pg_class_desc, new_rel_desc, new_rel_oid,
1016  relacl, reloptions);
1017 }
void InsertPgClassTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Datum relacl, Datum reloptions)
Definition: heap.c:896
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
TupleDesc rd_att
Definition: rel.h:112
Form_pg_class rd_rel
Definition: rel.h:111
int32 tdtypmod
Definition: tupdesc.h:83
Oid tdtypeid
Definition: tupdesc.h:82

References InsertPgClassTuple(), RelationData::rd_att, RelationData::rd_rel, TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by heap_create_with_catalog().

◆ AddNewRelationType()

static ObjectAddress AddNewRelationType ( const char *  typeName,
Oid  typeNamespace,
Oid  new_rel_oid,
char  new_rel_kind,
Oid  ownerid,
Oid  new_row_type,
Oid  new_array_type 
)
static

Definition at line 1027 of file heap.c.

1034 {
1035  return
1036  TypeCreate(new_row_type, /* optional predetermined OID */
1037  typeName, /* type name */
1038  typeNamespace, /* type namespace */
1039  new_rel_oid, /* relation oid */
1040  new_rel_kind, /* relation kind */
1041  ownerid, /* owner's ID */
1042  -1, /* internal size (varlena) */
1043  TYPTYPE_COMPOSITE, /* type-type (composite) */
1044  TYPCATEGORY_COMPOSITE, /* type-category (ditto) */
1045  false, /* composite types are never preferred */
1046  DEFAULT_TYPDELIM, /* default array delimiter */
1047  F_RECORD_IN, /* input procedure */
1048  F_RECORD_OUT, /* output procedure */
1049  F_RECORD_RECV, /* receive procedure */
1050  F_RECORD_SEND, /* send procedure */
1051  InvalidOid, /* typmodin procedure - none */
1052  InvalidOid, /* typmodout procedure - none */
1053  InvalidOid, /* analyze procedure - default */
1054  InvalidOid, /* subscript procedure - none */
1055  InvalidOid, /* array element type - irrelevant */
1056  false, /* this is not an array type */
1057  new_array_type, /* array type if any */
1058  InvalidOid, /* domain base type - irrelevant */
1059  NULL, /* default value - none */
1060  NULL, /* default binary representation */
1061  false, /* passed by reference */
1062  TYPALIGN_DOUBLE, /* alignment - must be the largest! */
1063  TYPSTORAGE_EXTENDED, /* fully TOASTable */
1064  -1, /* typmod */
1065  0, /* array dimensions for typBaseType */
1066  false, /* Type NOT NULL */
1067  InvalidOid); /* rowtypes never have a collation */
1068 }
ObjectAddress TypeCreate(Oid newTypeOid, const char *typeName, Oid typeNamespace, Oid relationOid, char relationKind, Oid ownerId, int16 internalSize, char typeType, char typeCategory, bool typePreferred, char typDelim, Oid inputProcedure, Oid outputProcedure, Oid receiveProcedure, Oid sendProcedure, Oid typmodinProcedure, Oid typmodoutProcedure, Oid analyzeProcedure, Oid subscriptProcedure, Oid elementType, bool isImplicitArray, Oid arrayType, Oid baseType, const char *defaultTypeValue, char *defaultTypeBin, bool passedByValue, char alignment, char storage, int32 typeMod, int32 typNDims, bool typeNotNull, Oid typeCollation)
Definition: pg_type.c:195
#define InvalidOid
Definition: postgres_ext.h:36
#define DEFAULT_TYPDELIM
Definition: typecmds.h:22

References DEFAULT_TYPDELIM, InvalidOid, and TypeCreate().

Referenced by heap_create_with_catalog().

◆ AddRelationNewConstraints()

List* AddRelationNewConstraints ( Relation  rel,
List newColDefaults,
List newConstraints,
bool  allow_merge,
bool  is_local,
bool  is_internal,
const char *  queryString 
)

Definition at line 2259 of file heap.c.

2266 {
2267  List *cookedConstraints = NIL;
2268  TupleDesc tupleDesc;
2269  TupleConstr *oldconstr;
2270  int numoldchecks;
2271  ParseState *pstate;
2272  ParseNamespaceItem *nsitem;
2273  int numchecks;
2274  List *checknames;
2275  Node *expr;
2276  CookedConstraint *cooked;
2277 
2278  /*
2279  * Get info about existing constraints.
2280  */
2281  tupleDesc = RelationGetDescr(rel);
2282  oldconstr = tupleDesc->constr;
2283  if (oldconstr)
2284  numoldchecks = oldconstr->num_check;
2285  else
2286  numoldchecks = 0;
2287 
2288  /*
2289  * Create a dummy ParseState and insert the target relation as its sole
2290  * rangetable entry. We need a ParseState for transformExpr.
2291  */
2292  pstate = make_parsestate(NULL);
2293  pstate->p_sourcetext = queryString;
2294  nsitem = addRangeTableEntryForRelation(pstate,
2295  rel,
2297  NULL,
2298  false,
2299  true);
2300  addNSItemToQuery(pstate, nsitem, true, true, true);
2301 
2302  /*
2303  * Process column default expressions.
2304  */
2305  foreach_ptr(RawColumnDefault, colDef, newColDefaults)
2306  {
2307  Form_pg_attribute atp = TupleDescAttr(rel->rd_att, colDef->attnum - 1);
2308  Oid defOid;
2309 
2310  expr = cookDefault(pstate, colDef->raw_default,
2311  atp->atttypid, atp->atttypmod,
2312  NameStr(atp->attname),
2313  atp->attgenerated);
2314 
2315  /*
2316  * If the expression is just a NULL constant, we do not bother to make
2317  * an explicit pg_attrdef entry, since the default behavior is
2318  * equivalent. This applies to column defaults, but not for
2319  * generation expressions.
2320  *
2321  * Note a nonobvious property of this test: if the column is of a
2322  * domain type, what we'll get is not a bare null Const but a
2323  * CoerceToDomain expr, so we will not discard the default. This is
2324  * critical because the column default needs to be retained to
2325  * override any default that the domain might have.
2326  */
2327  if (expr == NULL ||
2328  (!colDef->generated &&
2329  IsA(expr, Const) &&
2330  castNode(Const, expr)->constisnull))
2331  continue;
2332 
2333  /* If the DEFAULT is volatile we cannot use a missing value */
2334  if (colDef->missingMode &&
2336  colDef->missingMode = false;
2337 
2338  defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal,
2339  colDef->missingMode);
2340 
2341  cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
2342  cooked->contype = CONSTR_DEFAULT;
2343  cooked->conoid = defOid;
2344  cooked->name = NULL;
2345  cooked->attnum = colDef->attnum;
2346  cooked->expr = expr;
2347  cooked->skip_validation = false;
2348  cooked->is_local = is_local;
2349  cooked->inhcount = is_local ? 0 : 1;
2350  cooked->is_no_inherit = false;
2351  cookedConstraints = lappend(cookedConstraints, cooked);
2352  }
2353 
2354  /*
2355  * Process constraint expressions.
2356  */
2357  numchecks = numoldchecks;
2358  checknames = NIL;
2359  foreach_node(Constraint, cdef, newConstraints)
2360  {
2361  Oid constrOid;
2362 
2363  if (cdef->contype == CONSTR_CHECK)
2364  {
2365  char *ccname;
2366 
2367  if (cdef->raw_expr != NULL)
2368  {
2369  Assert(cdef->cooked_expr == NULL);
2370 
2371  /*
2372  * Transform raw parsetree to executable expression, and
2373  * verify it's valid as a CHECK constraint.
2374  */
2375  expr = cookConstraint(pstate, cdef->raw_expr,
2377  }
2378  else
2379  {
2380  Assert(cdef->cooked_expr != NULL);
2381 
2382  /*
2383  * Here, we assume the parser will only pass us valid CHECK
2384  * expressions, so we do no particular checking.
2385  */
2386  expr = stringToNode(cdef->cooked_expr);
2387  }
2388 
2389  /*
2390  * Check name uniqueness, or generate a name if none was given.
2391  */
2392  if (cdef->conname != NULL)
2393  {
2394  ccname = cdef->conname;
2395  /* Check against other new constraints */
2396  /* Needed because we don't do CommandCounterIncrement in loop */
2397  foreach_ptr(char, chkname, checknames)
2398  {
2399  if (strcmp(chkname, ccname) == 0)
2400  ereport(ERROR,
2402  errmsg("check constraint \"%s\" already exists",
2403  ccname)));
2404  }
2405 
2406  /* save name for future checks */
2407  checknames = lappend(checknames, ccname);
2408 
2409  /*
2410  * Check against pre-existing constraints. If we are allowed
2411  * to merge with an existing constraint, there's no more to do
2412  * here. (We omit the duplicate constraint from the result,
2413  * which is what ATAddCheckConstraint wants.)
2414  */
2415  if (MergeWithExistingConstraint(rel, ccname, expr,
2416  allow_merge, is_local,
2417  cdef->initially_valid,
2418  cdef->is_no_inherit))
2419  continue;
2420  }
2421  else
2422  {
2423  /*
2424  * When generating a name, we want to create "tab_col_check"
2425  * for a column constraint and "tab_check" for a table
2426  * constraint. We no longer have any info about the syntactic
2427  * positioning of the constraint phrase, so we approximate
2428  * this by seeing whether the expression references more than
2429  * one column. (If the user played by the rules, the result
2430  * is the same...)
2431  *
2432  * Note: pull_var_clause() doesn't descend into sublinks, but
2433  * we eliminated those above; and anyway this only needs to be
2434  * an approximate answer.
2435  */
2436  List *vars;
2437  char *colname;
2438 
2439  vars = pull_var_clause(expr, 0);
2440 
2441  /* eliminate duplicates */
2442  vars = list_union(NIL, vars);
2443 
2444  if (list_length(vars) == 1)
2445  colname = get_attname(RelationGetRelid(rel),
2446  ((Var *) linitial(vars))->varattno,
2447  true);
2448  else
2449  colname = NULL;
2450 
2452  colname,
2453  "check",
2454  RelationGetNamespace(rel),
2455  checknames);
2456 
2457  /* save name for future checks */
2458  checknames = lappend(checknames, ccname);
2459  }
2460 
2461  /*
2462  * OK, store it.
2463  */
2464  constrOid =
2465  StoreRelCheck(rel, ccname, expr, cdef->initially_valid, is_local,
2466  is_local ? 0 : 1, cdef->is_no_inherit, is_internal);
2467 
2468  numchecks++;
2469 
2470  cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
2471  cooked->contype = CONSTR_CHECK;
2472  cooked->conoid = constrOid;
2473  cooked->name = ccname;
2474  cooked->attnum = 0;
2475  cooked->expr = expr;
2476  cooked->skip_validation = cdef->skip_validation;
2477  cooked->is_local = is_local;
2478  cooked->inhcount = is_local ? 0 : 1;
2479  cooked->is_no_inherit = cdef->is_no_inherit;
2480  cookedConstraints = lappend(cookedConstraints, cooked);
2481  }
2482  }
2483 
2484  /*
2485  * Update the count of constraints in the relation's pg_class tuple. We do
2486  * this even if there was no change, in order to ensure that an SI update
2487  * message is sent out for the pg_class tuple, which will force other
2488  * backends to rebuild their relcache entries for the rel. (This is
2489  * critical if we added defaults but not constraints.)
2490  */
2491  SetRelationNumChecks(rel, numchecks);
2492 
2493  return cookedConstraints;
2494 }
#define NameStr(name)
Definition: c.h:749
#define Assert(condition)
Definition: c.h:861
bool contain_volatile_functions_after_planning(Expr *expr)
Definition: clauses.c:659
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
static bool MergeWithExistingConstraint(Relation rel, const char *ccname, Node *expr, bool allow_merge, bool is_local, bool is_initially_valid, bool is_no_inherit)
Definition: heap.c:2507
Node * cookDefault(ParseState *pstate, Node *raw_default, Oid atttypid, int32 atttypmod, const char *attname, char attgenerated)
Definition: heap.c:2754
static void SetRelationNumChecks(Relation rel, int numchecks)
Definition: heap.c:2660
static Oid StoreRelCheck(Relation rel, const char *ccname, Node *expr, bool is_validated, bool is_local, int16 inhcount, bool is_no_inherit, bool is_internal)
Definition: heap.c:2074
static Node * cookConstraint(ParseState *pstate, Node *raw_constraint, char *relname)
Definition: heap.c:2831
List * list_union(const List *list1, const List *list2)
Definition: list.c:1066
List * lappend(List *list, void *datum)
Definition: list.c:339
#define AccessShareLock
Definition: lockdefs.h:36
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition: lsyscache.c:827
void * palloc(Size size)
Definition: mcxt.c:1317
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
@ CONSTR_DEFAULT
Definition: parsenodes.h:2716
@ CONSTR_CHECK
Definition: parsenodes.h:2719
Oid StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr, bool is_internal, bool add_column_mode)
Definition: pg_attrdef.c:46
char * ChooseConstraintName(const char *name1, const char *name2, const char *label, Oid namespaceid, List *others)
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define foreach_ptr(type, var, lst)
Definition: pg_list.h:469
#define linitial(l)
Definition: pg_list.h:178
#define foreach_node(type, var, lst)
Definition: pg_list.h:496
unsigned int Oid
Definition: postgres_ext.h:31
void * stringToNode(const char *str)
Definition: read.c:90
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationGetDescr(relation)
Definition: rel.h:531
#define RelationGetRelationName(relation)
Definition: rel.h:539
#define RelationGetNamespace(relation)
Definition: rel.h:546
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:32
Oid conoid
Definition: heap.h:38
char * name
Definition: heap.h:39
AttrNumber attnum
Definition: heap.h:40
bool skip_validation
Definition: heap.h:42
bool is_no_inherit
Definition: heap.h:45
int16 inhcount
Definition: heap.h:44
bool is_local
Definition: heap.h:43
ConstrType contype
Definition: heap.h:37
Node * expr
Definition: heap.h:41
Definition: pg_list.h:54
Definition: nodes.h:129
const char * p_sourcetext
Definition: parse_node.h:195
uint16 num_check
Definition: tupdesc.h:43
TupleConstr * constr
Definition: tupdesc.h:85
Definition: primnodes.h:248
Definition: regcomp.c:281
List * pull_var_clause(Node *node, int flags)
Definition: var.c:612

References AccessShareLock, addNSItemToQuery(), addRangeTableEntryForRelation(), Assert, CookedConstraint::attnum, castNode, ChooseConstraintName(), CookedConstraint::conoid, TupleDescData::constr, CONSTR_CHECK, CONSTR_DEFAULT, contain_volatile_functions_after_planning(), CookedConstraint::contype, cookConstraint(), cookDefault(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, CookedConstraint::expr, foreach_node, foreach_ptr, get_attname(), CookedConstraint::inhcount, CookedConstraint::is_local, CookedConstraint::is_no_inherit, IsA, lappend(), linitial, list_length(), list_union(), make_parsestate(), MergeWithExistingConstraint(), CookedConstraint::name, NameStr, NIL, TupleConstr::num_check, ParseState::p_sourcetext, palloc(), pull_var_clause(), RelationData::rd_att, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, SetRelationNumChecks(), CookedConstraint::skip_validation, StoreAttrDefault(), StoreRelCheck(), stringToNode(), and TupleDescAttr.

Referenced by ATAddCheckConstraint(), ATExecAddColumn(), ATExecColumnDefault(), ATExecSetExpression(), and DefineRelation().

◆ check_nested_generated()

static void check_nested_generated ( ParseState pstate,
Node node 
)
static

Definition at line 2736 of file heap.c.

2737 {
2738  check_nested_generated_walker(node, pstate);
2739 }
static bool check_nested_generated_walker(Node *node, void *context)
Definition: heap.c:2694

References check_nested_generated_walker().

Referenced by cookDefault().

◆ check_nested_generated_walker()

static bool check_nested_generated_walker ( Node node,
void *  context 
)
static

Definition at line 2694 of file heap.c.

2695 {
2696  ParseState *pstate = context;
2697 
2698  if (node == NULL)
2699  return false;
2700  else if (IsA(node, Var))
2701  {
2702  Var *var = (Var *) node;
2703  Oid relid;
2705 
2706  relid = rt_fetch(var->varno, pstate->p_rtable)->relid;
2707  if (!OidIsValid(relid))
2708  return false; /* XXX shouldn't we raise an error? */
2709 
2710  attnum = var->varattno;
2711 
2712  if (attnum > 0 && get_attgenerated(relid, attnum))
2713  ereport(ERROR,
2714  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2715  errmsg("cannot use generated column \"%s\" in column generation expression",
2716  get_attname(relid, attnum, false)),
2717  errdetail("A generated column cannot reference another generated column."),
2718  parser_errposition(pstate, var->location)));
2719  /* A whole-row Var is necessarily self-referential, so forbid it */
2720  if (attnum == 0)
2721  ereport(ERROR,
2722  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2723  errmsg("cannot use whole-row variable in column generation expression"),
2724  errdetail("This would cause the generated column to depend on its own value."),
2725  parser_errposition(pstate, var->location)));
2726  /* System columns were already checked in the parser */
2727 
2728  return false;
2729  }
2730  else
2732  (void *) context);
2733 }
int16 AttrNumber
Definition: attnum.h:21
int errdetail(const char *fmt,...)
Definition: elog.c:1203
char get_attgenerated(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:888
#define expression_tree_walker(n, w, c)
Definition: nodeFuncs.h:153
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
int16 attnum
Definition: pg_attribute.h:74
tree context
Definition: radixtree.h:1835
List * p_rtable
Definition: parse_node.h:196
ParseLoc location
Definition: primnodes.h:293
AttrNumber varattno
Definition: primnodes.h:260
int varno
Definition: primnodes.h:255

References attnum, context, ereport, errcode(), errdetail(), errmsg(), ERROR, expression_tree_walker, get_attgenerated(), get_attname(), IsA, Var::location, OidIsValid, ParseState::p_rtable, parser_errposition(), rt_fetch, Var::varattno, and Var::varno.

Referenced by check_nested_generated().

◆ CheckAttributeNamesTypes()

void CheckAttributeNamesTypes ( TupleDesc  tupdesc,
char  relkind,
int  flags 
)

Definition at line 456 of file heap.c.

458 {
459  int i;
460  int j;
461  int natts = tupdesc->natts;
462 
463  /* Sanity check on column count */
464  if (natts < 0 || natts > MaxHeapAttributeNumber)
465  ereport(ERROR,
466  (errcode(ERRCODE_TOO_MANY_COLUMNS),
467  errmsg("tables can have at most %d columns",
469 
470  /*
471  * first check for collision with system attribute names
472  *
473  * Skip this for a view or type relation, since those don't have system
474  * attributes.
475  */
476  if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
477  {
478  for (i = 0; i < natts; i++)
479  {
480  Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
481 
482  if (SystemAttributeByName(NameStr(attr->attname)) != NULL)
483  ereport(ERROR,
484  (errcode(ERRCODE_DUPLICATE_COLUMN),
485  errmsg("column name \"%s\" conflicts with a system column name",
486  NameStr(attr->attname))));
487  }
488  }
489 
490  /*
491  * next check for repeated attribute names
492  */
493  for (i = 1; i < natts; i++)
494  {
495  for (j = 0; j < i; j++)
496  {
497  if (strcmp(NameStr(TupleDescAttr(tupdesc, j)->attname),
498  NameStr(TupleDescAttr(tupdesc, i)->attname)) == 0)
499  ereport(ERROR,
500  (errcode(ERRCODE_DUPLICATE_COLUMN),
501  errmsg("column name \"%s\" specified more than once",
502  NameStr(TupleDescAttr(tupdesc, j)->attname))));
503  }
504  }
505 
506  /*
507  * next check the attribute types
508  */
509  for (i = 0; i < natts; i++)
510  {
512  TupleDescAttr(tupdesc, i)->atttypid,
513  TupleDescAttr(tupdesc, i)->attcollation,
514  NIL, /* assume we're creating a new rowtype */
515  flags);
516  }
517 }
void CheckAttributeType(const char *attname, Oid atttypid, Oid attcollation, List *containing_rowtypes, int flags)
Definition: heap.c:548
const FormData_pg_attribute * SystemAttributeByName(const char *attname)
Definition: heap.c:252
#define MaxHeapAttributeNumber
Definition: htup_details.h:48
int j
Definition: isn.c:74
NameData attname
Definition: pg_attribute.h:41

References attname, CheckAttributeType(), ereport, errcode(), errmsg(), ERROR, i, j, MaxHeapAttributeNumber, NameStr, TupleDescData::natts, NIL, SystemAttributeByName(), and TupleDescAttr.

Referenced by addRangeTableEntryForFunction(), and heap_create_with_catalog().

◆ CheckAttributeType()

void CheckAttributeType ( const char *  attname,
Oid  atttypid,
Oid  attcollation,
List containing_rowtypes,
int  flags 
)

Definition at line 548 of file heap.c.

552 {
553  char att_typtype = get_typtype(atttypid);
554  Oid att_typelem;
555 
556  /* since this function recurses, it could be driven to stack overflow */
558 
559  if (att_typtype == TYPTYPE_PSEUDO)
560  {
561  /*
562  * We disallow pseudo-type columns, with the exception of ANYARRAY,
563  * RECORD, and RECORD[] when the caller says that those are OK.
564  *
565  * We don't need to worry about recursive containment for RECORD and
566  * RECORD[] because (a) no named composite type should be allowed to
567  * contain those, and (b) two "anonymous" record types couldn't be
568  * considered to be the same type, so infinite recursion isn't
569  * possible.
570  */
571  if (!((atttypid == ANYARRAYOID && (flags & CHKATYPE_ANYARRAY)) ||
572  (atttypid == RECORDOID && (flags & CHKATYPE_ANYRECORD)) ||
573  (atttypid == RECORDARRAYOID && (flags & CHKATYPE_ANYRECORD))))
574  {
575  if (flags & CHKATYPE_IS_PARTKEY)
576  ereport(ERROR,
577  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
578  /* translator: first %s is an integer not a name */
579  errmsg("partition key column %s has pseudo-type %s",
580  attname, format_type_be(atttypid))));
581  else
582  ereport(ERROR,
583  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
584  errmsg("column \"%s\" has pseudo-type %s",
585  attname, format_type_be(atttypid))));
586  }
587  }
588  else if (att_typtype == TYPTYPE_DOMAIN)
589  {
590  /*
591  * If it's a domain, recurse to check its base type.
592  */
593  CheckAttributeType(attname, getBaseType(atttypid), attcollation,
594  containing_rowtypes,
595  flags);
596  }
597  else if (att_typtype == TYPTYPE_COMPOSITE)
598  {
599  /*
600  * For a composite type, recurse into its attributes.
601  */
602  Relation relation;
603  TupleDesc tupdesc;
604  int i;
605 
606  /*
607  * Check for self-containment. Eventually we might be able to allow
608  * this (just return without complaint, if so) but it's not clear how
609  * many other places would require anti-recursion defenses before it
610  * would be safe to allow tables to contain their own rowtype.
611  */
612  if (list_member_oid(containing_rowtypes, atttypid))
613  ereport(ERROR,
614  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
615  errmsg("composite type %s cannot be made a member of itself",
616  format_type_be(atttypid))));
617 
618  containing_rowtypes = lappend_oid(containing_rowtypes, atttypid);
619 
620  relation = relation_open(get_typ_typrelid(atttypid), AccessShareLock);
621 
622  tupdesc = RelationGetDescr(relation);
623 
624  for (i = 0; i < tupdesc->natts; i++)
625  {
626  Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
627 
628  if (attr->attisdropped)
629  continue;
630  CheckAttributeType(NameStr(attr->attname),
631  attr->atttypid, attr->attcollation,
632  containing_rowtypes,
633  flags & ~CHKATYPE_IS_PARTKEY);
634  }
635 
636  relation_close(relation, AccessShareLock);
637 
638  containing_rowtypes = list_delete_last(containing_rowtypes);
639  }
640  else if (att_typtype == TYPTYPE_RANGE)
641  {
642  /*
643  * If it's a range, recurse to check its subtype.
644  */
646  get_range_collation(atttypid),
647  containing_rowtypes,
648  flags);
649  }
650  else if (OidIsValid((att_typelem = get_element_type(atttypid))))
651  {
652  /*
653  * Must recurse into array types, too, in case they are composite.
654  */
655  CheckAttributeType(attname, att_typelem, attcollation,
656  containing_rowtypes,
657  flags);
658  }
659 
660  /*
661  * This might not be strictly invalid per SQL standard, but it is pretty
662  * useless, and it cannot be dumped, so we must disallow it.
663  */
664  if (!OidIsValid(attcollation) && type_is_collatable(atttypid))
665  {
666  if (flags & CHKATYPE_IS_PARTKEY)
667  ereport(ERROR,
668  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
669  /* translator: first %s is an integer not a name */
670  errmsg("no collation was derived for partition key column %s with collatable type %s",
671  attname, format_type_be(atttypid)),
672  errhint("Use the COLLATE clause to set the collation explicitly.")));
673  else
674  ereport(ERROR,
675  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
676  errmsg("no collation was derived for column \"%s\" with collatable type %s",
677  attname, format_type_be(atttypid)),
678  errhint("Use the COLLATE clause to set the collation explicitly.")));
679  }
680 }
int errhint(const char *fmt,...)
Definition: elog.c:1317
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
#define CHKATYPE_ANYRECORD
Definition: heap.h:24
#define CHKATYPE_ANYARRAY
Definition: heap.h:23
#define CHKATYPE_IS_PARTKEY
Definition: heap.h:25
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722
List * list_delete_last(List *list)
Definition: list.c:957
Oid get_range_subtype(Oid rangeOid)
Definition: lsyscache.c:3407
Oid get_element_type(Oid typid)
Definition: lsyscache.c:2759
Oid get_range_collation(Oid rangeOid)
Definition: lsyscache.c:3433
bool type_is_collatable(Oid typid)
Definition: lsyscache.c:3081
Oid get_typ_typrelid(Oid typid)
Definition: lsyscache.c:2731
char get_typtype(Oid typid)
Definition: lsyscache.c:2629
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2521
void check_stack_depth(void)
Definition: postgres.c:3564
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47

References AccessShareLock, attname, check_stack_depth(), CHKATYPE_ANYARRAY, CHKATYPE_ANYRECORD, CHKATYPE_IS_PARTKEY, ereport, errcode(), errhint(), errmsg(), ERROR, format_type_be(), get_element_type(), get_range_collation(), get_range_subtype(), get_typ_typrelid(), get_typtype(), getBaseType(), i, lappend_oid(), list_delete_last(), list_member_oid(), NameStr, TupleDescData::natts, OidIsValid, relation_close(), relation_open(), RelationGetDescr, TupleDescAttr, and type_is_collatable().

Referenced by ATExecAddColumn(), ATPrepAlterColumnType(), CheckAttributeNamesTypes(), ComputePartitionAttrs(), and ConstructTupleDescriptor().

◆ cookConstraint()

static Node * cookConstraint ( ParseState pstate,
Node raw_constraint,
char *  relname 
)
static

Definition at line 2831 of file heap.c.

2834 {
2835  Node *expr;
2836 
2837  /*
2838  * Transform raw parsetree to executable expression.
2839  */
2840  expr = transformExpr(pstate, raw_constraint, EXPR_KIND_CHECK_CONSTRAINT);
2841 
2842  /*
2843  * Make sure it yields a boolean result.
2844  */
2845  expr = coerce_to_boolean(pstate, expr, "CHECK");
2846 
2847  /*
2848  * Take care of collations.
2849  */
2850  assign_expr_collations(pstate, expr);
2851 
2852  /*
2853  * Make sure no outside relations are referred to (this is probably dead
2854  * code now that add_missing_from is history).
2855  */
2856  if (list_length(pstate->p_rtable) != 1)
2857  ereport(ERROR,
2858  (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2859  errmsg("only table \"%s\" can be referenced in check constraint",
2860  relname)));
2861 
2862  return expr;
2863 }
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)
void assign_expr_collations(ParseState *pstate, Node *expr)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:120
@ EXPR_KIND_CHECK_CONSTRAINT
Definition: parse_node.h:68
NameData relname
Definition: pg_class.h:38

References assign_expr_collations(), coerce_to_boolean(), ereport, errcode(), errmsg(), ERROR, EXPR_KIND_CHECK_CONSTRAINT, list_length(), ParseState::p_rtable, relname, and transformExpr().

Referenced by AddRelationNewConstraints().

◆ cookDefault()

Node* cookDefault ( ParseState pstate,
Node raw_default,
Oid  atttypid,
int32  atttypmod,
const char *  attname,
char  attgenerated 
)

Definition at line 2754 of file heap.c.

2760 {
2761  Node *expr;
2762 
2763  Assert(raw_default != NULL);
2764 
2765  /*
2766  * Transform raw parsetree to executable expression.
2767  */
2768  expr = transformExpr(pstate, raw_default, attgenerated ? EXPR_KIND_GENERATED_COLUMN : EXPR_KIND_COLUMN_DEFAULT);
2769 
2770  if (attgenerated)
2771  {
2772  /* Disallow refs to other generated columns */
2773  check_nested_generated(pstate, expr);
2774 
2775  /* Disallow mutable functions */
2777  ereport(ERROR,
2778  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2779  errmsg("generation expression is not immutable")));
2780  }
2781  else
2782  {
2783  /*
2784  * For a default expression, transformExpr() should have rejected
2785  * column references.
2786  */
2787  Assert(!contain_var_clause(expr));
2788  }
2789 
2790  /*
2791  * Coerce the expression to the correct type and typmod, if given. This
2792  * should match the parser's processing of non-defaulted expressions ---
2793  * see transformAssignedExpr().
2794  */
2795  if (OidIsValid(atttypid))
2796  {
2797  Oid type_id = exprType(expr);
2798 
2799  expr = coerce_to_target_type(pstate, expr, type_id,
2800  atttypid, atttypmod,
2803  -1);
2804  if (expr == NULL)
2805  ereport(ERROR,
2806  (errcode(ERRCODE_DATATYPE_MISMATCH),
2807  errmsg("column \"%s\" is of type %s"
2808  " but default expression is of type %s",
2809  attname,
2810  format_type_be(atttypid),
2811  format_type_be(type_id)),
2812  errhint("You will need to rewrite or cast the expression.")));
2813  }
2814 
2815  /*
2816  * Finally, take care of collations in the finished expression.
2817  */
2818  assign_expr_collations(pstate, expr);
2819 
2820  return expr;
2821 }
bool contain_mutable_functions_after_planning(Expr *expr)
Definition: clauses.c:490
static void check_nested_generated(ParseState *pstate, Node *node)
Definition: heap.c:2736
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:78
@ EXPR_KIND_COLUMN_DEFAULT
Definition: parse_node.h:70
@ EXPR_KIND_GENERATED_COLUMN
Definition: parse_node.h:83
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:736
@ COERCION_ASSIGNMENT
Definition: primnodes.h:715
bool contain_var_clause(Node *node)
Definition: var.c:408

References Assert, assign_expr_collations(), attname, check_nested_generated(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, contain_mutable_functions_after_planning(), contain_var_clause(), ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_COLUMN_DEFAULT, EXPR_KIND_GENERATED_COLUMN, exprType(), format_type_be(), OidIsValid, and transformExpr().

Referenced by AddRelationNewConstraints(), AlterDomainDefault(), and DefineDomain().

◆ CopyStatistics()

void CopyStatistics ( Oid  fromrelid,
Oid  torelid 
)

Definition at line 2869 of file heap.c.

2870 {
2871  HeapTuple tup;
2872  SysScanDesc scan;
2873  ScanKeyData key[1];
2874  Relation statrel;
2875  CatalogIndexState indstate = NULL;
2876 
2877  statrel = table_open(StatisticRelationId, RowExclusiveLock);
2878 
2879  /* Now search for stat records */
2880  ScanKeyInit(&key[0],
2881  Anum_pg_statistic_starelid,
2882  BTEqualStrategyNumber, F_OIDEQ,
2883  ObjectIdGetDatum(fromrelid));
2884 
2885  scan = systable_beginscan(statrel, StatisticRelidAttnumInhIndexId,
2886  true, NULL, 1, key);
2887 
2888  while (HeapTupleIsValid((tup = systable_getnext(scan))))
2889  {
2890  Form_pg_statistic statform;
2891 
2892  /* make a modifiable copy */
2893  tup = heap_copytuple(tup);
2894  statform = (Form_pg_statistic) GETSTRUCT(tup);
2895 
2896  /* update the copy of the tuple and insert it */
2897  statform->starelid = torelid;
2898 
2899  /* fetch index information when we know we need it */
2900  if (indstate == NULL)
2901  indstate = CatalogOpenIndexes(statrel);
2902 
2903  CatalogTupleInsertWithInfo(statrel, tup, indstate);
2904 
2905  heap_freetuple(tup);
2906  }
2907 
2908  systable_endscan(scan);
2909 
2910  if (indstate != NULL)
2911  CatalogCloseIndexes(indstate);
2912  table_close(statrel, RowExclusiveLock);
2913 }
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:604
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:511
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:387
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, CatalogIndexState indstate)
Definition: indexing.c:256
FormData_pg_statistic * Form_pg_statistic
Definition: pg_statistic.h:135
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define BTEqualStrategyNumber
Definition: stratnum.h:31

References BTEqualStrategyNumber, CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTupleInsertWithInfo(), GETSTRUCT, heap_copytuple(), heap_freetuple(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by index_concurrently_swap().

◆ DeleteAttributeTuples()

void DeleteAttributeTuples ( Oid  relid)

Definition at line 1586 of file heap.c.

1587 {
1588  Relation attrel;
1589  SysScanDesc scan;
1590  ScanKeyData key[1];
1591  HeapTuple atttup;
1592 
1593  /* Grab an appropriate lock on the pg_attribute relation */
1594  attrel = table_open(AttributeRelationId, RowExclusiveLock);
1595 
1596  /* Use the index to scan only attributes of the target relation */
1597  ScanKeyInit(&key[0],
1598  Anum_pg_attribute_attrelid,
1599  BTEqualStrategyNumber, F_OIDEQ,
1600  ObjectIdGetDatum(relid));
1601 
1602  scan = systable_beginscan(attrel, AttributeRelidNumIndexId, true,
1603  NULL, 1, key);
1604 
1605  /* Delete all the matching tuples */
1606  while ((atttup = systable_getnext(scan)) != NULL)
1607  CatalogTupleDelete(attrel, &atttup->t_self);
1608 
1609  /* Clean up after the scan */
1610  systable_endscan(scan);
1611  table_close(attrel, RowExclusiveLock);
1612 }
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:365
ItemPointerData t_self
Definition: htup.h:65

References BTEqualStrategyNumber, CatalogTupleDelete(), sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by heap_drop_with_catalog(), and index_drop().

◆ DeleteRelationTuple()

void DeleteRelationTuple ( Oid  relid)

Definition at line 1557 of file heap.c.

1558 {
1559  Relation pg_class_desc;
1560  HeapTuple tup;
1561 
1562  /* Grab an appropriate lock on the pg_class relation */
1563  pg_class_desc = table_open(RelationRelationId, RowExclusiveLock);
1564 
1565  tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1566  if (!HeapTupleIsValid(tup))
1567  elog(ERROR, "cache lookup failed for relation %u", relid);
1568 
1569  /* delete the relation tuple from pg_class, and finish up */
1570  CatalogTupleDelete(pg_class_desc, &tup->t_self);
1571 
1572  ReleaseSysCache(tup);
1573 
1574  table_close(pg_class_desc, RowExclusiveLock);
1575 }
#define elog(elevel,...)
Definition: elog.h:225
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221

References CatalogTupleDelete(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by heap_drop_with_catalog(), and index_drop().

◆ DeleteSystemAttributeTuples()

void DeleteSystemAttributeTuples ( Oid  relid)

Definition at line 1623 of file heap.c.

1624 {
1625  Relation attrel;
1626  SysScanDesc scan;
1627  ScanKeyData key[2];
1628  HeapTuple atttup;
1629 
1630  /* Grab an appropriate lock on the pg_attribute relation */
1631  attrel = table_open(AttributeRelationId, RowExclusiveLock);
1632 
1633  /* Use the index to scan only system attributes of the target relation */
1634  ScanKeyInit(&key[0],
1635  Anum_pg_attribute_attrelid,
1636  BTEqualStrategyNumber, F_OIDEQ,
1637  ObjectIdGetDatum(relid));
1638  ScanKeyInit(&key[1],
1639  Anum_pg_attribute_attnum,
1640  BTLessEqualStrategyNumber, F_INT2LE,
1641  Int16GetDatum(0));
1642 
1643  scan = systable_beginscan(attrel, AttributeRelidNumIndexId, true,
1644  NULL, 2, key);
1645 
1646  /* Delete all the matching tuples */
1647  while ((atttup = systable_getnext(scan)) != NULL)
1648  CatalogTupleDelete(attrel, &atttup->t_self);
1649 
1650  /* Clean up after the scan */
1651  systable_endscan(scan);
1652  table_close(attrel, RowExclusiveLock);
1653 }
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:172
#define BTLessEqualStrategyNumber
Definition: stratnum.h:30

References BTEqualStrategyNumber, BTLessEqualStrategyNumber, CatalogTupleDelete(), Int16GetDatum(), sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

◆ heap_create()

Relation heap_create ( const char *  relname,
Oid  relnamespace,
Oid  reltablespace,
Oid  relid,
RelFileNumber  relfilenumber,
Oid  accessmtd,
TupleDesc  tupDesc,
char  relkind,
char  relpersistence,
bool  shared_relation,
bool  mapped_relation,
bool  allow_system_table_mods,
TransactionId relfrozenxid,
MultiXactId relminmxid,
bool  create_storage 
)

Definition at line 289 of file heap.c.

304 {
305  Relation rel;
306 
307  /* The caller must have provided an OID for the relation. */
308  Assert(OidIsValid(relid));
309 
310  /*
311  * Don't allow creating relations in pg_catalog directly, even though it
312  * is allowed to move user defined relations there. Semantics with search
313  * paths including pg_catalog are too confusing for now.
314  *
315  * But allow creating indexes on relations in pg_catalog even if
316  * allow_system_table_mods = off, upper layers already guarantee it's on a
317  * user defined relation, not a system one.
318  */
319  if (!allow_system_table_mods &&
320  ((IsCatalogNamespace(relnamespace) && relkind != RELKIND_INDEX) ||
321  IsToastNamespace(relnamespace)) &&
323  ereport(ERROR,
324  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
325  errmsg("permission denied to create \"%s.%s\"",
326  get_namespace_name(relnamespace), relname),
327  errdetail("System catalog modifications are currently disallowed.")));
328 
329  *relfrozenxid = InvalidTransactionId;
330  *relminmxid = InvalidMultiXactId;
331 
332  /*
333  * Force reltablespace to zero if the relation kind does not support
334  * tablespaces. This is mainly just for cleanliness' sake.
335  */
336  if (!RELKIND_HAS_TABLESPACE(relkind))
337  reltablespace = InvalidOid;
338 
339  /* Don't create storage for relkinds without physical storage. */
340  if (!RELKIND_HAS_STORAGE(relkind))
341  create_storage = false;
342  else
343  {
344  /*
345  * If relfilenumber is unspecified by the caller then create storage
346  * with oid same as relid.
347  */
348  if (!RelFileNumberIsValid(relfilenumber))
349  relfilenumber = relid;
350  }
351 
352  /*
353  * Never allow a pg_class entry to explicitly specify the database's
354  * default tablespace in reltablespace; force it to zero instead. This
355  * ensures that if the database is cloned with a different default
356  * tablespace, the pg_class entry will still match where CREATE DATABASE
357  * will put the physically copied relation.
358  *
359  * Yes, this is a bit of a hack.
360  */
361  if (reltablespace == MyDatabaseTableSpace)
362  reltablespace = InvalidOid;
363 
364  /*
365  * build the relcache entry.
366  */
368  relnamespace,
369  tupDesc,
370  relid,
371  accessmtd,
372  relfilenumber,
373  reltablespace,
374  shared_relation,
375  mapped_relation,
376  relpersistence,
377  relkind);
378 
379  /*
380  * Have the storage manager create the relation's disk file, if needed.
381  *
382  * For tables, the AM callback creates both the main and the init fork.
383  * For others, only the main fork is created; the other forks will be
384  * created on demand.
385  */
386  if (create_storage)
387  {
388  if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
390  relpersistence,
391  relfrozenxid, relminmxid);
392  else if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
393  RelationCreateStorage(rel->rd_locator, relpersistence, true);
394  else
395  Assert(false);
396  }
397 
398  /*
399  * If a tablespace is specified, removal of that tablespace is normally
400  * protected by the existence of a physical file; but for relations with
401  * no files, add a pg_shdepend entry to account for that.
402  */
403  if (!create_storage && reltablespace != InvalidOid)
404  recordDependencyOnTablespace(RelationRelationId, relid,
405  reltablespace);
406 
407  /* ensure that stats are dropped if transaction aborts */
409 
410  return rel;
411 }
bool IsToastNamespace(Oid namespaceId)
Definition: catalog.c:230
bool IsCatalogNamespace(Oid namespaceId)
Definition: catalog.c:212
Oid MyDatabaseTableSpace
Definition: globals.c:95
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3366
#define IsNormalProcessingMode()
Definition: miscadmin.h:453
#define InvalidMultiXactId
Definition: multixact.h:24
void recordDependencyOnTablespace(Oid classId, Oid objectId, Oid tablespace)
Definition: pg_shdepend.c:370
void pgstat_create_relation(Relation rel)
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)
Definition: relcache.c:3524
#define RelFileNumberIsValid(relnumber)
Definition: relpath.h:27
SMgrRelation RelationCreateStorage(RelFileLocator rlocator, char relpersistence, bool register_delete)
Definition: storage.c:121
RelFileLocator rd_locator
Definition: rel.h:57
static void table_relation_set_new_filelocator(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
Definition: tableam.h:1621
#define InvalidTransactionId
Definition: transam.h:31

References Assert, ereport, errcode(), errdetail(), errmsg(), ERROR, get_namespace_name(), InvalidMultiXactId, InvalidOid, InvalidTransactionId, IsCatalogNamespace(), IsNormalProcessingMode, IsToastNamespace(), MyDatabaseTableSpace, OidIsValid, pgstat_create_relation(), RelationData::rd_locator, RelationData::rd_rel, recordDependencyOnTablespace(), RelationBuildLocalRelation(), RelationCreateStorage(), RelFileNumberIsValid, relname, and table_relation_set_new_filelocator().

Referenced by heap_create_with_catalog(), and index_create().

◆ heap_create_with_catalog()

Oid heap_create_with_catalog ( const char *  relname,
Oid  relnamespace,
Oid  reltablespace,
Oid  relid,
Oid  reltypeid,
Oid  reloftypeid,
Oid  ownerid,
Oid  accessmtd,
TupleDesc  tupdesc,
List cooked_constraints,
char  relkind,
char  relpersistence,
bool  shared_relation,
bool  mapped_relation,
OnCommitAction  oncommit,
Datum  reloptions,
bool  use_user_acl,
bool  allow_system_table_mods,
bool  is_internal,
Oid  relrewrite,
ObjectAddress typaddress 
)

Definition at line 1105 of file heap.c.

1126 {
1127  Relation pg_class_desc;
1128  Relation new_rel_desc;
1129  Acl *relacl;
1130  Oid existing_relid;
1131  Oid old_type_oid;
1132  Oid new_type_oid;
1133 
1134  /* By default set to InvalidOid unless overridden by binary-upgrade */
1135  RelFileNumber relfilenumber = InvalidRelFileNumber;
1136  TransactionId relfrozenxid;
1137  MultiXactId relminmxid;
1138 
1139  pg_class_desc = table_open(RelationRelationId, RowExclusiveLock);
1140 
1141  /*
1142  * sanity checks
1143  */
1145 
1146  /*
1147  * Validate proposed tupdesc for the desired relkind. If
1148  * allow_system_table_mods is on, allow ANYARRAY to be used; this is a
1149  * hack to allow creating pg_statistic and cloning it during VACUUM FULL.
1150  */
1151  CheckAttributeNamesTypes(tupdesc, relkind,
1152  allow_system_table_mods ? CHKATYPE_ANYARRAY : 0);
1153 
1154  /*
1155  * This would fail later on anyway, if the relation already exists. But
1156  * by catching it here we can emit a nicer error message.
1157  */
1158  existing_relid = get_relname_relid(relname, relnamespace);
1159  if (existing_relid != InvalidOid)
1160  ereport(ERROR,
1161  (errcode(ERRCODE_DUPLICATE_TABLE),
1162  errmsg("relation \"%s\" already exists", relname)));
1163 
1164  /*
1165  * Since we are going to create a rowtype as well, also check for
1166  * collision with an existing type name. If there is one and it's an
1167  * autogenerated array, we can rename it out of the way; otherwise we can
1168  * at least give a good error message.
1169  */
1170  old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1172  ObjectIdGetDatum(relnamespace));
1173  if (OidIsValid(old_type_oid))
1174  {
1175  if (!moveArrayTypeName(old_type_oid, relname, relnamespace))
1176  ereport(ERROR,
1178  errmsg("type \"%s\" already exists", relname),
1179  errhint("A relation has an associated type of the same name, "
1180  "so you must use a name that doesn't conflict "
1181  "with any existing type.")));
1182  }
1183 
1184  /*
1185  * Shared relations must be in pg_global (last-ditch check)
1186  */
1187  if (shared_relation && reltablespace != GLOBALTABLESPACE_OID)
1188  elog(ERROR, "shared relations must be placed in pg_global tablespace");
1189 
1190  /*
1191  * Allocate an OID for the relation, unless we were told what to use.
1192  *
1193  * The OID will be the relfilenumber as well, so make sure it doesn't
1194  * collide with either pg_class OIDs or existing physical files.
1195  */
1196  if (!OidIsValid(relid))
1197  {
1198  /* Use binary-upgrade override for pg_class.oid and relfilenumber */
1199  if (IsBinaryUpgrade)
1200  {
1201  /*
1202  * Indexes are not supported here; they use
1203  * binary_upgrade_next_index_pg_class_oid.
1204  */
1205  Assert(relkind != RELKIND_INDEX);
1206  Assert(relkind != RELKIND_PARTITIONED_INDEX);
1207 
1208  if (relkind == RELKIND_TOASTVALUE)
1209  {
1210  /* There might be no TOAST table, so we have to test for it. */
1212  {
1215 
1217  ereport(ERROR,
1218  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1219  errmsg("toast relfilenumber value not set when in binary upgrade mode")));
1220 
1223  }
1224  }
1225  else
1226  {
1228  ereport(ERROR,
1229  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1230  errmsg("pg_class heap OID value not set when in binary upgrade mode")));
1231 
1234 
1235  if (RELKIND_HAS_STORAGE(relkind))
1236  {
1238  ereport(ERROR,
1239  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1240  errmsg("relfilenumber value not set when in binary upgrade mode")));
1241 
1244  }
1245  }
1246  }
1247 
1248  if (!OidIsValid(relid))
1249  relid = GetNewRelFileNumber(reltablespace, pg_class_desc,
1250  relpersistence);
1251  }
1252 
1253  /*
1254  * Other sessions' catalog scans can't find this until we commit. Hence,
1255  * it doesn't hurt to hold AccessExclusiveLock. Do it here so callers
1256  * can't accidentally vary in their lock mode or acquisition timing.
1257  */
1259 
1260  /*
1261  * Determine the relation's initial permissions.
1262  */
1263  if (use_user_acl)
1264  {
1265  switch (relkind)
1266  {
1267  case RELKIND_RELATION:
1268  case RELKIND_VIEW:
1269  case RELKIND_MATVIEW:
1270  case RELKIND_FOREIGN_TABLE:
1271  case RELKIND_PARTITIONED_TABLE:
1272  relacl = get_user_default_acl(OBJECT_TABLE, ownerid,
1273  relnamespace);
1274  break;
1275  case RELKIND_SEQUENCE:
1276  relacl = get_user_default_acl(OBJECT_SEQUENCE, ownerid,
1277  relnamespace);
1278  break;
1279  default:
1280  relacl = NULL;
1281  break;
1282  }
1283  }
1284  else
1285  relacl = NULL;
1286 
1287  /*
1288  * Create the relcache entry (mostly dummy at this point) and the physical
1289  * disk file. (If we fail further down, it's the smgr's responsibility to
1290  * remove the disk file again.)
1291  *
1292  * NB: Note that passing create_storage = true is correct even for binary
1293  * upgrade. The storage we create here will be replaced later, but we
1294  * need to have something on disk in the meanwhile.
1295  */
1296  new_rel_desc = heap_create(relname,
1297  relnamespace,
1298  reltablespace,
1299  relid,
1300  relfilenumber,
1301  accessmtd,
1302  tupdesc,
1303  relkind,
1304  relpersistence,
1305  shared_relation,
1306  mapped_relation,
1307  allow_system_table_mods,
1308  &relfrozenxid,
1309  &relminmxid,
1310  true);
1311 
1312  Assert(relid == RelationGetRelid(new_rel_desc));
1313 
1314  new_rel_desc->rd_rel->relrewrite = relrewrite;
1315 
1316  /*
1317  * Decide whether to create a pg_type entry for the relation's rowtype.
1318  * These types are made except where the use of a relation as such is an
1319  * implementation detail: toast tables, sequences and indexes.
1320  */
1321  if (!(relkind == RELKIND_SEQUENCE ||
1322  relkind == RELKIND_TOASTVALUE ||
1323  relkind == RELKIND_INDEX ||
1324  relkind == RELKIND_PARTITIONED_INDEX))
1325  {
1326  Oid new_array_oid;
1327  ObjectAddress new_type_addr;
1328  char *relarrayname;
1329 
1330  /*
1331  * We'll make an array over the composite type, too. For largely
1332  * historical reasons, the array type's OID is assigned first.
1333  */
1334  new_array_oid = AssignTypeArrayOid();
1335 
1336  /*
1337  * Make the pg_type entry for the composite type. The OID of the
1338  * composite type can be preselected by the caller, but if reltypeid
1339  * is InvalidOid, we'll generate a new OID for it.
1340  *
1341  * NOTE: we could get a unique-index failure here, in case someone
1342  * else is creating the same type name in parallel but hadn't
1343  * committed yet when we checked for a duplicate name above.
1344  */
1345  new_type_addr = AddNewRelationType(relname,
1346  relnamespace,
1347  relid,
1348  relkind,
1349  ownerid,
1350  reltypeid,
1351  new_array_oid);
1352  new_type_oid = new_type_addr.objectId;
1353  if (typaddress)
1354  *typaddress = new_type_addr;
1355 
1356  /* Now create the array type. */
1357  relarrayname = makeArrayTypeName(relname, relnamespace);
1358 
1359  TypeCreate(new_array_oid, /* force the type's OID to this */
1360  relarrayname, /* Array type name */
1361  relnamespace, /* Same namespace as parent */
1362  InvalidOid, /* Not composite, no relationOid */
1363  0, /* relkind, also N/A here */
1364  ownerid, /* owner's ID */
1365  -1, /* Internal size (varlena) */
1366  TYPTYPE_BASE, /* Not composite - typelem is */
1367  TYPCATEGORY_ARRAY, /* type-category (array) */
1368  false, /* array types are never preferred */
1369  DEFAULT_TYPDELIM, /* default array delimiter */
1370  F_ARRAY_IN, /* array input proc */
1371  F_ARRAY_OUT, /* array output proc */
1372  F_ARRAY_RECV, /* array recv (bin) proc */
1373  F_ARRAY_SEND, /* array send (bin) proc */
1374  InvalidOid, /* typmodin procedure - none */
1375  InvalidOid, /* typmodout procedure - none */
1376  F_ARRAY_TYPANALYZE, /* array analyze procedure */
1377  F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
1378  new_type_oid, /* array element type - the rowtype */
1379  true, /* yes, this is an array type */
1380  InvalidOid, /* this has no array type */
1381  InvalidOid, /* domain base type - irrelevant */
1382  NULL, /* default value - none */
1383  NULL, /* default binary representation */
1384  false, /* passed by reference */
1385  TYPALIGN_DOUBLE, /* alignment - must be the largest! */
1386  TYPSTORAGE_EXTENDED, /* fully TOASTable */
1387  -1, /* typmod */
1388  0, /* array dimensions for typBaseType */
1389  false, /* Type NOT NULL */
1390  InvalidOid); /* rowtypes never have a collation */
1391 
1392  pfree(relarrayname);
1393  }
1394  else
1395  {
1396  /* Caller should not be expecting a type to be created. */
1397  Assert(reltypeid == InvalidOid);
1398  Assert(typaddress == NULL);
1399 
1400  new_type_oid = InvalidOid;
1401  }
1402 
1403  /*
1404  * now create an entry in pg_class for the relation.
1405  *
1406  * NOTE: we could get a unique-index failure here, in case someone else is
1407  * creating the same relation name in parallel but hadn't committed yet
1408  * when we checked for a duplicate name above.
1409  */
1410  AddNewRelationTuple(pg_class_desc,
1411  new_rel_desc,
1412  relid,
1413  new_type_oid,
1414  reloftypeid,
1415  ownerid,
1416  relkind,
1417  relfrozenxid,
1418  relminmxid,
1419  PointerGetDatum(relacl),
1420  reloptions);
1421 
1422  /*
1423  * now add tuples to pg_attribute for the attributes in our new relation.
1424  */
1425  AddNewAttributeTuples(relid, new_rel_desc->rd_att, relkind);
1426 
1427  /*
1428  * Make a dependency link to force the relation to be deleted if its
1429  * namespace is. Also make a dependency link to its owner, as well as
1430  * dependencies for any roles mentioned in the default ACL.
1431  *
1432  * For composite types, these dependencies are tracked for the pg_type
1433  * entry, so we needn't record them here. Likewise, TOAST tables don't
1434  * need a namespace dependency (they live in a pinned namespace) nor an
1435  * owner dependency (they depend indirectly through the parent table), nor
1436  * should they have any ACL entries. The same applies for extension
1437  * dependencies.
1438  *
1439  * Also, skip this in bootstrap mode, since we don't make dependencies
1440  * while bootstrapping.
1441  */
1442  if (relkind != RELKIND_COMPOSITE_TYPE &&
1443  relkind != RELKIND_TOASTVALUE &&
1445  {
1446  ObjectAddress myself,
1447  referenced;
1448  ObjectAddresses *addrs;
1449 
1450  ObjectAddressSet(myself, RelationRelationId, relid);
1451 
1452  recordDependencyOnOwner(RelationRelationId, relid, ownerid);
1453 
1454  recordDependencyOnNewAcl(RelationRelationId, relid, 0, ownerid, relacl);
1455 
1456  recordDependencyOnCurrentExtension(&myself, false);
1457 
1458  addrs = new_object_addresses();
1459 
1460  ObjectAddressSet(referenced, NamespaceRelationId, relnamespace);
1461  add_exact_object_address(&referenced, addrs);
1462 
1463  if (reloftypeid)
1464  {
1465  ObjectAddressSet(referenced, TypeRelationId, reloftypeid);
1466  add_exact_object_address(&referenced, addrs);
1467  }
1468 
1469  /*
1470  * Make a dependency link to force the relation to be deleted if its
1471  * access method is.
1472  *
1473  * No need to add an explicit dependency for the toast table, as the
1474  * main table depends on it.
1475  */
1476  if (RELKIND_HAS_TABLE_AM(relkind) && relkind != RELKIND_TOASTVALUE)
1477  {
1478  ObjectAddressSet(referenced, AccessMethodRelationId, accessmtd);
1479  add_exact_object_address(&referenced, addrs);
1480  }
1481 
1483  free_object_addresses(addrs);
1484  }
1485 
1486  /* Post creation hook for new relation */
1487  InvokeObjectPostCreateHookArg(RelationRelationId, relid, 0, is_internal);
1488 
1489  /*
1490  * Store any supplied constraints and defaults.
1491  *
1492  * NB: this may do a CommandCounterIncrement and rebuild the relcache
1493  * entry, so the relation must be valid and self-consistent at this point.
1494  * In particular, there are not yet constraints and defaults anywhere.
1495  */
1496  StoreConstraints(new_rel_desc, cooked_constraints, is_internal);
1497 
1498  /*
1499  * If there's a special on-commit action, remember it
1500  */
1501  if (oncommit != ONCOMMIT_NOOP)
1502  register_on_commit_action(relid, oncommit);
1503 
1504  /*
1505  * ok, the relation has been cataloged, so close our relations and return
1506  * the OID of the newly created relation.
1507  */
1508  table_close(new_rel_desc, NoLock); /* do not unlock till end of xact */
1509  table_close(pg_class_desc, RowExclusiveLock);
1510 
1511  return relid;
1512 }
void recordDependencyOnNewAcl(Oid classId, Oid objectId, int32 objsubId, Oid ownerId, Acl *acl)
Definition: aclchk.c:4380
Acl * get_user_default_acl(ObjectType objtype, Oid ownerId, Oid nsp_oid)
Definition: aclchk.c:4304
TransactionId MultiXactId
Definition: c.h:665
uint32 TransactionId
Definition: c.h:655
RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
Definition: catalog.c:528
void record_object_address_dependencies(const ObjectAddress *depender, ObjectAddresses *referenced, DependencyType behavior)
Definition: dependency.c:2742
ObjectAddresses * new_object_addresses(void)
Definition: dependency.c:2487
void add_exact_object_address(const ObjectAddress *object, ObjectAddresses *addrs)
Definition: dependency.c:2533
void free_object_addresses(ObjectAddresses *addrs)
Definition: dependency.c:2773
bool IsBinaryUpgrade
Definition: globals.c:120
static void StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal)
Definition: heap.c:2185
static void AddNewAttributeTuples(Oid new_rel_oid, TupleDesc tupdesc, char relkind)
Definition: heap.c:820
RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber
Definition: heap.c:82
static void AddNewRelationTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Oid new_type_oid, Oid reloftype, Oid relowner, char relkind, TransactionId relfrozenxid, TransactionId relminmxid, Datum relacl, Datum reloptions)
Definition: heap.c:969
RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber
Definition: heap.c:83
static ObjectAddress AddNewRelationType(const char *typeName, Oid typeNamespace, Oid new_rel_oid, char new_rel_kind, Oid ownerid, Oid new_row_type, Oid new_array_type)
Definition: heap.c:1027
void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind, int flags)
Definition: heap.c:456
Oid binary_upgrade_next_toast_pg_class_oid
Definition: heap.c:81
Oid binary_upgrade_next_heap_pg_class_oid
Definition: heap.c:80
Relation heap_create(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, RelFileNumber relfilenumber, Oid accessmtd, TupleDesc tupDesc, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, bool allow_system_table_mods, TransactionId *relfrozenxid, MultiXactId *relminmxid, bool create_storage)
Definition: heap.c:289
void LockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:108
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition: lsyscache.c:1885
void pfree(void *pointer)
Definition: mcxt.c:1521
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:451
#define InvokeObjectPostCreateHookArg(classId, objectId, subId, is_internal)
Definition: objectaccess.h:175
@ OBJECT_SEQUENCE
Definition: parsenodes.h:2294
@ OBJECT_TABLE
Definition: parsenodes.h:2298
void recordDependencyOnCurrentExtension(const ObjectAddress *object, bool isReplace)
Definition: pg_depend.c:194
void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
Definition: pg_shdepend.c:168
char * makeArrayTypeName(const char *typeName, Oid typeNamespace)
Definition: pg_type.c:840
bool moveArrayTypeName(Oid typeOid, const char *typeName, Oid typeNamespace)
Definition: pg_type.c:905
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
@ ONCOMMIT_NOOP
Definition: primnodes.h:57
Oid RelFileNumber
Definition: relpath.h:25
#define InvalidRelFileNumber
Definition: relpath.h:26
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
Definition: syscache.h:111
void register_on_commit_action(Oid relid, OnCommitAction action)
Definition: tablecmds.c:17507
Oid AssignTypeArrayOid(void)
Definition: typecmds.c:2410

References AccessExclusiveLock, add_exact_object_address(), AddNewAttributeTuples(), AddNewRelationTuple(), AddNewRelationType(), Assert, AssignTypeArrayOid(), binary_upgrade_next_heap_pg_class_oid, binary_upgrade_next_heap_pg_class_relfilenumber, binary_upgrade_next_toast_pg_class_oid, binary_upgrade_next_toast_pg_class_relfilenumber, CheckAttributeNamesTypes(), CHKATYPE_ANYARRAY, CStringGetDatum(), DEFAULT_TYPDELIM, DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, free_object_addresses(), get_relname_relid(), get_user_default_acl(), GetNewRelFileNumber(), GetSysCacheOid2, heap_create(), InvalidOid, InvalidRelFileNumber, InvokeObjectPostCreateHookArg, IsBinaryUpgrade, IsBootstrapProcessingMode, IsNormalProcessingMode, LockRelationOid(), makeArrayTypeName(), moveArrayTypeName(), new_object_addresses(), NoLock, OBJECT_SEQUENCE, OBJECT_TABLE, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, pfree(), PointerGetDatum(), RelationData::rd_att, RelationData::rd_rel, record_object_address_dependencies(), recordDependencyOnCurrentExtension(), recordDependencyOnNewAcl(), recordDependencyOnOwner(), register_on_commit_action(), RelationGetRelid, RelFileNumberIsValid, relname, RowExclusiveLock, StoreConstraints(), table_close(), table_open(), and TypeCreate().

Referenced by create_toast_table(), DefineRelation(), and make_new_heap().

◆ heap_drop_with_catalog()

void heap_drop_with_catalog ( Oid  relid)

Definition at line 1765 of file heap.c.

1766 {
1767  Relation rel;
1768  HeapTuple tuple;
1769  Oid parentOid = InvalidOid,
1770  defaultPartOid = InvalidOid;
1771 
1772  /*
1773  * To drop a partition safely, we must grab exclusive lock on its parent,
1774  * because another backend might be about to execute a query on the parent
1775  * table. If it relies on previously cached partition descriptor, then it
1776  * could attempt to access the just-dropped relation as its partition. We
1777  * must therefore take a table lock strong enough to prevent all queries
1778  * on the table from proceeding until we commit and send out a
1779  * shared-cache-inval notice that will make them update their partition
1780  * descriptors.
1781  */
1782  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1783  if (!HeapTupleIsValid(tuple))
1784  elog(ERROR, "cache lookup failed for relation %u", relid);
1785  if (((Form_pg_class) GETSTRUCT(tuple))->relispartition)
1786  {
1787  /*
1788  * We have to lock the parent if the partition is being detached,
1789  * because it's possible that some query still has a partition
1790  * descriptor that includes this partition.
1791  */
1792  parentOid = get_partition_parent(relid, true);
1794 
1795  /*
1796  * If this is not the default partition, dropping it will change the
1797  * default partition's partition constraint, so we must lock it.
1798  */
1799  defaultPartOid = get_default_partition_oid(parentOid);
1800  if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
1801  LockRelationOid(defaultPartOid, AccessExclusiveLock);
1802  }
1803 
1804  ReleaseSysCache(tuple);
1805 
1806  /*
1807  * Open and lock the relation.
1808  */
1809  rel = relation_open(relid, AccessExclusiveLock);
1810 
1811  /*
1812  * There can no longer be anyone *else* touching the relation, but we
1813  * might still have open queries or cursors, or pending trigger events, in
1814  * our own session.
1815  */
1816  CheckTableNotInUse(rel, "DROP TABLE");
1817 
1818  /*
1819  * This effectively deletes all rows in the table, and may be done in a
1820  * serializable transaction. In that case we must record a rw-conflict in
1821  * to this transaction from each transaction holding a predicate lock on
1822  * the table.
1823  */
1825 
1826  /*
1827  * Delete pg_foreign_table tuple first.
1828  */
1829  if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
1830  {
1831  Relation ftrel;
1832  HeapTuple fttuple;
1833 
1834  ftrel = table_open(ForeignTableRelationId, RowExclusiveLock);
1835 
1836  fttuple = SearchSysCache1(FOREIGNTABLEREL, ObjectIdGetDatum(relid));
1837  if (!HeapTupleIsValid(fttuple))
1838  elog(ERROR, "cache lookup failed for foreign table %u", relid);
1839 
1840  CatalogTupleDelete(ftrel, &fttuple->t_self);
1841 
1842  ReleaseSysCache(fttuple);
1843  table_close(ftrel, RowExclusiveLock);
1844  }
1845 
1846  /*
1847  * If a partitioned table, delete the pg_partitioned_table tuple.
1848  */
1849  if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1851 
1852  /*
1853  * If the relation being dropped is the default partition itself,
1854  * invalidate its entry in pg_partitioned_table.
1855  */
1856  if (relid == defaultPartOid)
1858 
1859  /*
1860  * Schedule unlinking of the relation's physical files at commit.
1861  */
1862  if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
1863  RelationDropStorage(rel);
1864 
1865  /* ensure that stats are dropped if transaction commits */
1866  pgstat_drop_relation(rel);
1867 
1868  /*
1869  * Close relcache entry, but *keep* AccessExclusiveLock on the relation
1870  * until transaction commit. This ensures no one else will try to do
1871  * something with the doomed relation.
1872  */
1873  relation_close(rel, NoLock);
1874 
1875  /*
1876  * Remove any associated relation synchronization states.
1877  */
1879 
1880  /*
1881  * Forget any ON COMMIT action for the rel
1882  */
1883  remove_on_commit_action(relid);
1884 
1885  /*
1886  * Flush the relation from the relcache. We want to do this before
1887  * starting to remove catalog entries, just to be certain that no relcache
1888  * entry rebuild will happen partway through. (That should not really
1889  * matter, since we don't do CommandCounterIncrement here, but let's be
1890  * safe.)
1891  */
1892  RelationForgetRelation(relid);
1893 
1894  /*
1895  * remove inheritance information
1896  */
1898 
1899  /*
1900  * delete statistics
1901  */
1902  RemoveStatistics(relid, 0);
1903 
1904  /*
1905  * delete attribute tuples
1906  */
1907  DeleteAttributeTuples(relid);
1908 
1909  /*
1910  * delete relation tuple
1911  */
1912  DeleteRelationTuple(relid);
1913 
1914  if (OidIsValid(parentOid))
1915  {
1916  /*
1917  * If this is not the default partition, the partition constraint of
1918  * the default partition has changed to include the portion of the key
1919  * space previously covered by the dropped partition.
1920  */
1921  if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
1922  CacheInvalidateRelcacheByRelid(defaultPartOid);
1923 
1924  /*
1925  * Invalidate the parent's relcache so that the partition is no longer
1926  * included in its partition descriptor.
1927  */
1928  CacheInvalidateRelcacheByRelid(parentOid);
1929  /* keep the lock */
1930  }
1931 }
void DeleteRelationTuple(Oid relid)
Definition: heap.c:1557
void DeleteAttributeTuples(Oid relid)
Definition: heap.c:1586
void RemoveStatistics(Oid relid, AttrNumber attnum)
Definition: heap.c:2922
static void RelationRemoveInheritance(Oid relid)
Definition: heap.c:1524
void RemovePartitionKeyByRelId(Oid relid)
Definition: heap.c:3449
void CacheInvalidateRelcacheByRelid(Oid relid)
Definition: inval.c:1419
void update_default_partition_oid(Oid parentId, Oid defaultPartId)
Definition: partition.c:340
Oid get_default_partition_oid(Oid parentId)
Definition: partition.c:315
Oid get_partition_parent(Oid relid, bool even_if_detached)
Definition: partition.c:53
void RemoveSubscriptionRel(Oid subid, Oid relid)
void pgstat_drop_relation(Relation rel)
void CheckTableForSerializableConflictIn(Relation relation)
Definition: predicate.c:4404
void RelationForgetRelation(Oid rid)
Definition: relcache.c:2911
void RelationDropStorage(Relation rel)
Definition: storage.c:206
void CheckTableNotInUse(Relation rel, const char *stmt)
Definition: tablecmds.c:4259
void remove_on_commit_action(Oid relid)
Definition: tablecmds.c:17543

References AccessExclusiveLock, CacheInvalidateRelcacheByRelid(), CatalogTupleDelete(), CheckTableForSerializableConflictIn(), CheckTableNotInUse(), DeleteAttributeTuples(), DeleteRelationTuple(), elog, ERROR, get_default_partition_oid(), get_partition_parent(), GETSTRUCT, HeapTupleIsValid, InvalidOid, LockRelationOid(), NoLock, ObjectIdGetDatum(), OidIsValid, pgstat_drop_relation(), RelationData::rd_rel, relation_close(), relation_open(), RelationDropStorage(), RelationForgetRelation(), RelationRemoveInheritance(), ReleaseSysCache(), remove_on_commit_action(), RemovePartitionKeyByRelId(), RemoveStatistics(), RemoveSubscriptionRel(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), table_open(), and update_default_partition_oid().

Referenced by doDeletion().

◆ heap_truncate()

void heap_truncate ( List relids)

Definition at line 3017 of file heap.c.

3018 {
3019  List *relations = NIL;
3020  ListCell *cell;
3021 
3022  /* Open relations for processing, and grab exclusive access on each */
3023  foreach(cell, relids)
3024  {
3025  Oid rid = lfirst_oid(cell);
3026  Relation rel;
3027 
3028  rel = table_open(rid, AccessExclusiveLock);
3029  relations = lappend(relations, rel);
3030  }
3031 
3032  /* Don't allow truncate on tables that are referenced by foreign keys */
3033  heap_truncate_check_FKs(relations, true);
3034 
3035  /* OK to do it */
3036  foreach(cell, relations)
3037  {
3038  Relation rel = lfirst(cell);
3039 
3040  /* Truncate the relation */
3041  heap_truncate_one_rel(rel);
3042 
3043  /* Close the relation, but keep exclusive lock on it until commit */
3044  table_close(rel, NoLock);
3045  }
3046 }
void heap_truncate_check_FKs(List *relations, bool tempTables)
Definition: heap.c:3102
void heap_truncate_one_rel(Relation rel)
Definition: heap.c:3058
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_oid(lc)
Definition: pg_list.h:174

References AccessExclusiveLock, heap_truncate_check_FKs(), heap_truncate_one_rel(), lappend(), lfirst, lfirst_oid, NIL, NoLock, table_close(), and table_open().

Referenced by PreCommit_on_commit_actions().

◆ heap_truncate_check_FKs()

void heap_truncate_check_FKs ( List relations,
bool  tempTables 
)

Definition at line 3102 of file heap.c.

3103 {
3104  List *oids = NIL;
3105  List *dependents;
3106  ListCell *cell;
3107 
3108  /*
3109  * Build a list of OIDs of the interesting relations.
3110  *
3111  * If a relation has no triggers, then it can neither have FKs nor be
3112  * referenced by a FK from another table, so we can ignore it. For
3113  * partitioned tables, FKs have no triggers, so we must include them
3114  * anyway.
3115  */
3116  foreach(cell, relations)
3117  {
3118  Relation rel = lfirst(cell);
3119 
3120  if (rel->rd_rel->relhastriggers ||
3121  rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3122  oids = lappend_oid(oids, RelationGetRelid(rel));
3123  }
3124 
3125  /*
3126  * Fast path: if no relation has triggers, none has FKs either.
3127  */
3128  if (oids == NIL)
3129  return;
3130 
3131  /*
3132  * Otherwise, must scan pg_constraint. We make one pass with all the
3133  * relations considered; if this finds nothing, then all is well.
3134  */
3135  dependents = heap_truncate_find_FKs(oids);
3136  if (dependents == NIL)
3137  return;
3138 
3139  /*
3140  * Otherwise we repeat the scan once per relation to identify a particular
3141  * pair of relations to complain about. This is pretty slow, but
3142  * performance shouldn't matter much in a failure path. The reason for
3143  * doing things this way is to ensure that the message produced is not
3144  * dependent on chance row locations within pg_constraint.
3145  */
3146  foreach(cell, oids)
3147  {
3148  Oid relid = lfirst_oid(cell);
3149  ListCell *cell2;
3150 
3151  dependents = heap_truncate_find_FKs(list_make1_oid(relid));
3152 
3153  foreach(cell2, dependents)
3154  {
3155  Oid relid2 = lfirst_oid(cell2);
3156 
3157  if (!list_member_oid(oids, relid2))
3158  {
3159  char *relname = get_rel_name(relid);
3160  char *relname2 = get_rel_name(relid2);
3161 
3162  if (tempTables)
3163  ereport(ERROR,
3164  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3165  errmsg("unsupported ON COMMIT and foreign key combination"),
3166  errdetail("Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting.",
3167  relname2, relname)));
3168  else
3169  ereport(ERROR,
3170  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3171  errmsg("cannot truncate a table referenced in a foreign key constraint"),
3172  errdetail("Table \"%s\" references \"%s\".",
3173  relname2, relname),
3174  errhint("Truncate table \"%s\" at the same time, "
3175  "or use TRUNCATE ... CASCADE.",
3176  relname2)));
3177  }
3178  }
3179  }
3180 }
List * heap_truncate_find_FKs(List *relationIds)
Definition: heap.c:3197
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1928
#define list_make1_oid(x1)
Definition: pg_list.h:242

References ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, get_rel_name(), heap_truncate_find_FKs(), lappend_oid(), lfirst, lfirst_oid, list_make1_oid, list_member_oid(), NIL, RelationData::rd_rel, RelationGetRelid, and relname.

Referenced by ExecuteTruncateGuts(), and heap_truncate().

◆ heap_truncate_find_FKs()

List* heap_truncate_find_FKs ( List relationIds)

Definition at line 3197 of file heap.c.

3198 {
3199  List *result = NIL;
3200  List *oids;
3201  List *parent_cons;
3202  ListCell *cell;
3203  ScanKeyData key;
3204  Relation fkeyRel;
3205  SysScanDesc fkeyScan;
3206  HeapTuple tuple;
3207  bool restart;
3208 
3209  oids = list_copy(relationIds);
3210 
3211  /*
3212  * Must scan pg_constraint. Right now, it is a seqscan because there is
3213  * no available index on confrelid.
3214  */
3215  fkeyRel = table_open(ConstraintRelationId, AccessShareLock);
3216 
3217 restart:
3218  restart = false;
3219  parent_cons = NIL;
3220 
3221  fkeyScan = systable_beginscan(fkeyRel, InvalidOid, false,
3222  NULL, 0, NULL);
3223 
3224  while (HeapTupleIsValid(tuple = systable_getnext(fkeyScan)))
3225  {
3227 
3228  /* Not a foreign key */
3229  if (con->contype != CONSTRAINT_FOREIGN)
3230  continue;
3231 
3232  /* Not referencing one of our list of tables */
3233  if (!list_member_oid(oids, con->confrelid))
3234  continue;
3235 
3236  /*
3237  * If this constraint has a parent constraint which we have not seen
3238  * yet, keep track of it for the second loop, below. Tracking parent
3239  * constraints allows us to climb up to the top-level constraint and
3240  * look for all possible relations referencing the partitioned table.
3241  */
3242  if (OidIsValid(con->conparentid) &&
3243  !list_member_oid(parent_cons, con->conparentid))
3244  parent_cons = lappend_oid(parent_cons, con->conparentid);
3245 
3246  /*
3247  * Add referencer to result, unless present in input list. (Don't
3248  * worry about dupes: we'll fix that below).
3249  */
3250  if (!list_member_oid(relationIds, con->conrelid))
3251  result = lappend_oid(result, con->conrelid);
3252  }
3253 
3254  systable_endscan(fkeyScan);
3255 
3256  /*
3257  * Process each parent constraint we found to add the list of referenced
3258  * relations by them to the oids list. If we do add any new such
3259  * relations, redo the first loop above. Also, if we see that the parent
3260  * constraint in turn has a parent, add that so that we process all
3261  * relations in a single additional pass.
3262  */
3263  foreach(cell, parent_cons)
3264  {
3265  Oid parent = lfirst_oid(cell);
3266 
3267  ScanKeyInit(&key,
3268  Anum_pg_constraint_oid,
3269  BTEqualStrategyNumber, F_OIDEQ,
3270  ObjectIdGetDatum(parent));
3271 
3272  fkeyScan = systable_beginscan(fkeyRel, ConstraintOidIndexId,
3273  true, NULL, 1, &key);
3274 
3275  tuple = systable_getnext(fkeyScan);
3276  if (HeapTupleIsValid(tuple))
3277  {
3279 
3280  /*
3281  * pg_constraint rows always appear for partitioned hierarchies
3282  * this way: on the each side of the constraint, one row appears
3283  * for each partition that points to the top-most table on the
3284  * other side.
3285  *
3286  * Because of this arrangement, we can correctly catch all
3287  * relevant relations by adding to 'parent_cons' all rows with
3288  * valid conparentid, and to the 'oids' list all rows with a zero
3289  * conparentid. If any oids are added to 'oids', redo the first
3290  * loop above by setting 'restart'.
3291  */
3292  if (OidIsValid(con->conparentid))
3293  parent_cons = list_append_unique_oid(parent_cons,
3294  con->conparentid);
3295  else if (!list_member_oid(oids, con->confrelid))
3296  {
3297  oids = lappend_oid(oids, con->confrelid);
3298  restart = true;
3299  }
3300  }
3301 
3302  systable_endscan(fkeyScan);
3303  }
3304 
3305  list_free(parent_cons);
3306  if (restart)
3307  goto restart;
3308 
3309  table_close(fkeyRel, AccessShareLock);
3310  list_free(oids);
3311 
3312  /* Now sort and de-duplicate the result list */
3313  list_sort(result, list_oid_cmp);
3314  list_deduplicate_oid(result);
3315 
3316  return result;
3317 }
void list_sort(List *list, list_sort_comparator cmp)
Definition: list.c:1674
List * list_copy(const List *oldlist)
Definition: list.c:1573
void list_deduplicate_oid(List *list)
Definition: list.c:1495
int list_oid_cmp(const ListCell *p1, const ListCell *p2)
Definition: list.c:1703
void list_free(List *list)
Definition: list.c:1546
List * list_append_unique_oid(List *list, Oid datum)
Definition: list.c:1380
FormData_pg_constraint * Form_pg_constraint

References AccessShareLock, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, InvalidOid, sort-test::key, lappend_oid(), lfirst_oid, list_append_unique_oid(), list_copy(), list_deduplicate_oid(), list_free(), list_member_oid(), list_oid_cmp(), list_sort(), NIL, ObjectIdGetDatum(), OidIsValid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ExecuteTruncateGuts(), and heap_truncate_check_FKs().

◆ heap_truncate_one_rel()

void heap_truncate_one_rel ( Relation  rel)

Definition at line 3058 of file heap.c.

3059 {
3060  Oid toastrelid;
3061 
3062  /*
3063  * Truncate the relation. Partitioned tables have no storage, so there is
3064  * nothing to do for them here.
3065  */
3066  if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3067  return;
3068 
3069  /* Truncate the underlying relation */
3071 
3072  /* If the relation has indexes, truncate the indexes too */
3074 
3075  /* If there is a toast table, truncate that too */
3076  toastrelid = rel->rd_rel->reltoastrelid;
3077  if (OidIsValid(toastrelid))
3078  {
3079  Relation toastrel = table_open(toastrelid, AccessExclusiveLock);
3080 
3082  RelationTruncateIndexes(toastrel);
3083  /* keep the lock... */
3084  table_close(toastrel, NoLock);
3085  }
3086 }
static void RelationTruncateIndexes(Relation heapRelation)
Definition: heap.c:2969
static void table_relation_nontransactional_truncate(Relation rel)
Definition: tableam.h:1639

References AccessExclusiveLock, NoLock, OidIsValid, RelationData::rd_rel, RelationTruncateIndexes(), table_close(), table_open(), and table_relation_nontransactional_truncate().

Referenced by ExecuteTruncateGuts(), and heap_truncate().

◆ InsertPgAttributeTuples()

void InsertPgAttributeTuples ( Relation  pg_attribute_rel,
TupleDesc  tupdesc,
Oid  new_rel_oid,
const FormExtraData_pg_attribute  tupdesc_extra[],
CatalogIndexState  indstate 
)

Definition at line 702 of file heap.c.

707 {
708  TupleTableSlot **slot;
709  TupleDesc td;
710  int nslots;
711  int natts = 0;
712  int slotCount = 0;
713  bool close_index = false;
714 
715  td = RelationGetDescr(pg_attribute_rel);
716 
717  /* Initialize the number of slots to use */
718  nslots = Min(tupdesc->natts,
720  slot = palloc(sizeof(TupleTableSlot *) * nslots);
721  for (int i = 0; i < nslots; i++)
723 
724  while (natts < tupdesc->natts)
725  {
726  Form_pg_attribute attrs = TupleDescAttr(tupdesc, natts);
727  const FormExtraData_pg_attribute *attrs_extra = tupdesc_extra ? &tupdesc_extra[natts] : NULL;
728 
729  ExecClearTuple(slot[slotCount]);
730 
731  memset(slot[slotCount]->tts_isnull, false,
732  slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));
733 
734  if (new_rel_oid != InvalidOid)
735  slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(new_rel_oid);
736  else
737  slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(attrs->attrelid);
738 
739  slot[slotCount]->tts_values[Anum_pg_attribute_attname - 1] = NameGetDatum(&attrs->attname);
740  slot[slotCount]->tts_values[Anum_pg_attribute_atttypid - 1] = ObjectIdGetDatum(attrs->atttypid);
741  slot[slotCount]->tts_values[Anum_pg_attribute_attlen - 1] = Int16GetDatum(attrs->attlen);
742  slot[slotCount]->tts_values[Anum_pg_attribute_attnum - 1] = Int16GetDatum(attrs->attnum);
743  slot[slotCount]->tts_values[Anum_pg_attribute_attcacheoff - 1] = Int32GetDatum(-1);
744  slot[slotCount]->tts_values[Anum_pg_attribute_atttypmod - 1] = Int32GetDatum(attrs->atttypmod);
745  slot[slotCount]->tts_values[Anum_pg_attribute_attndims - 1] = Int16GetDatum(attrs->attndims);
746  slot[slotCount]->tts_values[Anum_pg_attribute_attbyval - 1] = BoolGetDatum(attrs->attbyval);
747  slot[slotCount]->tts_values[Anum_pg_attribute_attalign - 1] = CharGetDatum(attrs->attalign);
748  slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
749  slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);
750  slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
751  slot[slotCount]->tts_values[Anum_pg_attribute_atthasdef - 1] = BoolGetDatum(attrs->atthasdef);
752  slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
753  slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
754  slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
755  slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
756  slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
757  slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int16GetDatum(attrs->attinhcount);
758  slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
759  if (attrs_extra)
760  {
761  slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.value;
762  slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.isnull;
763 
764  slot[slotCount]->tts_values[Anum_pg_attribute_attoptions - 1] = attrs_extra->attoptions.value;
765  slot[slotCount]->tts_isnull[Anum_pg_attribute_attoptions - 1] = attrs_extra->attoptions.isnull;
766  }
767  else
768  {
769  slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = true;
770  slot[slotCount]->tts_isnull[Anum_pg_attribute_attoptions - 1] = true;
771  }
772 
773  /*
774  * The remaining fields are not set for new columns.
775  */
776  slot[slotCount]->tts_isnull[Anum_pg_attribute_attacl - 1] = true;
777  slot[slotCount]->tts_isnull[Anum_pg_attribute_attfdwoptions - 1] = true;
778  slot[slotCount]->tts_isnull[Anum_pg_attribute_attmissingval - 1] = true;
779 
780  ExecStoreVirtualTuple(slot[slotCount]);
781  slotCount++;
782 
783  /*
784  * If slots are full or the end of processing has been reached, insert
785  * a batch of tuples.
786  */
787  if (slotCount == nslots || natts == tupdesc->natts - 1)
788  {
789  /* fetch index info only when we know we need it */
790  if (!indstate)
791  {
792  indstate = CatalogOpenIndexes(pg_attribute_rel);
793  close_index = true;
794  }
795 
796  /* insert the new tuples and update the indexes */
797  CatalogTuplesMultiInsertWithInfo(pg_attribute_rel, slot, slotCount,
798  indstate);
799  slotCount = 0;
800  }
801 
802  natts++;
803  }
804 
805  if (close_index)
806  CatalogCloseIndexes(indstate);
807  for (int i = 0; i < nslots; i++)
809  pfree(slot);
810 }
#define Min(x, y)
Definition: c.h:1007
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1639
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1341
const TupleTableSlotOps TTSOpsHeapTuple
Definition: execTuples.c:85
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1325
void CatalogTuplesMultiInsertWithInfo(Relation heapRel, TupleTableSlot **slot, int ntuples, CatalogIndexState indstate)
Definition: indexing.c:273
#define MAX_CATALOG_MULTI_INSERT_BYTES
Definition: indexing.h:33
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
static Datum NameGetDatum(const NameData *X)
Definition: postgres.h:373
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
static Datum CharGetDatum(char X)
Definition: postgres.h:122
Datum value
Definition: postgres.h:75
bool isnull
Definition: postgres.h:77
bool * tts_isnull
Definition: tuptable.h:127
Datum * tts_values
Definition: tuptable.h:125
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:454

References FormExtraData_pg_attribute::attoptions, FormExtraData_pg_attribute::attstattarget, BoolGetDatum(), CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTuplesMultiInsertWithInfo(), CharGetDatum(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), FormData_pg_attribute, i, Int16GetDatum(), Int32GetDatum(), InvalidOid, NullableDatum::isnull, MakeSingleTupleTableSlot(), MAX_CATALOG_MULTI_INSERT_BYTES, Min, NameGetDatum(), TupleDescData::natts, ObjectIdGetDatum(), palloc(), pfree(), RelationGetDescr, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, TTSOpsHeapTuple, TupleDescAttr, and NullableDatum::value.

Referenced by AddNewAttributeTuples(), AppendAttributeTuples(), and ATExecAddColumn().

◆ InsertPgClassTuple()

void InsertPgClassTuple ( Relation  pg_class_desc,
Relation  new_rel_desc,
Oid  new_rel_oid,
Datum  relacl,
Datum  reloptions 
)

Definition at line 896 of file heap.c.

901 {
902  Form_pg_class rd_rel = new_rel_desc->rd_rel;
903  Datum values[Natts_pg_class];
904  bool nulls[Natts_pg_class];
905  HeapTuple tup;
906 
907  /* This is a tad tedious, but way cleaner than what we used to do... */
908  memset(values, 0, sizeof(values));
909  memset(nulls, false, sizeof(nulls));
910 
911  values[Anum_pg_class_oid - 1] = ObjectIdGetDatum(new_rel_oid);
912  values[Anum_pg_class_relname - 1] = NameGetDatum(&rd_rel->relname);
913  values[Anum_pg_class_relnamespace - 1] = ObjectIdGetDatum(rd_rel->relnamespace);
914  values[Anum_pg_class_reltype - 1] = ObjectIdGetDatum(rd_rel->reltype);
915  values[Anum_pg_class_reloftype - 1] = ObjectIdGetDatum(rd_rel->reloftype);
916  values[Anum_pg_class_relowner - 1] = ObjectIdGetDatum(rd_rel->relowner);
917  values[Anum_pg_class_relam - 1] = ObjectIdGetDatum(rd_rel->relam);
918  values[Anum_pg_class_relfilenode - 1] = ObjectIdGetDatum(rd_rel->relfilenode);
919  values[Anum_pg_class_reltablespace - 1] = ObjectIdGetDatum(rd_rel->reltablespace);
920  values[Anum_pg_class_relpages - 1] = Int32GetDatum(rd_rel->relpages);
921  values[Anum_pg_class_reltuples - 1] = Float4GetDatum(rd_rel->reltuples);
922  values[Anum_pg_class_relallvisible - 1] = Int32GetDatum(rd_rel->relallvisible);
923  values[Anum_pg_class_reltoastrelid - 1] = ObjectIdGetDatum(rd_rel->reltoastrelid);
924  values[Anum_pg_class_relhasindex - 1] = BoolGetDatum(rd_rel->relhasindex);
925  values[Anum_pg_class_relisshared - 1] = BoolGetDatum(rd_rel->relisshared);
926  values[Anum_pg_class_relpersistence - 1] = CharGetDatum(rd_rel->relpersistence);
927  values[Anum_pg_class_relkind - 1] = CharGetDatum(rd_rel->relkind);
928  values[Anum_pg_class_relnatts - 1] = Int16GetDatum(rd_rel->relnatts);
929  values[Anum_pg_class_relchecks - 1] = Int16GetDatum(rd_rel->relchecks);
930  values[Anum_pg_class_relhasrules - 1] = BoolGetDatum(rd_rel->relhasrules);
931  values[Anum_pg_class_relhastriggers - 1] = BoolGetDatum(rd_rel->relhastriggers);
932  values[Anum_pg_class_relrowsecurity - 1] = BoolGetDatum(rd_rel->relrowsecurity);
933  values[Anum_pg_class_relforcerowsecurity - 1] = BoolGetDatum(rd_rel->relforcerowsecurity);
934  values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass);
935  values[Anum_pg_class_relispopulated - 1] = BoolGetDatum(rd_rel->relispopulated);
936  values[Anum_pg_class_relreplident - 1] = CharGetDatum(rd_rel->relreplident);
937  values[Anum_pg_class_relispartition - 1] = BoolGetDatum(rd_rel->relispartition);
938  values[Anum_pg_class_relrewrite - 1] = ObjectIdGetDatum(rd_rel->relrewrite);
939  values[Anum_pg_class_relfrozenxid - 1] = TransactionIdGetDatum(rd_rel->relfrozenxid);
940  values[Anum_pg_class_relminmxid - 1] = MultiXactIdGetDatum(rd_rel->relminmxid);
941  if (relacl != (Datum) 0)
942  values[Anum_pg_class_relacl - 1] = relacl;
943  else
944  nulls[Anum_pg_class_relacl - 1] = true;
945  if (reloptions != (Datum) 0)
946  values[Anum_pg_class_reloptions - 1] = reloptions;
947  else
948  nulls[Anum_pg_class_reloptions - 1] = true;
949 
950  /* relpartbound is set by updating this tuple, if necessary */
951  nulls[Anum_pg_class_relpartbound - 1] = true;
952 
953  tup = heap_form_tuple(RelationGetDescr(pg_class_desc), values, nulls);
954 
955  /* finally insert the new tuple, update the indexes, and clean up */
956  CatalogTupleInsert(pg_class_desc, tup);
957 
958  heap_freetuple(tup);
959 }
static Datum values[MAXATTR]
Definition: bootstrap.c:150
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
Definition: indexing.c:233
static Datum Float4GetDatum(float4 X)
Definition: postgres.h:475
static Datum TransactionIdGetDatum(TransactionId X)
Definition: postgres.h:272
uintptr_t Datum
Definition: postgres.h:64
static Datum MultiXactIdGetDatum(MultiXactId X)
Definition: postgres.h:282

References BoolGetDatum(), CatalogTupleInsert(), CharGetDatum(), Float4GetDatum(), heap_form_tuple(), heap_freetuple(), Int16GetDatum(), Int32GetDatum(), MultiXactIdGetDatum(), NameGetDatum(), ObjectIdGetDatum(), RelationData::rd_rel, RelationGetDescr, TransactionIdGetDatum(), and values.

Referenced by AddNewRelationTuple(), and index_create().

◆ MergeWithExistingConstraint()

static bool MergeWithExistingConstraint ( Relation  rel,
const char *  ccname,
Node expr,
bool  allow_merge,
bool  is_local,
bool  is_initially_valid,
bool  is_no_inherit 
)
static

Definition at line 2507 of file heap.c.

2511 {
2512  bool found;
2513  Relation conDesc;
2514  SysScanDesc conscan;
2515  ScanKeyData skey[3];
2516  HeapTuple tup;
2517 
2518  /* Search for a pg_constraint entry with same name and relation */
2519  conDesc = table_open(ConstraintRelationId, RowExclusiveLock);
2520 
2521  found = false;
2522 
2523  ScanKeyInit(&skey[0],
2524  Anum_pg_constraint_conrelid,
2525  BTEqualStrategyNumber, F_OIDEQ,
2527  ScanKeyInit(&skey[1],
2528  Anum_pg_constraint_contypid,
2529  BTEqualStrategyNumber, F_OIDEQ,
2531  ScanKeyInit(&skey[2],
2532  Anum_pg_constraint_conname,
2533  BTEqualStrategyNumber, F_NAMEEQ,
2534  CStringGetDatum(ccname));
2535 
2536  conscan = systable_beginscan(conDesc, ConstraintRelidTypidNameIndexId, true,
2537  NULL, 3, skey);
2538 
2539  /* There can be at most one matching row */
2540  if (HeapTupleIsValid(tup = systable_getnext(conscan)))
2541  {
2543 
2544  /* Found it. Conflicts if not identical check constraint */
2545  if (con->contype == CONSTRAINT_CHECK)
2546  {
2547  Datum val;
2548  bool isnull;
2549 
2550  val = fastgetattr(tup,
2551  Anum_pg_constraint_conbin,
2552  conDesc->rd_att, &isnull);
2553  if (isnull)
2554  elog(ERROR, "null conbin for rel %s",
2557  found = true;
2558  }
2559 
2560  /*
2561  * If the existing constraint is purely inherited (no local
2562  * definition) then interpret addition of a local constraint as a
2563  * legal merge. This allows ALTER ADD CONSTRAINT on parent and child
2564  * tables to be given in either order with same end state. However if
2565  * the relation is a partition, all inherited constraints are always
2566  * non-local, including those that were merged.
2567  */
2568  if (is_local && !con->conislocal && !rel->rd_rel->relispartition)
2569  allow_merge = true;
2570 
2571  if (!found || !allow_merge)
2572  ereport(ERROR,
2574  errmsg("constraint \"%s\" for relation \"%s\" already exists",
2575  ccname, RelationGetRelationName(rel))));
2576 
2577  /* If the child constraint is "no inherit" then cannot merge */
2578  if (con->connoinherit)
2579  ereport(ERROR,
2580  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2581  errmsg("constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"",
2582  ccname, RelationGetRelationName(rel))));
2583 
2584  /*
2585  * Must not change an existing inherited constraint to "no inherit"
2586  * status. That's because inherited constraints should be able to
2587  * propagate to lower-level children.
2588  */
2589  if (con->coninhcount > 0 && is_no_inherit)
2590  ereport(ERROR,
2591  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2592  errmsg("constraint \"%s\" conflicts with inherited constraint on relation \"%s\"",
2593  ccname, RelationGetRelationName(rel))));
2594 
2595  /*
2596  * If the child constraint is "not valid" then cannot merge with a
2597  * valid parent constraint.
2598  */
2599  if (is_initially_valid && !con->convalidated)
2600  ereport(ERROR,
2601  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2602  errmsg("constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"",
2603  ccname, RelationGetRelationName(rel))));
2604 
2605  /* OK to update the tuple */
2606  ereport(NOTICE,
2607  (errmsg("merging constraint \"%s\" with inherited definition",
2608  ccname)));
2609 
2610  tup = heap_copytuple(tup);
2611  con = (Form_pg_constraint) GETSTRUCT(tup);
2612 
2613  /*
2614  * In case of partitions, an inherited constraint must be inherited
2615  * only once since it cannot have multiple parents and it is never
2616  * considered local.
2617  */
2618  if (rel->rd_rel->relispartition)
2619  {
2620  con->coninhcount = 1;
2621  con->conislocal = false;
2622  }
2623  else
2624  {
2625  if (is_local)
2626  con->conislocal = true;
2627  else if (pg_add_s16_overflow(con->coninhcount, 1,
2628  &con->coninhcount))
2629  ereport(ERROR,
2630  errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2631  errmsg("too many inheritance parents"));
2632  }
2633 
2634  if (is_no_inherit)
2635  {
2636  Assert(is_local);
2637  con->connoinherit = true;
2638  }
2639 
2640  CatalogTupleUpdate(conDesc, &tup->t_self, tup);
2641  }
2642 
2643  systable_endscan(conscan);
2644  table_close(conDesc, RowExclusiveLock);
2645 
2646  return found;
2647 }
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NOTICE
Definition: elog.h:35
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:749
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
long val
Definition: informix.c:689
static bool pg_add_s16_overflow(int16 a, int16 b, int16 *result)
Definition: int.h:67

References Assert, BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), elog, equal(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, fastgetattr(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, InvalidOid, NOTICE, ObjectIdGetDatum(), pg_add_s16_overflow(), RelationData::rd_att, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), TextDatumGetCString, and val.

Referenced by AddRelationNewConstraints().

◆ RelationClearMissing()

void RelationClearMissing ( Relation  rel)

Definition at line 1945 of file heap.c.

1946 {
1947  Relation attr_rel;
1948  Oid relid = RelationGetRelid(rel);
1949  int natts = RelationGetNumberOfAttributes(rel);
1950  int attnum;
1951  Datum repl_val[Natts_pg_attribute];
1952  bool repl_null[Natts_pg_attribute];
1953  bool repl_repl[Natts_pg_attribute];
1954  Form_pg_attribute attrtuple;
1955  HeapTuple tuple,
1956  newtuple;
1957 
1958  memset(repl_val, 0, sizeof(repl_val));
1959  memset(repl_null, false, sizeof(repl_null));
1960  memset(repl_repl, false, sizeof(repl_repl));
1961 
1962  repl_val[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(false);
1963  repl_null[Anum_pg_attribute_attmissingval - 1] = true;
1964 
1965  repl_repl[Anum_pg_attribute_atthasmissing - 1] = true;
1966  repl_repl[Anum_pg_attribute_attmissingval - 1] = true;
1967 
1968 
1969  /* Get a lock on pg_attribute */
1970  attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
1971 
1972  /* process each non-system attribute, including any dropped columns */
1973  for (attnum = 1; attnum <= natts; attnum++)
1974  {
1975  tuple = SearchSysCache2(ATTNUM,
1976  ObjectIdGetDatum(relid),
1978  if (!HeapTupleIsValid(tuple)) /* shouldn't happen */
1979  elog(ERROR, "cache lookup failed for attribute %d of relation %u",
1980  attnum, relid);
1981 
1982  attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
1983 
1984  /* ignore any where atthasmissing is not true */
1985  if (attrtuple->atthasmissing)
1986  {
1987  newtuple = heap_modify_tuple(tuple, RelationGetDescr(attr_rel),
1988  repl_val, repl_null, repl_repl);
1989 
1990  CatalogTupleUpdate(attr_rel, &newtuple->t_self, newtuple);
1991 
1992  heap_freetuple(newtuple);
1993  }
1994 
1995  ReleaseSysCache(tuple);
1996  }
1997 
1998  /*
1999  * Our update of the pg_attribute rows will force a relcache rebuild, so
2000  * there's nothing else to do here.
2001  */
2002  table_close(attr_rel, RowExclusiveLock);
2003 }
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
Definition: heaptuple.c:1209
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:511
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
Definition: syscache.c:232

References attnum, BoolGetDatum(), CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, Int16GetDatum(), ObjectIdGetDatum(), RelationGetDescr, RelationGetNumberOfAttributes, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCache2(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecAlterColumnType(), ATExecSetExpression(), and finish_heap_swap().

◆ RelationRemoveInheritance()

static void RelationRemoveInheritance ( Oid  relid)
static

Definition at line 1524 of file heap.c.

1525 {
1526  Relation catalogRelation;
1527  SysScanDesc scan;
1528  ScanKeyData key;
1529  HeapTuple tuple;
1530 
1531  catalogRelation = table_open(InheritsRelationId, RowExclusiveLock);
1532 
1533  ScanKeyInit(&key,
1534  Anum_pg_inherits_inhrelid,
1535  BTEqualStrategyNumber, F_OIDEQ,
1536  ObjectIdGetDatum(relid));
1537 
1538  scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId, true,
1539  NULL, 1, &key);
1540 
1541  while (HeapTupleIsValid(tuple = systable_getnext(scan)))
1542  CatalogTupleDelete(catalogRelation, &tuple->t_self);
1543 
1544  systable_endscan(scan);
1545  table_close(catalogRelation, RowExclusiveLock);
1546 }

References BTEqualStrategyNumber, CatalogTupleDelete(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by heap_drop_with_catalog().

◆ RelationTruncateIndexes()

static void RelationTruncateIndexes ( Relation  heapRelation)
static

Definition at line 2969 of file heap.c.

2970 {
2971  ListCell *indlist;
2972 
2973  /* Ask the relcache to produce a list of the indexes of the rel */
2974  foreach(indlist, RelationGetIndexList(heapRelation))
2975  {
2976  Oid indexId = lfirst_oid(indlist);
2977  Relation currentIndex;
2978  IndexInfo *indexInfo;
2979 
2980  /* Open the index relation; use exclusive lock, just to be sure */
2981  currentIndex = index_open(indexId, AccessExclusiveLock);
2982 
2983  /*
2984  * Fetch info needed for index_build. Since we know there are no
2985  * tuples that actually need indexing, we can use a dummy IndexInfo.
2986  * This is slightly cheaper to build, but the real point is to avoid
2987  * possibly running user-defined code in index expressions or
2988  * predicates. We might be getting invoked during ON COMMIT
2989  * processing, and we don't want to run any such code then.
2990  */
2991  indexInfo = BuildDummyIndexInfo(currentIndex);
2992 
2993  /*
2994  * Now truncate the actual file (and discard buffers).
2995  */
2996  RelationTruncate(currentIndex, 0);
2997 
2998  /* Initialize the index and rebuild */
2999  /* Note: we do not need to re-establish pkey setting */
3000  index_build(heapRelation, currentIndex, indexInfo, true, false);
3001 
3002  /* We're done with this index */
3003  index_close(currentIndex, NoLock);
3004  }
3005 }
IndexInfo * BuildDummyIndexInfo(Relation index)
Definition: index.c:2490
void index_build(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel)
Definition: index.c:2953
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4804
void RelationTruncate(Relation rel, BlockNumber nblocks)
Definition: storage.c:288

References AccessExclusiveLock, BuildDummyIndexInfo(), index_build(), index_close(), index_open(), lfirst_oid, NoLock, RelationGetIndexList(), and RelationTruncate().

Referenced by heap_truncate_one_rel().

◆ RemoveAttributeById()

void RemoveAttributeById ( Oid  relid,
AttrNumber  attnum 
)

Definition at line 1664 of file heap.c.

1665 {
1666  Relation rel;
1667  Relation attr_rel;
1668  HeapTuple tuple;
1669  Form_pg_attribute attStruct;
1670  char newattname[NAMEDATALEN];
1671  Datum valuesAtt[Natts_pg_attribute] = {0};
1672  bool nullsAtt[Natts_pg_attribute] = {0};
1673  bool replacesAtt[Natts_pg_attribute] = {0};
1674 
1675  /*
1676  * Grab an exclusive lock on the target table, which we will NOT release
1677  * until end of transaction. (In the simple case where we are directly
1678  * dropping this column, ATExecDropColumn already did this ... but when
1679  * cascading from a drop of some other object, we may not have any lock.)
1680  */
1681  rel = relation_open(relid, AccessExclusiveLock);
1682 
1683  attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
1684 
1685  tuple = SearchSysCacheCopy2(ATTNUM,
1686  ObjectIdGetDatum(relid),
1688  if (!HeapTupleIsValid(tuple)) /* shouldn't happen */
1689  elog(ERROR, "cache lookup failed for attribute %d of relation %u",
1690  attnum, relid);
1691  attStruct = (Form_pg_attribute) GETSTRUCT(tuple);
1692 
1693  /* Mark the attribute as dropped */
1694  attStruct->attisdropped = true;
1695 
1696  /*
1697  * Set the type OID to invalid. A dropped attribute's type link cannot be
1698  * relied on (once the attribute is dropped, the type might be too).
1699  * Fortunately we do not need the type row --- the only really essential
1700  * information is the type's typlen and typalign, which are preserved in
1701  * the attribute's attlen and attalign. We set atttypid to zero here as a
1702  * means of catching code that incorrectly expects it to be valid.
1703  */
1704  attStruct->atttypid = InvalidOid;
1705 
1706  /* Remove any not-null constraint the column may have */
1707  attStruct->attnotnull = false;
1708 
1709  /* Unset this so no one tries to look up the generation expression */
1710  attStruct->attgenerated = '\0';
1711 
1712  /*
1713  * Change the column name to something that isn't likely to conflict
1714  */
1715  snprintf(newattname, sizeof(newattname),
1716  "........pg.dropped.%d........", attnum);
1717  namestrcpy(&(attStruct->attname), newattname);
1718 
1719  /* Clear the missing value */
1720  attStruct->atthasmissing = false;
1721  nullsAtt[Anum_pg_attribute_attmissingval - 1] = true;
1722  replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
1723 
1724  /*
1725  * Clear the other nullable fields. This saves some space in pg_attribute
1726  * and removes no longer useful information.
1727  */
1728  nullsAtt[Anum_pg_attribute_attstattarget - 1] = true;
1729  replacesAtt[Anum_pg_attribute_attstattarget - 1] = true;
1730  nullsAtt[Anum_pg_attribute_attacl - 1] = true;
1731  replacesAtt[Anum_pg_attribute_attacl - 1] = true;
1732  nullsAtt[Anum_pg_attribute_attoptions - 1] = true;
1733  replacesAtt[Anum_pg_attribute_attoptions - 1] = true;
1734  nullsAtt[Anum_pg_attribute_attfdwoptions - 1] = true;
1735  replacesAtt[Anum_pg_attribute_attfdwoptions - 1] = true;
1736 
1737  tuple = heap_modify_tuple(tuple, RelationGetDescr(attr_rel),
1738  valuesAtt, nullsAtt, replacesAtt);
1739 
1740  CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
1741 
1742  /*
1743  * Because updating the pg_attribute row will trigger a relcache flush for
1744  * the target relation, we need not do anything else to notify other
1745  * backends of the change.
1746  */
1747 
1748  table_close(attr_rel, RowExclusiveLock);
1749 
1750  RemoveStatistics(relid, attnum);
1751 
1752  relation_close(rel, NoLock);
1753 }
void namestrcpy(Name name, const char *str)
Definition: name.c:233
#define NAMEDATALEN
#define snprintf
Definition: port.h:238
#define SearchSysCacheCopy2(cacheId, key1, key2)
Definition: syscache.h:93

References AccessExclusiveLock, attnum, CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, heap_modify_tuple(), HeapTupleIsValid, Int16GetDatum(), InvalidOid, NAMEDATALEN, namestrcpy(), NoLock, ObjectIdGetDatum(), relation_close(), relation_open(), RelationGetDescr, RemoveStatistics(), RowExclusiveLock, SearchSysCacheCopy2, snprintf, HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

◆ RemovePartitionKeyByRelId()

void RemovePartitionKeyByRelId ( Oid  relid)

Definition at line 3449 of file heap.c.

3450 {
3451  Relation rel;
3452  HeapTuple tuple;
3453 
3454  rel = table_open(PartitionedRelationId, RowExclusiveLock);
3455 
3456  tuple = SearchSysCache1(PARTRELID, ObjectIdGetDatum(relid));
3457  if (!HeapTupleIsValid(tuple))
3458  elog(ERROR, "cache lookup failed for partition key of relation %u",
3459  relid);
3460 
3461  CatalogTupleDelete(rel, &tuple->t_self);
3462 
3463  ReleaseSysCache(tuple);
3465 }

References CatalogTupleDelete(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by heap_drop_with_catalog().

◆ RemoveStatistics()

void RemoveStatistics ( Oid  relid,
AttrNumber  attnum 
)

Definition at line 2922 of file heap.c.

2923 {
2924  Relation pgstatistic;
2925  SysScanDesc scan;
2926  ScanKeyData key[2];
2927  int nkeys;
2928  HeapTuple tuple;
2929 
2930  pgstatistic = table_open(StatisticRelationId, RowExclusiveLock);
2931 
2932  ScanKeyInit(&key[0],
2933  Anum_pg_statistic_starelid,
2934  BTEqualStrategyNumber, F_OIDEQ,
2935  ObjectIdGetDatum(relid));
2936 
2937  if (attnum == 0)
2938  nkeys = 1;
2939  else
2940  {
2941  ScanKeyInit(&key[1],
2942  Anum_pg_statistic_staattnum,
2943  BTEqualStrategyNumber, F_INT2EQ,
2945  nkeys = 2;
2946  }
2947 
2948  scan = systable_beginscan(pgstatistic, StatisticRelidAttnumInhIndexId, true,
2949  NULL, nkeys, key);
2950 
2951  /* we must loop even when attnum != 0, in case of inherited stats */
2952  while (HeapTupleIsValid(tuple = systable_getnext(scan)))
2953  CatalogTupleDelete(pgstatistic, &tuple->t_self);
2954 
2955  systable_endscan(scan);
2956 
2957  table_close(pgstatistic, RowExclusiveLock);
2958 }

References attnum, BTEqualStrategyNumber, CatalogTupleDelete(), HeapTupleIsValid, Int16GetDatum(), sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ATExecAlterColumnType(), ATExecSetExpression(), heap_drop_with_catalog(), index_drop(), and RemoveAttributeById().

◆ SetAttrMissing()

void SetAttrMissing ( Oid  relid,
char *  attname,
char *  value 
)

Definition at line 2013 of file heap.c.

2014 {
2015  Datum valuesAtt[Natts_pg_attribute] = {0};
2016  bool nullsAtt[Natts_pg_attribute] = {0};
2017  bool replacesAtt[Natts_pg_attribute] = {0};
2018  Datum missingval;
2019  Form_pg_attribute attStruct;
2020  Relation attrrel,
2021  tablerel;
2022  HeapTuple atttup,
2023  newtup;
2024 
2025  /* lock the table the attribute belongs to */
2026  tablerel = table_open(relid, AccessExclusiveLock);
2027 
2028  /* Don't do anything unless it's a plain table */
2029  if (tablerel->rd_rel->relkind != RELKIND_RELATION)
2030  {
2031  table_close(tablerel, AccessExclusiveLock);
2032  return;
2033  }
2034 
2035  /* Lock the attribute row and get the data */
2036  attrrel = table_open(AttributeRelationId, RowExclusiveLock);
2037  atttup = SearchSysCacheAttName(relid, attname);
2038  if (!HeapTupleIsValid(atttup))
2039  elog(ERROR, "cache lookup failed for attribute %s of relation %u",
2040  attname, relid);
2041  attStruct = (Form_pg_attribute) GETSTRUCT(atttup);
2042 
2043  /* get an array value from the value string */
2044  missingval = OidFunctionCall3(F_ARRAY_IN,
2046  ObjectIdGetDatum(attStruct->atttypid),
2047  Int32GetDatum(attStruct->atttypmod));
2048 
2049  /* update the tuple - set atthasmissing and attmissingval */
2050  valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);
2051  replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
2052  valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
2053  replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
2054 
2055  newtup = heap_modify_tuple(atttup, RelationGetDescr(attrrel),
2056  valuesAtt, nullsAtt, replacesAtt);
2057  CatalogTupleUpdate(attrrel, &newtup->t_self, newtup);
2058 
2059  /* clean up */
2060  ReleaseSysCache(atttup);
2061  table_close(attrrel, RowExclusiveLock);
2062  table_close(tablerel, AccessExclusiveLock);
2063 }
#define OidFunctionCall3(functionId, arg1, arg2, arg3)
Definition: fmgr.h:683
static struct @157 value
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
Definition: syscache.c:476

References AccessExclusiveLock, attname, BoolGetDatum(), CatalogTupleUpdate(), CStringGetDatum(), elog, ERROR, GETSTRUCT, heap_modify_tuple(), HeapTupleIsValid, Int32GetDatum(), ObjectIdGetDatum(), OidFunctionCall3, RelationData::rd_rel, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), HeapTupleData::t_self, table_close(), table_open(), and value.

Referenced by binary_upgrade_set_missing_value().

◆ SetRelationNumChecks()

static void SetRelationNumChecks ( Relation  rel,
int  numchecks 
)
static

Definition at line 2660 of file heap.c.

2661 {
2662  Relation relrel;
2663  HeapTuple reltup;
2664  Form_pg_class relStruct;
2665 
2666  relrel = table_open(RelationRelationId, RowExclusiveLock);
2667  reltup = SearchSysCacheCopy1(RELOID,
2669  if (!HeapTupleIsValid(reltup))
2670  elog(ERROR, "cache lookup failed for relation %u",
2671  RelationGetRelid(rel));
2672  relStruct = (Form_pg_class) GETSTRUCT(reltup);
2673 
2674  if (relStruct->relchecks != numchecks)
2675  {
2676  relStruct->relchecks = numchecks;
2677 
2678  CatalogTupleUpdate(relrel, &reltup->t_self, reltup);
2679  }
2680  else
2681  {
2682  /* Skip the disk update, but force relcache inval anyway */
2684  }
2685 
2686  heap_freetuple(reltup);
2687  table_close(relrel, RowExclusiveLock);
2688 }
void CacheInvalidateRelcache(Relation relation)
Definition: inval.c:1360
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:91

References CacheInvalidateRelcache(), CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by AddRelationNewConstraints(), and StoreConstraints().

◆ StoreConstraints()

static void StoreConstraints ( Relation  rel,
List cooked_constraints,
bool  is_internal 
)
static

Definition at line 2185 of file heap.c.

2186 {
2187  int numchecks = 0;
2188  ListCell *lc;
2189 
2190  if (cooked_constraints == NIL)
2191  return; /* nothing to do */
2192 
2193  /*
2194  * Deparsing of constraint expressions will fail unless the just-created
2195  * pg_attribute tuples for this relation are made visible. So, bump the
2196  * command counter. CAUTION: this will cause a relcache entry rebuild.
2197  */
2199 
2200  foreach(lc, cooked_constraints)
2201  {
2202  CookedConstraint *con = (CookedConstraint *) lfirst(lc);
2203 
2204  switch (con->contype)
2205  {
2206  case CONSTR_DEFAULT:
2207  con->conoid = StoreAttrDefault(rel, con->attnum, con->expr,
2208  is_internal, false);
2209  break;
2210  case CONSTR_CHECK:
2211  con->conoid =
2212  StoreRelCheck(rel, con->name, con->expr,
2213  !con->skip_validation, con->is_local,
2214  con->inhcount, con->is_no_inherit,
2215  is_internal);
2216  numchecks++;
2217  break;
2218  default:
2219  elog(ERROR, "unrecognized constraint type: %d",
2220  (int) con->contype);
2221  }
2222  }
2223 
2224  if (numchecks > 0)
2225  SetRelationNumChecks(rel, numchecks);
2226 }
void CommandCounterIncrement(void)
Definition: xact.c:1099

References CookedConstraint::attnum, CommandCounterIncrement(), CookedConstraint::conoid, CONSTR_CHECK, CONSTR_DEFAULT, CookedConstraint::contype, elog, ERROR, CookedConstraint::expr, CookedConstraint::inhcount, CookedConstraint::is_local, CookedConstraint::is_no_inherit, lfirst, CookedConstraint::name, NIL, SetRelationNumChecks(), CookedConstraint::skip_validation, StoreAttrDefault(), and StoreRelCheck().

Referenced by heap_create_with_catalog().

◆ StorePartitionBound()

void StorePartitionBound ( Relation  rel,
Relation  parent,
PartitionBoundSpec bound 
)

Definition at line 3480 of file heap.c.

3481 {
3482  Relation classRel;
3483  HeapTuple tuple,
3484  newtuple;
3485  Datum new_val[Natts_pg_class];
3486  bool new_null[Natts_pg_class],
3487  new_repl[Natts_pg_class];
3488  Oid defaultPartOid;
3489 
3490  /* Update pg_class tuple */
3491  classRel = table_open(RelationRelationId, RowExclusiveLock);
3492  tuple = SearchSysCacheCopy1(RELOID,
3494  if (!HeapTupleIsValid(tuple))
3495  elog(ERROR, "cache lookup failed for relation %u",
3496  RelationGetRelid(rel));
3497 
3498 #ifdef USE_ASSERT_CHECKING
3499  {
3500  Form_pg_class classForm;
3501  bool isnull;
3502 
3503  classForm = (Form_pg_class) GETSTRUCT(tuple);
3504  Assert(!classForm->relispartition);
3505  (void) SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relpartbound,
3506  &isnull);
3507  Assert(isnull);
3508  }
3509 #endif
3510 
3511  /* Fill in relpartbound value */
3512  memset(new_val, 0, sizeof(new_val));
3513  memset(new_null, false, sizeof(new_null));
3514  memset(new_repl, false, sizeof(new_repl));
3515  new_val[Anum_pg_class_relpartbound - 1] = CStringGetTextDatum(nodeToString(bound));
3516  new_null[Anum_pg_class_relpartbound - 1] = false;
3517  new_repl[Anum_pg_class_relpartbound - 1] = true;
3518  newtuple = heap_modify_tuple(tuple, RelationGetDescr(classRel),
3519  new_val, new_null, new_repl);
3520  /* Also set the flag */
3521  ((Form_pg_class) GETSTRUCT(newtuple))->relispartition = true;
3522 
3523  /*
3524  * We already checked for no inheritance children, but reset
3525  * relhassubclass in case it was left over.
3526  */
3527  if (rel->rd_rel->relkind == RELKIND_RELATION && rel->rd_rel->relhassubclass)
3528  ((Form_pg_class) GETSTRUCT(newtuple))->relhassubclass = false;
3529 
3530  CatalogTupleUpdate(classRel, &newtuple->t_self, newtuple);
3531  heap_freetuple(newtuple);
3532  table_close(classRel, RowExclusiveLock);
3533 
3534  /*
3535  * If we're storing bounds for the default partition, update
3536  * pg_partitioned_table too.
3537  */
3538  if (bound->is_default)
3540  RelationGetRelid(rel));
3541 
3542  /* Make these updates visible */
3544 
3545  /*
3546  * The partition constraint for the default partition depends on the
3547  * partition bounds of every other partition, so we must invalidate the
3548  * relcache entry for that partition every time a partition is added or
3549  * removed.
3550  */
3551  defaultPartOid =
3553  if (OidIsValid(defaultPartOid))
3554  CacheInvalidateRelcacheByRelid(defaultPartOid);
3555 
3556  CacheInvalidateRelcache(parent);
3557 }
#define CStringGetTextDatum(s)
Definition: builtins.h:97
char * nodeToString(const void *obj)
Definition: outfuncs.c:794
PartitionDesc RelationGetPartitionDesc(Relation rel, bool omit_detached)
Definition: partdesc.c:71
Oid get_default_oid_from_partdesc(PartitionDesc partdesc)
Definition: partdesc.c:501
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:596

References Assert, CacheInvalidateRelcache(), CacheInvalidateRelcacheByRelid(), CatalogTupleUpdate(), CommandCounterIncrement(), CStringGetTextDatum, elog, ERROR, get_default_oid_from_partdesc(), GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, PartitionBoundSpec::is_default, nodeToString(), ObjectIdGetDatum(), OidIsValid, RelationData::rd_rel, RelationGetDescr, RelationGetPartitionDesc(), RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and update_default_partition_oid().

Referenced by ATExecAttachPartition(), and DefineRelation().

◆ StorePartitionKey()

void StorePartitionKey ( Relation  rel,
char  strategy,
int16  partnatts,
AttrNumber partattrs,
List partexprs,
Oid partopclass,
Oid partcollation 
)

Definition at line 3324 of file heap.c.

3331 {
3332  int i;
3333  int2vector *partattrs_vec;
3334  oidvector *partopclass_vec;
3335  oidvector *partcollation_vec;
3336  Datum partexprDatum;
3337  Relation pg_partitioned_table;
3338  HeapTuple tuple;
3339  Datum values[Natts_pg_partitioned_table];
3340  bool nulls[Natts_pg_partitioned_table] = {0};
3341  ObjectAddress myself;
3342  ObjectAddress referenced;
3343  ObjectAddresses *addrs;
3344 
3345  Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
3346 
3347  /* Copy the partition attribute numbers, opclass OIDs into arrays */
3348  partattrs_vec = buildint2vector(partattrs, partnatts);
3349  partopclass_vec = buildoidvector(partopclass, partnatts);
3350  partcollation_vec = buildoidvector(partcollation, partnatts);
3351 
3352  /* Convert the expressions (if any) to a text datum */
3353  if (partexprs)
3354  {
3355  char *exprString;
3356 
3357  exprString = nodeToString(partexprs);
3358  partexprDatum = CStringGetTextDatum(exprString);
3359  pfree(exprString);
3360  }
3361  else
3362  partexprDatum = (Datum) 0;
3363 
3364  pg_partitioned_table = table_open(PartitionedRelationId, RowExclusiveLock);
3365 
3366  /* Only this can ever be NULL */
3367  if (!partexprDatum)
3368  nulls[Anum_pg_partitioned_table_partexprs - 1] = true;
3369 
3370  values[Anum_pg_partitioned_table_partrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
3371  values[Anum_pg_partitioned_table_partstrat - 1] = CharGetDatum(strategy);
3372  values[Anum_pg_partitioned_table_partnatts - 1] = Int16GetDatum(partnatts);
3373  values[Anum_pg_partitioned_table_partdefid - 1] = ObjectIdGetDatum(InvalidOid);
3374  values[Anum_pg_partitioned_table_partattrs - 1] = PointerGetDatum(partattrs_vec);
3375  values[Anum_pg_partitioned_table_partclass - 1] = PointerGetDatum(partopclass_vec);
3376  values[Anum_pg_partitioned_table_partcollation - 1] = PointerGetDatum(partcollation_vec);
3377  values[Anum_pg_partitioned_table_partexprs - 1] = partexprDatum;
3378 
3379  tuple = heap_form_tuple(RelationGetDescr(pg_partitioned_table), values, nulls);
3380 
3381  CatalogTupleInsert(pg_partitioned_table, tuple);
3382  table_close(pg_partitioned_table, RowExclusiveLock);
3383 
3384  /* Mark this relation as dependent on a few things as follows */
3385  addrs = new_object_addresses();
3386  ObjectAddressSet(myself, RelationRelationId, RelationGetRelid(rel));
3387 
3388  /* Operator class and collation per key column */
3389  for (i = 0; i < partnatts; i++)
3390  {
3391  ObjectAddressSet(referenced, OperatorClassRelationId, partopclass[i]);
3392  add_exact_object_address(&referenced, addrs);
3393 
3394  /* The default collation is pinned, so don't bother recording it */
3395  if (OidIsValid(partcollation[i]) &&
3396  partcollation[i] != DEFAULT_COLLATION_OID)
3397  {
3398  ObjectAddressSet(referenced, CollationRelationId, partcollation[i]);
3399  add_exact_object_address(&referenced, addrs);
3400  }
3401  }
3402 
3404  free_object_addresses(addrs);
3405 
3406  /*
3407  * The partitioning columns are made internally dependent on the table,
3408  * because we cannot drop any of them without dropping the whole table.
3409  * (ATExecDropColumn independently enforces that, but it's not bulletproof
3410  * so we need the dependencies too.)
3411  */
3412  for (i = 0; i < partnatts; i++)
3413  {
3414  if (partattrs[i] == 0)
3415  continue; /* ignore expressions here */
3416 
3417  ObjectAddressSubSet(referenced, RelationRelationId,
3418  RelationGetRelid(rel), partattrs[i]);
3419  recordDependencyOn(&referenced, &myself, DEPENDENCY_INTERNAL);
3420  }
3421 
3422  /*
3423  * Also consider anything mentioned in partition expressions. External
3424  * references (e.g. functions) get NORMAL dependencies. Table columns
3425  * mentioned in the expressions are handled the same as plain partitioning
3426  * columns, i.e. they become internally dependent on the whole table.
3427  */
3428  if (partexprs)
3430  (Node *) partexprs,
3431  RelationGetRelid(rel),
3434  true /* reverse the self-deps */ );
3435 
3436  /*
3437  * We must invalidate the relcache so that the next
3438  * CommandCounterIncrement() will cause the same to be rebuilt using the
3439  * information in just created catalog entry.
3440  */
3442 }
void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)
Definition: dependency.c:1596
@ DEPENDENCY_INTERNAL
Definition: dependency.h:35
int2vector * buildint2vector(const int16 *int2s, int n)
Definition: int.c:114
oidvector * buildoidvector(const Oid *oids, int n)
Definition: oid.c:87
Definition: c.h:718
Definition: c.h:729

References add_exact_object_address(), Assert, buildint2vector(), buildoidvector(), CacheInvalidateRelcache(), CatalogTupleInsert(), CharGetDatum(), CStringGetTextDatum, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, free_object_addresses(), heap_form_tuple(), i, Int16GetDatum(), InvalidOid, new_object_addresses(), nodeToString(), ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum(), OidIsValid, pfree(), PointerGetDatum(), RelationData::rd_rel, record_object_address_dependencies(), recordDependencyOn(), recordDependencyOnSingleRelExpr(), RelationGetDescr, RelationGetRelid, RowExclusiveLock, table_close(), table_open(), and values.

Referenced by DefineRelation().

◆ StoreRelCheck()

static Oid StoreRelCheck ( Relation  rel,
const char *  ccname,
Node expr,
bool  is_validated,
bool  is_local,
int16  inhcount,
bool  is_no_inherit,
bool  is_internal 
)
static

Definition at line 2074 of file heap.c.

2077 {
2078  char *ccbin;
2079  List *varList;
2080  int keycount;
2081  int16 *attNos;
2082  Oid constrOid;
2083 
2084  /*
2085  * Flatten expression to string form for storage.
2086  */
2087  ccbin = nodeToString(expr);
2088 
2089  /*
2090  * Find columns of rel that are used in expr
2091  *
2092  * NB: pull_var_clause is okay here only because we don't allow subselects
2093  * in check constraints; it would fail to examine the contents of
2094  * subselects.
2095  */
2096  varList = pull_var_clause(expr, 0);
2097  keycount = list_length(varList);
2098 
2099  if (keycount > 0)
2100  {
2101  ListCell *vl;
2102  int i = 0;
2103 
2104  attNos = (int16 *) palloc(keycount * sizeof(int16));
2105  foreach(vl, varList)
2106  {
2107  Var *var = (Var *) lfirst(vl);
2108  int j;
2109 
2110  for (j = 0; j < i; j++)
2111  if (attNos[j] == var->varattno)
2112  break;
2113  if (j == i)
2114  attNos[i++] = var->varattno;
2115  }
2116  keycount = i;
2117  }
2118  else
2119  attNos = NULL;
2120 
2121  /*
2122  * Partitioned tables do not contain any rows themselves, so a NO INHERIT
2123  * constraint makes no sense.
2124  */
2125  if (is_no_inherit &&
2126  rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
2127  ereport(ERROR,
2128  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
2129  errmsg("cannot add NO INHERIT constraint to partitioned table \"%s\"",
2130  RelationGetRelationName(rel))));
2131 
2132  /*
2133  * Create the Check Constraint
2134  */
2135  constrOid =
2136  CreateConstraintEntry(ccname, /* Constraint Name */
2137  RelationGetNamespace(rel), /* namespace */
2138  CONSTRAINT_CHECK, /* Constraint Type */
2139  false, /* Is Deferrable */
2140  false, /* Is Deferred */
2141  is_validated,
2142  InvalidOid, /* no parent constraint */
2143  RelationGetRelid(rel), /* relation */
2144  attNos, /* attrs in the constraint */
2145  keycount, /* # key attrs in the constraint */
2146  keycount, /* # total attrs in the constraint */
2147  InvalidOid, /* not a domain constraint */
2148  InvalidOid, /* no associated index */
2149  InvalidOid, /* Foreign key fields */
2150  NULL,
2151  NULL,
2152  NULL,
2153  NULL,
2154  0,
2155  ' ',
2156  ' ',
2157  NULL,
2158  0,
2159  ' ',
2160  NULL, /* not an exclusion constraint */
2161  expr, /* Tree form of check constraint */
2162  ccbin, /* Binary form of check constraint */
2163  is_local, /* conislocal */
2164  inhcount, /* coninhcount */
2165  is_no_inherit, /* connoinherit */
2166  false, /* conperiod */
2167  is_internal); /* internally constructed? */
2168 
2169  pfree(ccbin);
2170 
2171  return constrOid;
2172 }
signed short int16
Definition: c.h:496
Oid CreateConstraintEntry(const char *constraintName, Oid constraintNamespace, char constraintType, bool isDeferrable, bool isDeferred, bool isValidated, Oid parentConstrId, Oid relId, const int16 *constraintKey, int constraintNKeys, int constraintNTotalKeys, Oid domainId, Oid indexRelId, Oid foreignRelId, const int16 *foreignKey, const Oid *pfEqOp, const Oid *ppEqOp, const Oid *ffEqOp, int foreignNKeys, char foreignUpdateType, char foreignDeleteType, const int16 *fkDeleteSetCols, int numFkDeleteSetCols, char foreignMatchType, const Oid *exclOp, Node *conExpr, const char *conBin, bool conIsLocal, int16 conInhCount, bool conNoInherit, bool conPeriod, bool is_internal)
Definition: pg_constraint.c:50

References CreateConstraintEntry(), ereport, errcode(), errmsg(), ERROR, i, InvalidOid, j, lfirst, list_length(), nodeToString(), palloc(), pfree(), pull_var_clause(), RelationData::rd_rel, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, and Var::varattno.

Referenced by AddRelationNewConstraints(), and StoreConstraints().

◆ SystemAttributeByName()

const FormData_pg_attribute* SystemAttributeByName ( const char *  attname)

Definition at line 252 of file heap.c.

253 {
254  int j;
255 
256  for (j = 0; j < (int) lengthof(SysAtt); j++)
257  {
258  const FormData_pg_attribute *att = SysAtt[j];
259 
260  if (strcmp(NameStr(att->attname), attname) == 0)
261  return att;
262  }
263 
264  return NULL;
265 }

References attname, FormData_pg_attribute, j, lengthof, NameStr, and SysAtt.

Referenced by CheckAttributeNamesTypes(), expanded_record_lookup_field(), specialAttNum(), SPI_fnumber(), and transformIndexConstraint().

◆ SystemAttributeDefinition()

const FormData_pg_attribute* SystemAttributeDefinition ( AttrNumber  attno)

Definition at line 240 of file heap.c.

241 {
242  if (attno >= 0 || attno < -(int) lengthof(SysAtt))
243  elog(ERROR, "invalid system attribute number %d", attno);
244  return SysAtt[-attno - 1];
245 }

References elog, ERROR, lengthof, and SysAtt.

Referenced by attnumAttName(), attnumTypeId(), build_index_tlist(), scanNSItemForColumn(), SPI_fname(), SPI_gettype(), SPI_gettypeid(), SPI_getvalue(), and transformIndexConstraint().

Variable Documentation

◆ a1

const FormData_pg_attribute a1
static
Initial value:
= {
.attname = {"ctid"},
.atttypid = TIDOID,
.attlen = sizeof(ItemPointerData),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = false,
.attalign = TYPALIGN_SHORT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
struct ItemPointerData ItemPointerData
char attstorage
Definition: pg_attribute.h:117
bool attbyval
Definition: pg_attribute.h:103
char attalign
Definition: pg_attribute.h:109
bool attnotnull
Definition: pg_attribute.h:130
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21

Definition at line 142 of file heap.c.

Referenced by aclitem_eq(), aclitem_match(), aclitemComparator(), brin_minmax_multi_distance_float4(), brin_minmax_multi_distance_float8(), brin_minmax_multi_distance_int2(), brin_minmax_multi_distance_int4(), brin_minmax_multi_distance_int8(), brin_minmax_multi_distance_numeric(), brin_minmax_multi_distance_uuid(), build_distances(), cmpaffix(), deccall2(), deccall3(), distance_1D(), entryIndexByFrequencyCmp(), evalLazyFunc(), float8_qsort_cmp(), inet_merge(), inet_same_family(), int4gcd_internal(), int8gcd_internal(), macaddr8_cmp(), macaddr8_cmp_internal(), macaddr8_eq(), macaddr8_ge(), macaddr8_gt(), macaddr8_le(), macaddr8_lt(), macaddr8_ne(), macaddr_cmp(), macaddr_cmp_internal(), macaddr_eq(), macaddr_ge(), macaddr_gt(), macaddr_le(), macaddr_lt(), macaddr_ne(), MergeAffix(), network_cmp(), network_cmp_internal(), network_eq(), network_ge(), network_gt(), network_larger(), network_le(), network_lt(), network_ne(), network_overlap(), network_smaller(), network_sub(), network_subeq(), network_sup(), network_supeq(), packArcInfoCmp(), range_bound_qsort_cmp(), and sqrt_var().

◆ a2

const FormData_pg_attribute a2
static
Initial value:
= {
.attname = {"xmin"},
.atttypid = XIDOID,
.attlen = sizeof(TransactionId),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = true,
.attalign = TYPALIGN_INT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
#define MinTransactionIdAttributeNumber
Definition: sysattr.h:22

Definition at line 156 of file heap.c.

Referenced by aclitem_eq(), aclitem_match(), aclitemComparator(), brin_minmax_multi_distance_float4(), brin_minmax_multi_distance_float8(), brin_minmax_multi_distance_int2(), brin_minmax_multi_distance_int4(), brin_minmax_multi_distance_int8(), brin_minmax_multi_distance_numeric(), brin_minmax_multi_distance_uuid(), build_distances(), clonesuccessorstates(), cmpaffix(), deccall2(), deccall3(), distance_1D(), entryIndexByFrequencyCmp(), evalLazyFunc(), float8_qsort_cmp(), inet_merge(), inet_same_family(), int4gcd_internal(), int8gcd_internal(), macaddr8_cmp(), macaddr8_cmp_internal(), macaddr8_eq(), macaddr8_ge(), macaddr8_gt(), macaddr8_le(), macaddr8_lt(), macaddr8_ne(), macaddr_cmp(), macaddr_cmp_internal(), macaddr_eq(), macaddr_ge(), macaddr_gt(), macaddr_le(), macaddr_lt(), macaddr_ne(), MergeAffix(), network_cmp(), network_cmp_internal(), network_eq(), network_ge(), network_gt(), network_larger(), network_le(), network_lt(), network_ne(), network_overlap(), network_smaller(), network_sub(), network_subeq(), network_sup(), network_supeq(), packArcInfoCmp(), and range_bound_qsort_cmp().

◆ a3

const FormData_pg_attribute a3
static
Initial value:
= {
.attname = {"cmin"},
.atttypid = CIDOID,
.attlen = sizeof(CommandId),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = true,
.attalign = TYPALIGN_INT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
uint32 CommandId
Definition: c.h:669
#define MinCommandIdAttributeNumber
Definition: sysattr.h:23

Definition at line 170 of file heap.c.

◆ a4

const FormData_pg_attribute a4
static
Initial value:
= {
.attname = {"xmax"},
.atttypid = XIDOID,
.attlen = sizeof(TransactionId),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = true,
.attalign = TYPALIGN_INT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
#define MaxTransactionIdAttributeNumber
Definition: sysattr.h:24

Definition at line 184 of file heap.c.

◆ a5

const FormData_pg_attribute a5
static
Initial value:
= {
.attname = {"cmax"},
.atttypid = CIDOID,
.attlen = sizeof(CommandId),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = true,
.attalign = TYPALIGN_INT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
#define MaxCommandIdAttributeNumber
Definition: sysattr.h:25

Definition at line 198 of file heap.c.

◆ a6

const FormData_pg_attribute a6
static
Initial value:
= {
.attname = {"tableoid"},
.atttypid = OIDOID,
.attlen = sizeof(Oid),
.attcacheoff = -1,
.atttypmod = -1,
.attbyval = true,
.attalign = TYPALIGN_INT,
.attstorage = TYPSTORAGE_PLAIN,
.attnotnull = true,
.attislocal = true,
}
#define TableOidAttributeNumber
Definition: sysattr.h:26

Definition at line 218 of file heap.c.

◆ binary_upgrade_next_heap_pg_class_oid

Oid binary_upgrade_next_heap_pg_class_oid = InvalidOid

Definition at line 80 of file heap.c.

Referenced by binary_upgrade_set_next_heap_pg_class_oid(), and heap_create_with_catalog().

◆ binary_upgrade_next_heap_pg_class_relfilenumber

RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber = InvalidRelFileNumber

◆ binary_upgrade_next_toast_pg_class_oid

Oid binary_upgrade_next_toast_pg_class_oid = InvalidOid

◆ binary_upgrade_next_toast_pg_class_relfilenumber

RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber = InvalidRelFileNumber

Definition at line 83 of file heap.c.

Referenced by binary_upgrade_set_next_toast_relfilenode(), and heap_create_with_catalog().

◆ SysAtt

const FormData_pg_attribute* const SysAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6}
static

Definition at line 232 of file heap.c.

Referenced by AddNewAttributeTuples(), SystemAttributeByName(), and SystemAttributeDefinition().