#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 "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:

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, int 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 Node *	cookConstraint (ParseState pstate, Node raw_constraint, char *relname)

const FormData_pg_attribute *	SystemAttributeDefinition (AttrNumber attno)

const FormData_pg_attribute *	SystemAttributeByName (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, Datum *attoptions, 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)

List *	AddRelationNewConstraints (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)

Node *	cookDefault (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)

List *	heap_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 *	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 804 of file heap.c.

 {
     Relation    rel;
     CatalogIndexState indstate;
     int         natts = tupdesc->natts;
     ObjectAddress myself,
                 referenced;
  
     /*
      * open pg_attribute and its indexes.
      */
     rel = table_open(AttributeRelationId, RowExclusiveLock);
  
     indstate = CatalogOpenIndexes(rel);
  
     /* set stats detail level to a sane default */
     for (int i = 0; i < natts; i++)
         tupdesc->attrs[i].attstattarget = -1;
     InsertPgAttributeTuples(rel, tupdesc, new_rel_oid, NULL, indstate);
  
     /* add dependencies on their datatypes and collations */
     for (int i = 0; i < natts; i++)
     {
         /* Add dependency info */
         ObjectAddressSubSet(myself, RelationRelationId, new_rel_oid, i + 1);
         ObjectAddressSet(referenced, TypeRelationId,
                          tupdesc->attrs[i].atttypid);
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
  
         /* The default collation is pinned, so don't bother recording it */
         if (OidIsValid(tupdesc->attrs[i].attcollation) &&
             tupdesc->attrs[i].attcollation != DEFAULT_COLLATION_OID)
         {
             ObjectAddressSet(referenced, CollationRelationId,
                              tupdesc->attrs[i].attcollation);
             recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
         }
     }
  
     /*
      * Next we add the system attributes.  Skip OID if rel has no OIDs. Skip
      * all for a view or type relation.  We don't bother with making datatype
      * dependencies here, since presumably all these types are pinned.
      */
     if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
     {
         TupleDesc   td;
  
         td = CreateTupleDesc(lengthof(SysAtt), (FormData_pg_attribute **) &SysAtt);
  
         InsertPgAttributeTuples(rel, td, new_rel_oid, NULL, indstate);
         FreeTupleDesc(td);
     }
  
     /*
      * clean up
      */
     CatalogCloseIndexes(indstate);
  
     table_close(rel, RowExclusiveLock);
 }

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

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 955 of file heap.c.

 {
     Form_pg_class new_rel_reltup;
  
     /*
      * first we update some of the information in our uncataloged relation's
      * relation descriptor.
      */
     new_rel_reltup = new_rel_desc->rd_rel;
  
     /* The relation is empty */
     new_rel_reltup->relpages = 0;
     new_rel_reltup->reltuples = -1;
     new_rel_reltup->relallvisible = 0;
  
     /* Sequences always have a known size */
     if (relkind == RELKIND_SEQUENCE)
     {
         new_rel_reltup->relpages = 1;
         new_rel_reltup->reltuples = 1;
     }
  
     new_rel_reltup->relfrozenxid = relfrozenxid;
     new_rel_reltup->relminmxid = relminmxid;
     new_rel_reltup->relowner = relowner;
     new_rel_reltup->reltype = new_type_oid;
     new_rel_reltup->reloftype = reloftype;
  
     /* relispartition is always set by updating this tuple later */
     new_rel_reltup->relispartition = false;
  
     /* fill rd_att's type ID with something sane even if reltype is zero */
     new_rel_desc->rd_att->tdtypeid = new_type_oid ? new_type_oid : RECORDOID;
     new_rel_desc->rd_att->tdtypmod = -1;
  
     /* Now build and insert the tuple */
     InsertPgClassTuple(pg_class_desc, new_rel_desc, new_rel_oid,
                        relacl, reloptions);
 }

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 1013 of file heap.c.

 {
     return
         TypeCreate(new_row_type,    /* optional predetermined OID */
                    typeName,    /* type name */
                    typeNamespace,   /* type namespace */
                    new_rel_oid, /* relation oid */
                    new_rel_kind,    /* relation kind */
                    ownerid,     /* owner's ID */
                    -1,          /* internal size (varlena) */
                    TYPTYPE_COMPOSITE,   /* type-type (composite) */
                    TYPCATEGORY_COMPOSITE,   /* type-category (ditto) */
                    false,       /* composite types are never preferred */
                    DEFAULT_TYPDELIM,    /* default array delimiter */
                    F_RECORD_IN, /* input procedure */
                    F_RECORD_OUT,    /* output procedure */
                    F_RECORD_RECV,   /* receive procedure */
                    F_RECORD_SEND,   /* send procedure */
                    InvalidOid,  /* typmodin procedure - none */
                    InvalidOid,  /* typmodout procedure - none */
                    InvalidOid,  /* analyze procedure - default */
                    InvalidOid,  /* subscript procedure - none */
                    InvalidOid,  /* array element type - irrelevant */
                    false,       /* this is not an array type */
                    new_array_type,  /* array type if any */
                    InvalidOid,  /* domain base type - irrelevant */
                    NULL,        /* default value - none */
                    NULL,        /* default binary representation */
                    false,       /* passed by reference */
                    TYPALIGN_DOUBLE, /* alignment - must be the largest! */
                    TYPSTORAGE_EXTENDED, /* fully TOASTable */
                    -1,          /* typmod */
                    0,           /* array dimensions for typBaseType */
                    false,       /* Type NOT NULL */
                    InvalidOid); /* rowtypes never have a collation */
 }

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 2246 of file heap.c.

 {
     List       *cookedConstraints = NIL;
     TupleDesc   tupleDesc;
     TupleConstr *oldconstr;
     int         numoldchecks;
     ParseState *pstate;
     ParseNamespaceItem *nsitem;
     int         numchecks;
     List       *checknames;
     ListCell   *cell;
     Node       *expr;
     CookedConstraint *cooked;
  
     /*
      * Get info about existing constraints.
      */
     tupleDesc = RelationGetDescr(rel);
     oldconstr = tupleDesc->constr;
     if (oldconstr)
         numoldchecks = oldconstr->num_check;
     else
         numoldchecks = 0;
  
     /*
      * Create a dummy ParseState and insert the target relation as its sole
      * rangetable entry.  We need a ParseState for transformExpr.
      */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
     nsitem = addRangeTableEntryForRelation(pstate,
                                            rel,
                                            AccessShareLock,
                                            NULL,
                                            false,
                                            true);
     addNSItemToQuery(pstate, nsitem, true, true, true);
  
     /*
      * Process column default expressions.
      */
     foreach(cell, newColDefaults)
     {
         RawColumnDefault *colDef = (RawColumnDefault *) lfirst(cell);
         Form_pg_attribute atp = TupleDescAttr(rel->rd_att, colDef->attnum - 1);
         Oid         defOid;
  
         expr = cookDefault(pstate, colDef->raw_default,
                            atp->atttypid, atp->atttypmod,
                            NameStr(atp->attname),
                            atp->attgenerated);
  
         /*
          * If the expression is just a NULL constant, we do not bother to make
          * an explicit pg_attrdef entry, since the default behavior is
          * equivalent.  This applies to column defaults, but not for
          * generation expressions.
          *
          * Note a nonobvious property of this test: if the column is of a
          * domain type, what we'll get is not a bare null Const but a
          * CoerceToDomain expr, so we will not discard the default.  This is
          * critical because the column default needs to be retained to
          * override any default that the domain might have.
          */
         if (expr == NULL ||
             (!colDef->generated &&
              IsA(expr, Const) &&
              castNode(Const, expr)->constisnull))
             continue;
  
         /* If the DEFAULT is volatile we cannot use a missing value */
         if (colDef->missingMode && contain_volatile_functions((Node *) expr))
             colDef->missingMode = false;
  
         defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal,
                                   colDef->missingMode);
  
         cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
         cooked->contype = CONSTR_DEFAULT;
         cooked->conoid = defOid;
         cooked->name = NULL;
         cooked->attnum = colDef->attnum;
         cooked->expr = expr;
         cooked->skip_validation = false;
         cooked->is_local = is_local;
         cooked->inhcount = is_local ? 0 : 1;
         cooked->is_no_inherit = false;
         cookedConstraints = lappend(cookedConstraints, cooked);
     }
  
     /*
      * Process constraint expressions.
      */
     numchecks = numoldchecks;
     checknames = NIL;
     foreach(cell, newConstraints)
     {
         Constraint *cdef = (Constraint *) lfirst(cell);
         char       *ccname;
         Oid         constrOid;
  
         if (cdef->contype != CONSTR_CHECK)
             continue;
  
         if (cdef->raw_expr != NULL)
         {
             Assert(cdef->cooked_expr == NULL);
  
             /*
              * Transform raw parsetree to executable expression, and verify
              * it's valid as a CHECK constraint.
              */
             expr = cookConstraint(pstate, cdef->raw_expr,
                                   RelationGetRelationName(rel));
         }
         else
         {
             Assert(cdef->cooked_expr != NULL);
  
             /*
              * Here, we assume the parser will only pass us valid CHECK
              * expressions, so we do no particular checking.
              */
             expr = stringToNode(cdef->cooked_expr);
         }
  
         /*
          * Check name uniqueness, or generate a name if none was given.
          */
         if (cdef->conname != NULL)
         {
             ListCell   *cell2;
  
             ccname = cdef->conname;
             /* Check against other new constraints */
             /* Needed because we don't do CommandCounterIncrement in loop */
             foreach(cell2, checknames)
             {
                 if (strcmp((char *) lfirst(cell2), ccname) == 0)
                     ereport(ERROR,
                             (errcode(ERRCODE_DUPLICATE_OBJECT),
                              errmsg("check constraint \"%s\" already exists",
                                     ccname)));
             }
  
             /* save name for future checks */
             checknames = lappend(checknames, ccname);
  
             /*
              * Check against pre-existing constraints.  If we are allowed to
              * merge with an existing constraint, there's no more to do here.
              * (We omit the duplicate constraint from the result, which is
              * what ATAddCheckConstraint wants.)
              */
             if (MergeWithExistingConstraint(rel, ccname, expr,
                                             allow_merge, is_local,
                                             cdef->initially_valid,
                                             cdef->is_no_inherit))
                 continue;
         }
         else
         {
             /*
              * When generating a name, we want to create "tab_col_check" for a
              * column constraint and "tab_check" for a table constraint.  We
              * no longer have any info about the syntactic positioning of the
              * constraint phrase, so we approximate this by seeing whether the
              * expression references more than one column.  (If the user
              * played by the rules, the result is the same...)
              *
              * Note: pull_var_clause() doesn't descend into sublinks, but we
              * eliminated those above; and anyway this only needs to be an
              * approximate answer.
              */
             List       *vars;
             char       *colname;
  
             vars = pull_var_clause(expr, 0);
  
             /* eliminate duplicates */
             vars = list_union(NIL, vars);
  
             if (list_length(vars) == 1)
                 colname = get_attname(RelationGetRelid(rel),
                                       ((Var *) linitial(vars))->varattno,
                                       true);
             else
                 colname = NULL;
  
             ccname = ChooseConstraintName(RelationGetRelationName(rel),
                                           colname,
                                           "check",
                                           RelationGetNamespace(rel),
                                           checknames);
  
             /* save name for future checks */
             checknames = lappend(checknames, ccname);
         }
  
         /*
          * OK, store it.
          */
         constrOid =
             StoreRelCheck(rel, ccname, expr, cdef->initially_valid, is_local,
                           is_local ? 0 : 1, cdef->is_no_inherit, is_internal);
  
         numchecks++;
  
         cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
         cooked->contype = CONSTR_CHECK;
         cooked->conoid = constrOid;
         cooked->name = ccname;
         cooked->attnum = 0;
         cooked->expr = expr;
         cooked->skip_validation = cdef->skip_validation;
         cooked->is_local = is_local;
         cooked->inhcount = is_local ? 0 : 1;
         cooked->is_no_inherit = cdef->is_no_inherit;
         cookedConstraints = lappend(cookedConstraints, cooked);
     }
  
     /*
      * Update the count of constraints in the relation's pg_class tuple. We do
      * this even if there was no change, in order to ensure that an SI update
      * message is sent out for the pg_class tuple, which will force other
      * backends to rebuild their relcache entries for the rel. (This is
      * critical if we added defaults but not constraints.)
      */
     SetRelationNumChecks(rel, numchecks);
  
     return cookedConstraints;
 }

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

◆ check_nested_generated()

static void check_nested_generated	(	ParseState *	pstate,
		Node *	node
	)

static

Definition at line 2722 of file heap.c.

 {
     check_nested_generated_walker(node, pstate);
 }

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 2680 of file heap.c.

 {
     ParseState *pstate = context;
  
     if (node == NULL)
         return false;
     else if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
         Oid         relid;
         AttrNumber  attnum;
  
         relid = rt_fetch(var->varno, pstate->p_rtable)->relid;
         if (!OidIsValid(relid))
             return false;       /* XXX shouldn't we raise an error? */
  
         attnum = var->varattno;
  
         if (attnum > 0 && get_attgenerated(relid, attnum))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cannot use generated column \"%s\" in column generation expression",
                             get_attname(relid, attnum, false)),
                      errdetail("A generated column cannot reference another generated column."),
                      parser_errposition(pstate, var->location)));
         /* A whole-row Var is necessarily self-referential, so forbid it */
         if (attnum == 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cannot use whole-row variable in column generation expression"),
                      errdetail("This would cause the generated column to depend on its own value."),
                      parser_errposition(pstate, var->location)));
         /* System columns were already checked in the parser */
  
         return false;
     }
     else
         return expression_tree_walker(node, check_nested_generated_walker,
                                       (void *) context);
 }

References attnum, 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 455 of file heap.c.

 {
     int         i;
     int         j;
     int         natts = tupdesc->natts;
  
     /* Sanity check on column count */
     if (natts < 0 || natts > MaxHeapAttributeNumber)
         ereport(ERROR,
                 (errcode(ERRCODE_TOO_MANY_COLUMNS),
                  errmsg("tables can have at most %d columns",
                         MaxHeapAttributeNumber)));
  
     /*
      * first check for collision with system attribute names
      *
      * Skip this for a view or type relation, since those don't have system
      * attributes.
      */
     if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
     {
         for (i = 0; i < natts; i++)
         {
             Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
  
             if (SystemAttributeByName(NameStr(attr->attname)) != NULL)
                 ereport(ERROR,
                         (errcode(ERRCODE_DUPLICATE_COLUMN),
                          errmsg("column name \"%s\" conflicts with a system column name",
                                 NameStr(attr->attname))));
         }
     }
  
     /*
      * next check for repeated attribute names
      */
     for (i = 1; i < natts; i++)
     {
         for (j = 0; j < i; j++)
         {
             if (strcmp(NameStr(TupleDescAttr(tupdesc, j)->attname),
                        NameStr(TupleDescAttr(tupdesc, i)->attname)) == 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_DUPLICATE_COLUMN),
                          errmsg("column name \"%s\" specified more than once",
                                 NameStr(TupleDescAttr(tupdesc, j)->attname))));
         }
     }
  
     /*
      * next check the attribute types
      */
     for (i = 0; i < natts; i++)
     {
         CheckAttributeType(NameStr(TupleDescAttr(tupdesc, i)->attname),
                            TupleDescAttr(tupdesc, i)->atttypid,
                            TupleDescAttr(tupdesc, i)->attcollation,
                            NIL, /* assume we're creating a new rowtype */
                            flags);
     }
 }

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 547 of file heap.c.

 {
     char        att_typtype = get_typtype(atttypid);
     Oid         att_typelem;
  
     if (att_typtype == TYPTYPE_PSEUDO)
     {
         /*
          * We disallow pseudo-type columns, with the exception of ANYARRAY,
          * RECORD, and RECORD[] when the caller says that those are OK.
          *
          * We don't need to worry about recursive containment for RECORD and
          * RECORD[] because (a) no named composite type should be allowed to
          * contain those, and (b) two "anonymous" record types couldn't be
          * considered to be the same type, so infinite recursion isn't
          * possible.
          */
         if (!((atttypid == ANYARRAYOID && (flags & CHKATYPE_ANYARRAY)) ||
               (atttypid == RECORDOID && (flags & CHKATYPE_ANYRECORD)) ||
               (atttypid == RECORDARRAYOID && (flags & CHKATYPE_ANYRECORD))))
         {
             if (flags & CHKATYPE_IS_PARTKEY)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 /* translator: first %s is an integer not a name */
                          errmsg("partition key column %s has pseudo-type %s",
                                 attname, format_type_be(atttypid))));
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                          errmsg("column \"%s\" has pseudo-type %s",
                                 attname, format_type_be(atttypid))));
         }
     }
     else if (att_typtype == TYPTYPE_DOMAIN)
     {
         /*
          * If it's a domain, recurse to check its base type.
          */
         CheckAttributeType(attname, getBaseType(atttypid), attcollation,
                            containing_rowtypes,
                            flags);
     }
     else if (att_typtype == TYPTYPE_COMPOSITE)
     {
         /*
          * For a composite type, recurse into its attributes.
          */
         Relation    relation;
         TupleDesc   tupdesc;
         int         i;
  
         /*
          * Check for self-containment.  Eventually we might be able to allow
          * this (just return without complaint, if so) but it's not clear how
          * many other places would require anti-recursion defenses before it
          * would be safe to allow tables to contain their own rowtype.
          */
         if (list_member_oid(containing_rowtypes, atttypid))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("composite type %s cannot be made a member of itself",
                             format_type_be(atttypid))));
  
         containing_rowtypes = lappend_oid(containing_rowtypes, atttypid);
  
         relation = relation_open(get_typ_typrelid(atttypid), AccessShareLock);
  
         tupdesc = RelationGetDescr(relation);
  
         for (i = 0; i < tupdesc->natts; i++)
         {
             Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
  
             if (attr->attisdropped)
                 continue;
             CheckAttributeType(NameStr(attr->attname),
                                attr->atttypid, attr->attcollation,
                                containing_rowtypes,
                                flags & ~CHKATYPE_IS_PARTKEY);
         }
  
         relation_close(relation, AccessShareLock);
  
         containing_rowtypes = list_delete_last(containing_rowtypes);
     }
     else if (att_typtype == TYPTYPE_RANGE)
     {
         /*
          * If it's a range, recurse to check its subtype.
          */
         CheckAttributeType(attname, get_range_subtype(atttypid),
                            get_range_collation(atttypid),
                            containing_rowtypes,
                            flags);
     }
     else if (OidIsValid((att_typelem = get_element_type(atttypid))))
     {
         /*
          * Must recurse into array types, too, in case they are composite.
          */
         CheckAttributeType(attname, att_typelem, attcollation,
                            containing_rowtypes,
                            flags);
     }
  
     /*
      * This might not be strictly invalid per SQL standard, but it is pretty
      * useless, and it cannot be dumped, so we must disallow it.
      */
     if (!OidIsValid(attcollation) && type_is_collatable(atttypid))
     {
         if (flags & CHKATYPE_IS_PARTKEY)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
             /* translator: first %s is an integer not a name */
                      errmsg("no collation was derived for partition key column %s with collatable type %s",
                             attname, format_type_be(atttypid)),
                      errhint("Use the COLLATE clause to set the collation explicitly.")));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("no collation was derived for column \"%s\" with collatable type %s",
                             attname, format_type_be(atttypid)),
                      errhint("Use the COLLATE clause to set the collation explicitly.")));
     }
 }

References AccessShareLock, attname, 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 2815 of file heap.c.

 {
     Node       *expr;
  
     /*
      * Transform raw parsetree to executable expression.
      */
     expr = transformExpr(pstate, raw_constraint, EXPR_KIND_CHECK_CONSTRAINT);
  
     /*
      * Make sure it yields a boolean result.
      */
     expr = coerce_to_boolean(pstate, expr, "CHECK");
  
     /*
      * Take care of collations.
      */
     assign_expr_collations(pstate, expr);
  
     /*
      * Make sure no outside relations are referred to (this is probably dead
      * code now that add_missing_from is history).
      */
     if (list_length(pstate->p_rtable) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("only table \"%s\" can be referenced in check constraint",
                         relname)));
  
     return expr;
 }

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 2740 of file heap.c.

 {
     Node       *expr;
  
     Assert(raw_default != NULL);
  
     /*
      * Transform raw parsetree to executable expression.
      */
     expr = transformExpr(pstate, raw_default, attgenerated ? EXPR_KIND_GENERATED_COLUMN : EXPR_KIND_COLUMN_DEFAULT);
  
     if (attgenerated)
     {
         check_nested_generated(pstate, expr);
  
         if (contain_mutable_functions(expr))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("generation expression is not immutable")));
     }
     else
     {
         /*
          * For a default expression, transformExpr() should have rejected
          * column references.
          */
         Assert(!contain_var_clause(expr));
     }
  
     /*
      * Coerce the expression to the correct type and typmod, if given. This
      * should match the parser's processing of non-defaulted expressions ---
      * see transformAssignedExpr().
      */
     if (OidIsValid(atttypid))
     {
         Oid         type_id = exprType(expr);
  
         expr = coerce_to_target_type(pstate, expr, type_id,
                                      atttypid, atttypmod,
                                      COERCION_ASSIGNMENT,
                                      COERCE_IMPLICIT_CAST,
                                      -1);
         if (expr == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                      errmsg("column \"%s\" is of type %s"
                             " but default expression is of type %s",
                             attname,
                             format_type_be(atttypid),
                             format_type_be(type_id)),
                      errhint("You will need to rewrite or cast the expression.")));
     }
  
     /*
      * Finally, take care of collations in the finished expression.
      */
     assign_expr_collations(pstate, expr);
  
     return expr;
 }

References Assert(), assign_expr_collations(), attname, check_nested_generated(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, contain_mutable_functions(), 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 2853 of file heap.c.

 {
     HeapTuple   tup;
     SysScanDesc scan;
     ScanKeyData key[1];
     Relation    statrel;
     CatalogIndexState indstate = NULL;
  
     statrel = table_open(StatisticRelationId, RowExclusiveLock);
  
     /* Now search for stat records */
     ScanKeyInit(&key[0],
                 Anum_pg_statistic_starelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(fromrelid));
  
     scan = systable_beginscan(statrel, StatisticRelidAttnumInhIndexId,
                               true, NULL, 1, key);
  
     while (HeapTupleIsValid((tup = systable_getnext(scan))))
     {
         Form_pg_statistic statform;
  
         /* make a modifiable copy */
         tup = heap_copytuple(tup);
         statform = (Form_pg_statistic) GETSTRUCT(tup);
  
         /* update the copy of the tuple and insert it */
         statform->starelid = torelid;
  
         /* fetch index information when we know we need it */
         if (indstate == NULL)
             indstate = CatalogOpenIndexes(statrel);
  
         CatalogTupleInsertWithInfo(statrel, tup, indstate);
  
         heap_freetuple(tup);
     }
  
     systable_endscan(scan);
  
     if (indstate != NULL)
         CatalogCloseIndexes(indstate);
     table_close(statrel, RowExclusiveLock);
 }

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 1565 of file heap.c.

 {
     Relation    attrel;
     SysScanDesc scan;
     ScanKeyData key[1];
     HeapTuple   atttup;
  
     /* Grab an appropriate lock on the pg_attribute relation */
     attrel = table_open(AttributeRelationId, RowExclusiveLock);
  
     /* Use the index to scan only attributes of the target relation */
     ScanKeyInit(&key[0],
                 Anum_pg_attribute_attrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
  
     scan = systable_beginscan(attrel, AttributeRelidNumIndexId, true,
                               NULL, 1, key);
  
     /* Delete all the matching tuples */
     while ((atttup = systable_getnext(scan)) != NULL)
         CatalogTupleDelete(attrel, &atttup->t_self);
  
     /* Clean up after the scan */
     systable_endscan(scan);
     table_close(attrel, RowExclusiveLock);
 }

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 1536 of file heap.c.

 {
     Relation    pg_class_desc;
     HeapTuple   tup;
  
     /* Grab an appropriate lock on the pg_class relation */
     pg_class_desc = table_open(RelationRelationId, RowExclusiveLock);
  
     tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tup))
         elog(ERROR, "cache lookup failed for relation %u", relid);
  
     /* delete the relation tuple from pg_class, and finish up */
     CatalogTupleDelete(pg_class_desc, &tup->t_self);
  
     ReleaseSysCache(tup);
  
     table_close(pg_class_desc, RowExclusiveLock);
 }

References CatalogTupleDelete(), elog(), ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), RELOID, 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 1602 of file heap.c.

 {
     Relation    attrel;
     SysScanDesc scan;
     ScanKeyData key[2];
     HeapTuple   atttup;
  
     /* Grab an appropriate lock on the pg_attribute relation */
     attrel = table_open(AttributeRelationId, RowExclusiveLock);
  
     /* Use the index to scan only system attributes of the target relation */
     ScanKeyInit(&key[0],
                 Anum_pg_attribute_attrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
     ScanKeyInit(&key[1],
                 Anum_pg_attribute_attnum,
                 BTLessEqualStrategyNumber, F_INT2LE,
                 Int16GetDatum(0));
  
     scan = systable_beginscan(attrel, AttributeRelidNumIndexId, true,
                               NULL, 2, key);
  
     /* Delete all the matching tuples */
     while ((atttup = systable_getnext(scan)) != NULL)
         CatalogTupleDelete(attrel, &atttup->t_self);
  
     /* Clean up after the scan */
     systable_endscan(scan);
     table_close(attrel, RowExclusiveLock);
 }

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 288 of file heap.c.

 {
     Relation    rel;
  
     /* The caller must have provided an OID for the relation. */
     Assert(OidIsValid(relid));
  
     /*
      * Don't allow creating relations in pg_catalog directly, even though it
      * is allowed to move user defined relations there. Semantics with search
      * paths including pg_catalog are too confusing for now.
      *
      * But allow creating indexes on relations in pg_catalog even if
      * allow_system_table_mods = off, upper layers already guarantee it's on a
      * user defined relation, not a system one.
      */
     if (!allow_system_table_mods &&
         ((IsCatalogNamespace(relnamespace) && relkind != RELKIND_INDEX) ||
          IsToastNamespace(relnamespace)) &&
         IsNormalProcessingMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied to create \"%s.%s\"",
                         get_namespace_name(relnamespace), relname),
                  errdetail("System catalog modifications are currently disallowed.")));
  
     *relfrozenxid = InvalidTransactionId;
     *relminmxid = InvalidMultiXactId;
  
     /*
      * Force reltablespace to zero if the relation kind does not support
      * tablespaces.  This is mainly just for cleanliness' sake.
      */
     if (!RELKIND_HAS_TABLESPACE(relkind))
         reltablespace = InvalidOid;
  
     /* Don't create storage for relkinds without physical storage. */
     if (!RELKIND_HAS_STORAGE(relkind))
         create_storage = false;
     else
     {
         /*
          * If relfilenumber is unspecified by the caller then create storage
          * with oid same as relid.
          */
         if (!RelFileNumberIsValid(relfilenumber))
             relfilenumber = relid;
     }
  
     /*
      * Never allow a pg_class entry to explicitly specify the database's
      * default tablespace in reltablespace; force it to zero instead. This
      * ensures that if the database is cloned with a different default
      * tablespace, the pg_class entry will still match where CREATE DATABASE
      * will put the physically copied relation.
      *
      * Yes, this is a bit of a hack.
      */
     if (reltablespace == MyDatabaseTableSpace)
         reltablespace = InvalidOid;
  
     /*
      * build the relcache entry.
      */
     rel = RelationBuildLocalRelation(relname,
                                      relnamespace,
                                      tupDesc,
                                      relid,
                                      accessmtd,
                                      relfilenumber,
                                      reltablespace,
                                      shared_relation,
                                      mapped_relation,
                                      relpersistence,
                                      relkind);
  
     /*
      * Have the storage manager create the relation's disk file, if needed.
      *
      * For tables, the AM callback creates both the main and the init fork.
      * For others, only the main fork is created; the other forks will be
      * created on demand.
      */
     if (create_storage)
     {
         if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
             table_relation_set_new_filelocator(rel, &rel->rd_locator,
                                                relpersistence,
                                                relfrozenxid, relminmxid);
         else if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
             RelationCreateStorage(rel->rd_locator, relpersistence, true);
         else
             Assert(false);
     }
  
     /*
      * If a tablespace is specified, removal of that tablespace is normally
      * protected by the existence of a physical file; but for relations with
      * no files, add a pg_shdepend entry to account for that.
      */
     if (!create_storage && reltablespace != InvalidOid)
         recordDependencyOnTablespace(RelationRelationId, relid,
                                      reltablespace);
  
     /* ensure that stats are dropped if transaction aborts */
     pgstat_create_relation(rel);
  
     return rel;
 }

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 1091 of file heap.c.

 {
     Relation    pg_class_desc;
     Relation    new_rel_desc;
     Acl        *relacl;
     Oid         existing_relid;
     Oid         old_type_oid;
     Oid         new_type_oid;
  
     /* By default set to InvalidOid unless overridden by binary-upgrade */
     RelFileNumber relfilenumber = InvalidRelFileNumber;
     TransactionId relfrozenxid;
     MultiXactId relminmxid;
  
     pg_class_desc = table_open(RelationRelationId, RowExclusiveLock);
  
     /*
      * sanity checks
      */
     Assert(IsNormalProcessingMode() || IsBootstrapProcessingMode());
  
     /*
      * Validate proposed tupdesc for the desired relkind.  If
      * allow_system_table_mods is on, allow ANYARRAY to be used; this is a
      * hack to allow creating pg_statistic and cloning it during VACUUM FULL.
      */
     CheckAttributeNamesTypes(tupdesc, relkind,
                              allow_system_table_mods ? CHKATYPE_ANYARRAY : 0);
  
     /*
      * This would fail later on anyway, if the relation already exists.  But
      * by catching it here we can emit a nicer error message.
      */
     existing_relid = get_relname_relid(relname, relnamespace);
     if (existing_relid != InvalidOid)
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_TABLE),
                  errmsg("relation \"%s\" already exists", relname)));
  
     /*
      * Since we are going to create a rowtype as well, also check for
      * collision with an existing type name.  If there is one and it's an
      * autogenerated array, we can rename it out of the way; otherwise we can
      * at least give a good error message.
      */
     old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
                                    CStringGetDatum(relname),
                                    ObjectIdGetDatum(relnamespace));
     if (OidIsValid(old_type_oid))
     {
         if (!moveArrayTypeName(old_type_oid, relname, relnamespace))
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("type \"%s\" already exists", relname),
                      errhint("A relation has an associated type of the same name, "
                              "so you must use a name that doesn't conflict "
                              "with any existing type.")));
     }
  
     /*
      * Shared relations must be in pg_global (last-ditch check)
      */
     if (shared_relation && reltablespace != GLOBALTABLESPACE_OID)
         elog(ERROR, "shared relations must be placed in pg_global tablespace");
  
     /*
      * Allocate an OID for the relation, unless we were told what to use.
      *
      * The OID will be the relfilenumber as well, so make sure it doesn't
      * collide with either pg_class OIDs or existing physical files.
      */
     if (!OidIsValid(relid))
     {
         /* Use binary-upgrade override for pg_class.oid and relfilenumber */
         if (IsBinaryUpgrade)
         {
             /*
              * Indexes are not supported here; they use
              * binary_upgrade_next_index_pg_class_oid.
              */
             Assert(relkind != RELKIND_INDEX);
             Assert(relkind != RELKIND_PARTITIONED_INDEX);
  
             if (relkind == RELKIND_TOASTVALUE)
             {
                 /* There might be no TOAST table, so we have to test for it. */
                 if (OidIsValid(binary_upgrade_next_toast_pg_class_oid))
                 {
                     relid = binary_upgrade_next_toast_pg_class_oid;
                     binary_upgrade_next_toast_pg_class_oid = InvalidOid;
  
                     if (!RelFileNumberIsValid(binary_upgrade_next_toast_pg_class_relfilenumber))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                  errmsg("toast relfilenumber value not set when in binary upgrade mode")));
  
                     relfilenumber = binary_upgrade_next_toast_pg_class_relfilenumber;
                     binary_upgrade_next_toast_pg_class_relfilenumber = InvalidRelFileNumber;
                 }
             }
             else
             {
                 if (!OidIsValid(binary_upgrade_next_heap_pg_class_oid))
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                              errmsg("pg_class heap OID value not set when in binary upgrade mode")));
  
                 relid = binary_upgrade_next_heap_pg_class_oid;
                 binary_upgrade_next_heap_pg_class_oid = InvalidOid;
  
                 if (RELKIND_HAS_STORAGE(relkind))
                 {
                     if (!RelFileNumberIsValid(binary_upgrade_next_heap_pg_class_relfilenumber))
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                  errmsg("relfilenumber value not set when in binary upgrade mode")));
  
                     relfilenumber = binary_upgrade_next_heap_pg_class_relfilenumber;
                     binary_upgrade_next_heap_pg_class_relfilenumber = InvalidRelFileNumber;
                 }
             }
         }
  
         if (!OidIsValid(relid))
             relid = GetNewRelFileNumber(reltablespace, pg_class_desc,
                                         relpersistence);
     }
  
     /*
      * Determine the relation's initial permissions.
      */
     if (use_user_acl)
     {
         switch (relkind)
         {
             case RELKIND_RELATION:
             case RELKIND_VIEW:
             case RELKIND_MATVIEW:
             case RELKIND_FOREIGN_TABLE:
             case RELKIND_PARTITIONED_TABLE:
                 relacl = get_user_default_acl(OBJECT_TABLE, ownerid,
                                               relnamespace);
                 break;
             case RELKIND_SEQUENCE:
                 relacl = get_user_default_acl(OBJECT_SEQUENCE, ownerid,
                                               relnamespace);
                 break;
             default:
                 relacl = NULL;
                 break;
         }
     }
     else
         relacl = NULL;
  
     /*
      * Create the relcache entry (mostly dummy at this point) and the physical
      * disk file.  (If we fail further down, it's the smgr's responsibility to
      * remove the disk file again.)
      *
      * NB: Note that passing create_storage = true is correct even for binary
      * upgrade.  The storage we create here will be replaced later, but we
      * need to have something on disk in the meanwhile.
      */
     new_rel_desc = heap_create(relname,
                                relnamespace,
                                reltablespace,
                                relid,
                                relfilenumber,
                                accessmtd,
                                tupdesc,
                                relkind,
                                relpersistence,
                                shared_relation,
                                mapped_relation,
                                allow_system_table_mods,
                                &relfrozenxid,
                                &relminmxid,
                                true);
  
     Assert(relid == RelationGetRelid(new_rel_desc));
  
     new_rel_desc->rd_rel->relrewrite = relrewrite;
  
     /*
      * Decide whether to create a pg_type entry for the relation's rowtype.
      * These types are made except where the use of a relation as such is an
      * implementation detail: toast tables, sequences and indexes.
      */
     if (!(relkind == RELKIND_SEQUENCE ||
           relkind == RELKIND_TOASTVALUE ||
           relkind == RELKIND_INDEX ||
           relkind == RELKIND_PARTITIONED_INDEX))
     {
         Oid         new_array_oid;
         ObjectAddress new_type_addr;
         char       *relarrayname;
  
         /*
          * We'll make an array over the composite type, too.  For largely
          * historical reasons, the array type's OID is assigned first.
          */
         new_array_oid = AssignTypeArrayOid();
  
         /*
          * Make the pg_type entry for the composite type.  The OID of the
          * composite type can be preselected by the caller, but if reltypeid
          * is InvalidOid, we'll generate a new OID for it.
          *
          * NOTE: we could get a unique-index failure here, in case someone
          * else is creating the same type name in parallel but hadn't
          * committed yet when we checked for a duplicate name above.
          */
         new_type_addr = AddNewRelationType(relname,
                                            relnamespace,
                                            relid,
                                            relkind,
                                            ownerid,
                                            reltypeid,
                                            new_array_oid);
         new_type_oid = new_type_addr.objectId;
         if (typaddress)
             *typaddress = new_type_addr;
  
         /* Now create the array type. */
         relarrayname = makeArrayTypeName(relname, relnamespace);
  
         TypeCreate(new_array_oid,   /* force the type's OID to this */
                    relarrayname,    /* Array type name */
                    relnamespace,    /* Same namespace as parent */
                    InvalidOid,  /* Not composite, no relationOid */
                    0,           /* relkind, also N/A here */
                    ownerid,     /* owner's ID */
                    -1,          /* Internal size (varlena) */
                    TYPTYPE_BASE,    /* Not composite - typelem is */
                    TYPCATEGORY_ARRAY,   /* type-category (array) */
                    false,       /* array types are never preferred */
                    DEFAULT_TYPDELIM,    /* default array delimiter */
                    F_ARRAY_IN,  /* array input proc */
                    F_ARRAY_OUT, /* array output proc */
                    F_ARRAY_RECV,    /* array recv (bin) proc */
                    F_ARRAY_SEND,    /* array send (bin) proc */
                    InvalidOid,  /* typmodin procedure - none */
                    InvalidOid,  /* typmodout procedure - none */
                    F_ARRAY_TYPANALYZE,  /* array analyze procedure */
                    F_ARRAY_SUBSCRIPT_HANDLER,   /* array subscript procedure */
                    new_type_oid,    /* array element type - the rowtype */
                    true,        /* yes, this is an array type */
                    InvalidOid,  /* this has no array type */
                    InvalidOid,  /* domain base type - irrelevant */
                    NULL,        /* default value - none */
                    NULL,        /* default binary representation */
                    false,       /* passed by reference */
                    TYPALIGN_DOUBLE, /* alignment - must be the largest! */
                    TYPSTORAGE_EXTENDED, /* fully TOASTable */
                    -1,          /* typmod */
                    0,           /* array dimensions for typBaseType */
                    false,       /* Type NOT NULL */
                    InvalidOid); /* rowtypes never have a collation */
  
         pfree(relarrayname);
     }
     else
     {
         /* Caller should not be expecting a type to be created. */
         Assert(reltypeid == InvalidOid);
         Assert(typaddress == NULL);
  
         new_type_oid = InvalidOid;
     }
  
     /*
      * now create an entry in pg_class for the relation.
      *
      * NOTE: we could get a unique-index failure here, in case someone else is
      * creating the same relation name in parallel but hadn't committed yet
      * when we checked for a duplicate name above.
      */
     AddNewRelationTuple(pg_class_desc,
                         new_rel_desc,
                         relid,
                         new_type_oid,
                         reloftypeid,
                         ownerid,
                         relkind,
                         relfrozenxid,
                         relminmxid,
                         PointerGetDatum(relacl),
                         reloptions);
  
     /*
      * now add tuples to pg_attribute for the attributes in our new relation.
      */
     AddNewAttributeTuples(relid, new_rel_desc->rd_att, relkind);
  
     /*
      * Make a dependency link to force the relation to be deleted if its
      * namespace is.  Also make a dependency link to its owner, as well as
      * dependencies for any roles mentioned in the default ACL.
      *
      * For composite types, these dependencies are tracked for the pg_type
      * entry, so we needn't record them here.  Likewise, TOAST tables don't
      * need a namespace dependency (they live in a pinned namespace) nor an
      * owner dependency (they depend indirectly through the parent table), nor
      * should they have any ACL entries.  The same applies for extension
      * dependencies.
      *
      * Also, skip this in bootstrap mode, since we don't make dependencies
      * while bootstrapping.
      */
     if (relkind != RELKIND_COMPOSITE_TYPE &&
         relkind != RELKIND_TOASTVALUE &&
         !IsBootstrapProcessingMode())
     {
         ObjectAddress myself,
                     referenced;
         ObjectAddresses *addrs;
  
         ObjectAddressSet(myself, RelationRelationId, relid);
  
         recordDependencyOnOwner(RelationRelationId, relid, ownerid);
  
         recordDependencyOnNewAcl(RelationRelationId, relid, 0, ownerid, relacl);
  
         recordDependencyOnCurrentExtension(&myself, false);
  
         addrs = new_object_addresses();
  
         ObjectAddressSet(referenced, NamespaceRelationId, relnamespace);
         add_exact_object_address(&referenced, addrs);
  
         if (reloftypeid)
         {
             ObjectAddressSet(referenced, TypeRelationId, reloftypeid);
             add_exact_object_address(&referenced, addrs);
         }
  
         /*
          * Make a dependency link to force the relation to be deleted if its
          * access method is.
          *
          * No need to add an explicit dependency for the toast table, as the
          * main table depends on it.
          */
         if (RELKIND_HAS_TABLE_AM(relkind) && relkind != RELKIND_TOASTVALUE)
         {
             ObjectAddressSet(referenced, AccessMethodRelationId, accessmtd);
             add_exact_object_address(&referenced, addrs);
         }
  
         record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
         free_object_addresses(addrs);
     }
  
     /* Post creation hook for new relation */
     InvokeObjectPostCreateHookArg(RelationRelationId, relid, 0, is_internal);
  
     /*
      * Store any supplied constraints and defaults.
      *
      * NB: this may do a CommandCounterIncrement and rebuild the relcache
      * entry, so the relation must be valid and self-consistent at this point.
      * In particular, there are not yet constraints and defaults anywhere.
      */
     StoreConstraints(new_rel_desc, cooked_constraints, is_internal);
  
     /*
      * If there's a special on-commit action, remember it
      */
     if (oncommit != ONCOMMIT_NOOP)
         register_on_commit_action(relid, oncommit);
  
     /*
      * ok, the relation has been cataloged, so close our relations and return
      * the OID of the newly created relation.
      */
     table_close(new_rel_desc, NoLock);  /* do not unlock till end of xact */
     table_close(pg_class_desc, RowExclusiveLock);
  
     return relid;
 }

References 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, 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(), TypeCreate(), and TYPENAMENSP.

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

◆ heap_drop_with_catalog()

void heap_drop_with_catalog ( Oid relid )

Definition at line 1755 of file heap.c.

 {
     Relation    rel;
     HeapTuple   tuple;
     Oid         parentOid = InvalidOid,
                 defaultPartOid = InvalidOid;
  
     /*
      * To drop a partition safely, we must grab exclusive lock on its parent,
      * because another backend might be about to execute a query on the parent
      * table.  If it relies on previously cached partition descriptor, then it
      * could attempt to access the just-dropped relation as its partition. We
      * must therefore take a table lock strong enough to prevent all queries
      * on the table from proceeding until we commit and send out a
      * shared-cache-inval notice that will make them update their partition
      * descriptors.
      */
     tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for relation %u", relid);
     if (((Form_pg_class) GETSTRUCT(tuple))->relispartition)
     {
         /*
          * We have to lock the parent if the partition is being detached,
          * because it's possible that some query still has a partition
          * descriptor that includes this partition.
          */
         parentOid = get_partition_parent(relid, true);
         LockRelationOid(parentOid, AccessExclusiveLock);
  
         /*
          * If this is not the default partition, dropping it will change the
          * default partition's partition constraint, so we must lock it.
          */
         defaultPartOid = get_default_partition_oid(parentOid);
         if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
             LockRelationOid(defaultPartOid, AccessExclusiveLock);
     }
  
     ReleaseSysCache(tuple);
  
     /*
      * Open and lock the relation.
      */
     rel = relation_open(relid, AccessExclusiveLock);
  
     /*
      * There can no longer be anyone *else* touching the relation, but we
      * might still have open queries or cursors, or pending trigger events, in
      * our own session.
      */
     CheckTableNotInUse(rel, "DROP TABLE");
  
     /*
      * This effectively deletes all rows in the table, and may be done in a
      * serializable transaction.  In that case we must record a rw-conflict in
      * to this transaction from each transaction holding a predicate lock on
      * the table.
      */
     CheckTableForSerializableConflictIn(rel);
  
     /*
      * Delete pg_foreign_table tuple first.
      */
     if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
     {
         Relation    ftrel;
         HeapTuple   fttuple;
  
         ftrel = table_open(ForeignTableRelationId, RowExclusiveLock);
  
         fttuple = SearchSysCache1(FOREIGNTABLEREL, ObjectIdGetDatum(relid));
         if (!HeapTupleIsValid(fttuple))
             elog(ERROR, "cache lookup failed for foreign table %u", relid);
  
         CatalogTupleDelete(ftrel, &fttuple->t_self);
  
         ReleaseSysCache(fttuple);
         table_close(ftrel, RowExclusiveLock);
     }
  
     /*
      * If a partitioned table, delete the pg_partitioned_table tuple.
      */
     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         RemovePartitionKeyByRelId(relid);
  
     /*
      * If the relation being dropped is the default partition itself,
      * invalidate its entry in pg_partitioned_table.
      */
     if (relid == defaultPartOid)
         update_default_partition_oid(parentOid, InvalidOid);
  
     /*
      * Schedule unlinking of the relation's physical files at commit.
      */
     if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
         RelationDropStorage(rel);
  
     /* ensure that stats are dropped if transaction commits */
     pgstat_drop_relation(rel);
  
     /*
      * Close relcache entry, but *keep* AccessExclusiveLock on the relation
      * until transaction commit.  This ensures no one else will try to do
      * something with the doomed relation.
      */
     relation_close(rel, NoLock);
  
     /*
      * Remove any associated relation synchronization states.
      */
     RemoveSubscriptionRel(InvalidOid, relid);
  
     /*
      * Forget any ON COMMIT action for the rel
      */
     remove_on_commit_action(relid);
  
     /*
      * Flush the relation from the relcache.  We want to do this before
      * starting to remove catalog entries, just to be certain that no relcache
      * entry rebuild will happen partway through.  (That should not really
      * matter, since we don't do CommandCounterIncrement here, but let's be
      * safe.)
      */
     RelationForgetRelation(relid);
  
     /*
      * remove inheritance information
      */
     RelationRemoveInheritance(relid);
  
     /*
      * delete statistics
      */
     RemoveStatistics(relid, 0);
  
     /*
      * delete attribute tuples
      */
     DeleteAttributeTuples(relid);
  
     /*
      * delete relation tuple
      */
     DeleteRelationTuple(relid);
  
     if (OidIsValid(parentOid))
     {
         /*
          * If this is not the default partition, the partition constraint of
          * the default partition has changed to include the portion of the key
          * space previously covered by the dropped partition.
          */
         if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
             CacheInvalidateRelcacheByRelid(defaultPartOid);
  
         /*
          * Invalidate the parent's relcache so that the partition is no longer
          * included in its partition descriptor.
          */
         CacheInvalidateRelcacheByRelid(parentOid);
         /* keep the lock */
     }
 }

References AccessExclusiveLock, CacheInvalidateRelcacheByRelid(), CatalogTupleDelete(), CheckTableForSerializableConflictIn(), CheckTableNotInUse(), DeleteAttributeTuples(), DeleteRelationTuple(), elog(), ERROR, FOREIGNTABLEREL, 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(), RELOID, 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 3001 of file heap.c.

 {
     List       *relations = NIL;
     ListCell   *cell;
  
     /* Open relations for processing, and grab exclusive access on each */
     foreach(cell, relids)
     {
         Oid         rid = lfirst_oid(cell);
         Relation    rel;
  
         rel = table_open(rid, AccessExclusiveLock);
         relations = lappend(relations, rel);
     }
  
     /* Don't allow truncate on tables that are referenced by foreign keys */
     heap_truncate_check_FKs(relations, true);
  
     /* OK to do it */
     foreach(cell, relations)
     {
         Relation    rel = lfirst(cell);
  
         /* Truncate the relation */
         heap_truncate_one_rel(rel);
  
         /* Close the relation, but keep exclusive lock on it until commit */
         table_close(rel, NoLock);
     }
 }

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 3086 of file heap.c.

 {
     List       *oids = NIL;
     List       *dependents;
     ListCell   *cell;
  
     /*
      * Build a list of OIDs of the interesting relations.
      *
      * If a relation has no triggers, then it can neither have FKs nor be
      * referenced by a FK from another table, so we can ignore it.  For
      * partitioned tables, FKs have no triggers, so we must include them
      * anyway.
      */
     foreach(cell, relations)
     {
         Relation    rel = lfirst(cell);
  
         if (rel->rd_rel->relhastriggers ||
             rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
             oids = lappend_oid(oids, RelationGetRelid(rel));
     }
  
     /*
      * Fast path: if no relation has triggers, none has FKs either.
      */
     if (oids == NIL)
         return;
  
     /*
      * Otherwise, must scan pg_constraint.  We make one pass with all the
      * relations considered; if this finds nothing, then all is well.
      */
     dependents = heap_truncate_find_FKs(oids);
     if (dependents == NIL)
         return;
  
     /*
      * Otherwise we repeat the scan once per relation to identify a particular
      * pair of relations to complain about.  This is pretty slow, but
      * performance shouldn't matter much in a failure path.  The reason for
      * doing things this way is to ensure that the message produced is not
      * dependent on chance row locations within pg_constraint.
      */
     foreach(cell, oids)
     {
         Oid         relid = lfirst_oid(cell);
         ListCell   *cell2;
  
         dependents = heap_truncate_find_FKs(list_make1_oid(relid));
  
         foreach(cell2, dependents)
         {
             Oid         relid2 = lfirst_oid(cell2);
  
             if (!list_member_oid(oids, relid2))
             {
                 char       *relname = get_rel_name(relid);
                 char       *relname2 = get_rel_name(relid2);
  
                 if (tempTables)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("unsupported ON COMMIT and foreign key combination"),
                              errdetail("Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting.",
                                        relname2, relname)));
                 else
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("cannot truncate a table referenced in a foreign key constraint"),
                              errdetail("Table \"%s\" references \"%s\".",
                                        relname2, relname),
                              errhint("Truncate table \"%s\" at the same time, "
                                      "or use TRUNCATE ... CASCADE.",
                                      relname2)));
             }
         }
     }
 }

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 3181 of file heap.c.

 {
     List       *result = NIL;
     List       *oids;
     List       *parent_cons;
     ListCell   *cell;
     ScanKeyData key;
     Relation    fkeyRel;
     SysScanDesc fkeyScan;
     HeapTuple   tuple;
     bool        restart;
  
     oids = list_copy(relationIds);
  
     /*
      * Must scan pg_constraint.  Right now, it is a seqscan because there is
      * no available index on confrelid.
      */
     fkeyRel = table_open(ConstraintRelationId, AccessShareLock);
  
 restart:
     restart = false;
     parent_cons = NIL;
  
     fkeyScan = systable_beginscan(fkeyRel, InvalidOid, false,
                                   NULL, 0, NULL);
  
     while (HeapTupleIsValid(tuple = systable_getnext(fkeyScan)))
     {
         Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tuple);
  
         /* Not a foreign key */
         if (con->contype != CONSTRAINT_FOREIGN)
             continue;
  
         /* Not referencing one of our list of tables */
         if (!list_member_oid(oids, con->confrelid))
             continue;
  
         /*
          * If this constraint has a parent constraint which we have not seen
          * yet, keep track of it for the second loop, below.  Tracking parent
          * constraints allows us to climb up to the top-level constraint and
          * look for all possible relations referencing the partitioned table.
          */
         if (OidIsValid(con->conparentid) &&
             !list_member_oid(parent_cons, con->conparentid))
             parent_cons = lappend_oid(parent_cons, con->conparentid);
  
         /*
          * Add referencer to result, unless present in input list.  (Don't
          * worry about dupes: we'll fix that below).
          */
         if (!list_member_oid(relationIds, con->conrelid))
             result = lappend_oid(result, con->conrelid);
     }
  
     systable_endscan(fkeyScan);
  
     /*
      * Process each parent constraint we found to add the list of referenced
      * relations by them to the oids list.  If we do add any new such
      * relations, redo the first loop above.  Also, if we see that the parent
      * constraint in turn has a parent, add that so that we process all
      * relations in a single additional pass.
      */
     foreach(cell, parent_cons)
     {
         Oid         parent = lfirst_oid(cell);
  
         ScanKeyInit(&key,
                     Anum_pg_constraint_oid,
                     BTEqualStrategyNumber, F_OIDEQ,
                     ObjectIdGetDatum(parent));
  
         fkeyScan = systable_beginscan(fkeyRel, ConstraintOidIndexId,
                                       true, NULL, 1, &key);
  
         tuple = systable_getnext(fkeyScan);
         if (HeapTupleIsValid(tuple))
         {
             Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tuple);
  
             /*
              * pg_constraint rows always appear for partitioned hierarchies
              * this way: on the each side of the constraint, one row appears
              * for each partition that points to the top-most table on the
              * other side.
              *
              * Because of this arrangement, we can correctly catch all
              * relevant relations by adding to 'parent_cons' all rows with
              * valid conparentid, and to the 'oids' list all rows with a zero
              * conparentid.  If any oids are added to 'oids', redo the first
              * loop above by setting 'restart'.
              */
             if (OidIsValid(con->conparentid))
                 parent_cons = list_append_unique_oid(parent_cons,
                                                      con->conparentid);
             else if (!list_member_oid(oids, con->confrelid))
             {
                 oids = lappend_oid(oids, con->confrelid);
                 restart = true;
             }
         }
  
         systable_endscan(fkeyScan);
     }
  
     list_free(parent_cons);
     if (restart)
         goto restart;
  
     table_close(fkeyRel, AccessShareLock);
     list_free(oids);
  
     /* Now sort and de-duplicate the result list */
     list_sort(result, list_oid_cmp);
     list_deduplicate_oid(result);
  
     return result;
 }

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 3042 of file heap.c.

 {
     Oid         toastrelid;
  
     /*
      * Truncate the relation.  Partitioned tables have no storage, so there is
      * nothing to do for them here.
      */
     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         return;
  
     /* Truncate the underlying relation */
     table_relation_nontransactional_truncate(rel);
  
     /* If the relation has indexes, truncate the indexes too */
     RelationTruncateIndexes(rel);
  
     /* If there is a toast table, truncate that too */
     toastrelid = rel->rd_rel->reltoastrelid;
     if (OidIsValid(toastrelid))
     {
         Relation    toastrel = table_open(toastrelid, AccessExclusiveLock);
  
         table_relation_nontransactional_truncate(toastrel);
         RelationTruncateIndexes(toastrel);
         /* keep the lock... */
         table_close(toastrel, NoLock);
     }
 }

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,
		Datum *	attoptions,
		CatalogIndexState	indstate
	)

Definition at line 697 of file heap.c.

 {
     TupleTableSlot **slot;
     TupleDesc   td;
     int         nslots;
     int         natts = 0;
     int         slotCount = 0;
     bool        close_index = false;
  
     td = RelationGetDescr(pg_attribute_rel);
  
     /* Initialize the number of slots to use */
     nslots = Min(tupdesc->natts,
                  (MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_attribute)));
     slot = palloc(sizeof(TupleTableSlot *) * nslots);
     for (int i = 0; i < nslots; i++)
         slot[i] = MakeSingleTupleTableSlot(td, &TTSOpsHeapTuple);
  
     while (natts < tupdesc->natts)
     {
         Form_pg_attribute attrs = TupleDescAttr(tupdesc, natts);
  
         ExecClearTuple(slot[slotCount]);
  
         memset(slot[slotCount]->tts_isnull, false,
                slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));
  
         if (new_rel_oid != InvalidOid)
             slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(new_rel_oid);
         else
             slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(attrs->attrelid);
  
         slot[slotCount]->tts_values[Anum_pg_attribute_attname - 1] = NameGetDatum(&attrs->attname);
         slot[slotCount]->tts_values[Anum_pg_attribute_atttypid - 1] = ObjectIdGetDatum(attrs->atttypid);
         slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = Int32GetDatum(attrs->attstattarget);
         slot[slotCount]->tts_values[Anum_pg_attribute_attlen - 1] = Int16GetDatum(attrs->attlen);
         slot[slotCount]->tts_values[Anum_pg_attribute_attnum - 1] = Int16GetDatum(attrs->attnum);
         slot[slotCount]->tts_values[Anum_pg_attribute_attndims - 1] = Int32GetDatum(attrs->attndims);
         slot[slotCount]->tts_values[Anum_pg_attribute_attcacheoff - 1] = Int32GetDatum(-1);
         slot[slotCount]->tts_values[Anum_pg_attribute_atttypmod - 1] = Int32GetDatum(attrs->atttypmod);
         slot[slotCount]->tts_values[Anum_pg_attribute_attbyval - 1] = BoolGetDatum(attrs->attbyval);
         slot[slotCount]->tts_values[Anum_pg_attribute_attalign - 1] = CharGetDatum(attrs->attalign);
         slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
         slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);
         slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
         slot[slotCount]->tts_values[Anum_pg_attribute_atthasdef - 1] = BoolGetDatum(attrs->atthasdef);
         slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
         slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
         slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
         slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
         slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
         slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int32GetDatum(attrs->attinhcount);
         slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
         if (attoptions && attoptions[natts] != (Datum) 0)
             slot[slotCount]->tts_values[Anum_pg_attribute_attoptions - 1] = attoptions[natts];
         else
             slot[slotCount]->tts_isnull[Anum_pg_attribute_attoptions - 1] = true;
  
         /* start out with empty permissions and empty options */
         slot[slotCount]->tts_isnull[Anum_pg_attribute_attacl - 1] = true;
         slot[slotCount]->tts_isnull[Anum_pg_attribute_attfdwoptions - 1] = true;
         slot[slotCount]->tts_isnull[Anum_pg_attribute_attmissingval - 1] = true;
  
         ExecStoreVirtualTuple(slot[slotCount]);
         slotCount++;
  
         /*
          * If slots are full or the end of processing has been reached, insert
          * a batch of tuples.
          */
         if (slotCount == nslots || natts == tupdesc->natts - 1)
         {
             /* fetch index info only when we know we need it */
             if (!indstate)
             {
                 indstate = CatalogOpenIndexes(pg_attribute_rel);
                 close_index = true;
             }
  
             /* insert the new tuples and update the indexes */
             CatalogTuplesMultiInsertWithInfo(pg_attribute_rel, slot, slotCount,
                                              indstate);
             slotCount = 0;
         }
  
         natts++;
     }
  
     if (close_index)
         CatalogCloseIndexes(indstate);
     for (int i = 0; i < nslots; i++)
         ExecDropSingleTupleTableSlot(slot[i]);
     pfree(slot);
 }

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

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 882 of file heap.c.

 {
     Form_pg_class rd_rel = new_rel_desc->rd_rel;
     Datum       values[Natts_pg_class];
     bool        nulls[Natts_pg_class];
     HeapTuple   tup;
  
     /* This is a tad tedious, but way cleaner than what we used to do... */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
  
     values[Anum_pg_class_oid - 1] = ObjectIdGetDatum(new_rel_oid);
     values[Anum_pg_class_relname - 1] = NameGetDatum(&rd_rel->relname);
     values[Anum_pg_class_relnamespace - 1] = ObjectIdGetDatum(rd_rel->relnamespace);
     values[Anum_pg_class_reltype - 1] = ObjectIdGetDatum(rd_rel->reltype);
     values[Anum_pg_class_reloftype - 1] = ObjectIdGetDatum(rd_rel->reloftype);
     values[Anum_pg_class_relowner - 1] = ObjectIdGetDatum(rd_rel->relowner);
     values[Anum_pg_class_relam - 1] = ObjectIdGetDatum(rd_rel->relam);
     values[Anum_pg_class_relfilenode - 1] = ObjectIdGetDatum(rd_rel->relfilenode);
     values[Anum_pg_class_reltablespace - 1] = ObjectIdGetDatum(rd_rel->reltablespace);
     values[Anum_pg_class_relpages - 1] = Int32GetDatum(rd_rel->relpages);
     values[Anum_pg_class_reltuples - 1] = Float4GetDatum(rd_rel->reltuples);
     values[Anum_pg_class_relallvisible - 1] = Int32GetDatum(rd_rel->relallvisible);
     values[Anum_pg_class_reltoastrelid - 1] = ObjectIdGetDatum(rd_rel->reltoastrelid);
     values[Anum_pg_class_relhasindex - 1] = BoolGetDatum(rd_rel->relhasindex);
     values[Anum_pg_class_relisshared - 1] = BoolGetDatum(rd_rel->relisshared);
     values[Anum_pg_class_relpersistence - 1] = CharGetDatum(rd_rel->relpersistence);
     values[Anum_pg_class_relkind - 1] = CharGetDatum(rd_rel->relkind);
     values[Anum_pg_class_relnatts - 1] = Int16GetDatum(rd_rel->relnatts);
     values[Anum_pg_class_relchecks - 1] = Int16GetDatum(rd_rel->relchecks);
     values[Anum_pg_class_relhasrules - 1] = BoolGetDatum(rd_rel->relhasrules);
     values[Anum_pg_class_relhastriggers - 1] = BoolGetDatum(rd_rel->relhastriggers);
     values[Anum_pg_class_relrowsecurity - 1] = BoolGetDatum(rd_rel->relrowsecurity);
     values[Anum_pg_class_relforcerowsecurity - 1] = BoolGetDatum(rd_rel->relforcerowsecurity);
     values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass);
     values[Anum_pg_class_relispopulated - 1] = BoolGetDatum(rd_rel->relispopulated);
     values[Anum_pg_class_relreplident - 1] = CharGetDatum(rd_rel->relreplident);
     values[Anum_pg_class_relispartition - 1] = BoolGetDatum(rd_rel->relispartition);
     values[Anum_pg_class_relrewrite - 1] = ObjectIdGetDatum(rd_rel->relrewrite);
     values[Anum_pg_class_relfrozenxid - 1] = TransactionIdGetDatum(rd_rel->relfrozenxid);
     values[Anum_pg_class_relminmxid - 1] = MultiXactIdGetDatum(rd_rel->relminmxid);
     if (relacl != (Datum) 0)
         values[Anum_pg_class_relacl - 1] = relacl;
     else
         nulls[Anum_pg_class_relacl - 1] = true;
     if (reloptions != (Datum) 0)
         values[Anum_pg_class_reloptions - 1] = reloptions;
     else
         nulls[Anum_pg_class_reloptions - 1] = true;
  
     /* relpartbound is set by updating this tuple, if necessary */
     nulls[Anum_pg_class_relpartbound - 1] = true;
  
     tup = heap_form_tuple(RelationGetDescr(pg_class_desc), values, nulls);
  
     /* finally insert the new tuple, update the indexes, and clean up */
     CatalogTupleInsert(pg_class_desc, tup);
  
     heap_freetuple(tup);
 }

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 2496 of file heap.c.

 {
     bool        found;
     Relation    conDesc;
     SysScanDesc conscan;
     ScanKeyData skey[3];
     HeapTuple   tup;
  
     /* Search for a pg_constraint entry with same name and relation */
     conDesc = table_open(ConstraintRelationId, RowExclusiveLock);
  
     found = false;
  
     ScanKeyInit(&skey[0],
                 Anum_pg_constraint_conrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(RelationGetRelid(rel)));
     ScanKeyInit(&skey[1],
                 Anum_pg_constraint_contypid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(InvalidOid));
     ScanKeyInit(&skey[2],
                 Anum_pg_constraint_conname,
                 BTEqualStrategyNumber, F_NAMEEQ,
                 CStringGetDatum(ccname));
  
     conscan = systable_beginscan(conDesc, ConstraintRelidTypidNameIndexId, true,
                                  NULL, 3, skey);
  
     /* There can be at most one matching row */
     if (HeapTupleIsValid(tup = systable_getnext(conscan)))
     {
         Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(tup);
  
         /* Found it.  Conflicts if not identical check constraint */
         if (con->contype == CONSTRAINT_CHECK)
         {
             Datum       val;
             bool        isnull;
  
             val = fastgetattr(tup,
                               Anum_pg_constraint_conbin,
                               conDesc->rd_att, &isnull);
             if (isnull)
                 elog(ERROR, "null conbin for rel %s",
                      RelationGetRelationName(rel));
             if (equal(expr, stringToNode(TextDatumGetCString(val))))
                 found = true;
         }
  
         /*
          * If the existing constraint is purely inherited (no local
          * definition) then interpret addition of a local constraint as a
          * legal merge.  This allows ALTER ADD CONSTRAINT on parent and child
          * tables to be given in either order with same end state.  However if
          * the relation is a partition, all inherited constraints are always
          * non-local, including those that were merged.
          */
         if (is_local && !con->conislocal && !rel->rd_rel->relispartition)
             allow_merge = true;
  
         if (!found || !allow_merge)
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("constraint \"%s\" for relation \"%s\" already exists",
                             ccname, RelationGetRelationName(rel))));
  
         /* If the child constraint is "no inherit" then cannot merge */
         if (con->connoinherit)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"",
                             ccname, RelationGetRelationName(rel))));
  
         /*
          * Must not change an existing inherited constraint to "no inherit"
          * status.  That's because inherited constraints should be able to
          * propagate to lower-level children.
          */
         if (con->coninhcount > 0 && is_no_inherit)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("constraint \"%s\" conflicts with inherited constraint on relation \"%s\"",
                             ccname, RelationGetRelationName(rel))));
  
         /*
          * If the child constraint is "not valid" then cannot merge with a
          * valid parent constraint.
          */
         if (is_initially_valid && !con->convalidated)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"",
                             ccname, RelationGetRelationName(rel))));
  
         /* OK to update the tuple */
         ereport(NOTICE,
                 (errmsg("merging constraint \"%s\" with inherited definition",
                         ccname)));
  
         tup = heap_copytuple(tup);
         con = (Form_pg_constraint) GETSTRUCT(tup);
  
         /*
          * In case of partitions, an inherited constraint must be inherited
          * only once since it cannot have multiple parents and it is never
          * considered local.
          */
         if (rel->rd_rel->relispartition)
         {
             con->coninhcount = 1;
             con->conislocal = false;
         }
         else
         {
             if (is_local)
                 con->conislocal = true;
             else
                 con->coninhcount++;
         }
  
         if (is_no_inherit)
         {
             Assert(is_local);
             con->connoinherit = true;
         }
  
         CatalogTupleUpdate(conDesc, &tup->t_self, tup);
     }
  
     systable_endscan(conscan);
     table_close(conDesc, RowExclusiveLock);
  
     return found;
 }

References Assert(), BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), elog(), equal(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, fastgetattr(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, InvalidOid, NOTICE, ObjectIdGetDatum(), 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 1935 of file heap.c.

 {
     Relation    attr_rel;
     Oid         relid = RelationGetRelid(rel);
     int         natts = RelationGetNumberOfAttributes(rel);
     int         attnum;
     Datum       repl_val[Natts_pg_attribute];
     bool        repl_null[Natts_pg_attribute];
     bool        repl_repl[Natts_pg_attribute];
     Form_pg_attribute attrtuple;
     HeapTuple   tuple,
                 newtuple;
  
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
  
     repl_val[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(false);
     repl_null[Anum_pg_attribute_attmissingval - 1] = true;
  
     repl_repl[Anum_pg_attribute_atthasmissing - 1] = true;
     repl_repl[Anum_pg_attribute_attmissingval - 1] = true;
  
  
     /* Get a lock on pg_attribute */
     attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
  
     /* process each non-system attribute, including any dropped columns */
     for (attnum = 1; attnum <= natts; attnum++)
     {
         tuple = SearchSysCache2(ATTNUM,
                                 ObjectIdGetDatum(relid),
                                 Int16GetDatum(attnum));
         if (!HeapTupleIsValid(tuple))   /* shouldn't happen */
             elog(ERROR, "cache lookup failed for attribute %d of relation %u",
                  attnum, relid);
  
         attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
  
         /* ignore any where atthasmissing is not true */
         if (attrtuple->atthasmissing)
         {
             newtuple = heap_modify_tuple(tuple, RelationGetDescr(attr_rel),
                                          repl_val, repl_null, repl_repl);
  
             CatalogTupleUpdate(attr_rel, &newtuple->t_self, newtuple);
  
             heap_freetuple(newtuple);
         }
  
         ReleaseSysCache(tuple);
     }
  
     /*
      * Our update of the pg_attribute rows will force a relcache rebuild, so
      * there's nothing else to do here.
      */
     table_close(attr_rel, RowExclusiveLock);
 }

References attnum, 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(), and finish_heap_swap().

◆ RelationRemoveInheritance()

static void RelationRemoveInheritance ( Oid relid )

static

Definition at line 1503 of file heap.c.

 {
     Relation    catalogRelation;
     SysScanDesc scan;
     ScanKeyData key;
     HeapTuple   tuple;
  
     catalogRelation = table_open(InheritsRelationId, RowExclusiveLock);
  
     ScanKeyInit(&key,
                 Anum_pg_inherits_inhrelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
  
     scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId, true,
                               NULL, 1, &key);
  
     while (HeapTupleIsValid(tuple = systable_getnext(scan)))
         CatalogTupleDelete(catalogRelation, &tuple->t_self);
  
     systable_endscan(scan);
     table_close(catalogRelation, RowExclusiveLock);
 }

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 2953 of file heap.c.

 {
     ListCell   *indlist;
  
     /* Ask the relcache to produce a list of the indexes of the rel */
     foreach(indlist, RelationGetIndexList(heapRelation))
     {
         Oid         indexId = lfirst_oid(indlist);
         Relation    currentIndex;
         IndexInfo  *indexInfo;
  
         /* Open the index relation; use exclusive lock, just to be sure */
         currentIndex = index_open(indexId, AccessExclusiveLock);
  
         /*
          * Fetch info needed for index_build.  Since we know there are no
          * tuples that actually need indexing, we can use a dummy IndexInfo.
          * This is slightly cheaper to build, but the real point is to avoid
          * possibly running user-defined code in index expressions or
          * predicates.  We might be getting invoked during ON COMMIT
          * processing, and we don't want to run any such code then.
          */
         indexInfo = BuildDummyIndexInfo(currentIndex);
  
         /*
          * Now truncate the actual file (and discard buffers).
          */
         RelationTruncate(currentIndex, 0);
  
         /* Initialize the index and rebuild */
         /* Note: we do not need to re-establish pkey setting */
         index_build(heapRelation, currentIndex, indexInfo, true, false);
  
         /* We're done with this index */
         index_close(currentIndex, NoLock);
     }
 }

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 1643 of file heap.c.

 {
     Relation    rel;
     Relation    attr_rel;
     HeapTuple   tuple;
     Form_pg_attribute attStruct;
     char        newattname[NAMEDATALEN];
  
     /*
      * Grab an exclusive lock on the target table, which we will NOT release
      * until end of transaction.  (In the simple case where we are directly
      * dropping this column, ATExecDropColumn already did this ... but when
      * cascading from a drop of some other object, we may not have any lock.)
      */
     rel = relation_open(relid, AccessExclusiveLock);
  
     attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
  
     tuple = SearchSysCacheCopy2(ATTNUM,
                                 ObjectIdGetDatum(relid),
                                 Int16GetDatum(attnum));
     if (!HeapTupleIsValid(tuple))   /* shouldn't happen */
         elog(ERROR, "cache lookup failed for attribute %d of relation %u",
              attnum, relid);
     attStruct = (Form_pg_attribute) GETSTRUCT(tuple);
  
     if (attnum < 0)
     {
         /* System attribute (probably OID) ... just delete the row */
  
         CatalogTupleDelete(attr_rel, &tuple->t_self);
     }
     else
     {
         /* Dropping user attributes is lots harder */
  
         /* Mark the attribute as dropped */
         attStruct->attisdropped = true;
  
         /*
          * Set the type OID to invalid.  A dropped attribute's type link
          * cannot be relied on (once the attribute is dropped, the type might
          * be too). Fortunately we do not need the type row --- the only
          * really essential information is the type's typlen and typalign,
          * which are preserved in the attribute's attlen and attalign.  We set
          * atttypid to zero here as a means of catching code that incorrectly
          * expects it to be valid.
          */
         attStruct->atttypid = InvalidOid;
  
         /* Remove any NOT NULL constraint the column may have */
         attStruct->attnotnull = false;
  
         /* We don't want to keep stats for it anymore */
         attStruct->attstattarget = 0;
  
         /* Unset this so no one tries to look up the generation expression */
         attStruct->attgenerated = '\0';
  
         /*
          * Change the column name to something that isn't likely to conflict
          */
         snprintf(newattname, sizeof(newattname),
                  "........pg.dropped.%d........", attnum);
         namestrcpy(&(attStruct->attname), newattname);
  
         /* clear the missing value if any */
         if (attStruct->atthasmissing)
         {
             Datum       valuesAtt[Natts_pg_attribute] = {0};
             bool        nullsAtt[Natts_pg_attribute] = {0};
             bool        replacesAtt[Natts_pg_attribute] = {0};
  
             /* update the tuple - set atthasmissing and attmissingval */
             valuesAtt[Anum_pg_attribute_atthasmissing - 1] =
                 BoolGetDatum(false);
             replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
             valuesAtt[Anum_pg_attribute_attmissingval - 1] = (Datum) 0;
             nullsAtt[Anum_pg_attribute_attmissingval - 1] = true;
             replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
  
             tuple = heap_modify_tuple(tuple, RelationGetDescr(attr_rel),
                                       valuesAtt, nullsAtt, replacesAtt);
         }
  
         CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
     }
  
     /*
      * Because updating the pg_attribute row will trigger a relcache flush for
      * the target relation, we need not do anything else to notify other
      * backends of the change.
      */
  
     table_close(attr_rel, RowExclusiveLock);
  
     if (attnum > 0)
         RemoveStatistics(relid, attnum);
  
     relation_close(rel, NoLock);
 }

References AccessExclusiveLock, attnum, ATTNUM, BoolGetDatum(), CatalogTupleDelete(), 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 3433 of file heap.c.

 {
     Relation    rel;
     HeapTuple   tuple;
  
     rel = table_open(PartitionedRelationId, RowExclusiveLock);
  
     tuple = SearchSysCache1(PARTRELID, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for partition key of relation %u",
              relid);
  
     CatalogTupleDelete(rel, &tuple->t_self);
  
     ReleaseSysCache(tuple);
     table_close(rel, RowExclusiveLock);
 }

References CatalogTupleDelete(), elog(), ERROR, HeapTupleIsValid, ObjectIdGetDatum(), PARTRELID, 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 2906 of file heap.c.

 {
     Relation    pgstatistic;
     SysScanDesc scan;
     ScanKeyData key[2];
     int         nkeys;
     HeapTuple   tuple;
  
     pgstatistic = table_open(StatisticRelationId, RowExclusiveLock);
  
     ScanKeyInit(&key[0],
                 Anum_pg_statistic_starelid,
                 BTEqualStrategyNumber, F_OIDEQ,
                 ObjectIdGetDatum(relid));
  
     if (attnum == 0)
         nkeys = 1;
     else
     {
         ScanKeyInit(&key[1],
                     Anum_pg_statistic_staattnum,
                     BTEqualStrategyNumber, F_INT2EQ,
                     Int16GetDatum(attnum));
         nkeys = 2;
     }
  
     scan = systable_beginscan(pgstatistic, StatisticRelidAttnumInhIndexId, true,
                               NULL, nkeys, key);
  
     /* we must loop even when attnum != 0, in case of inherited stats */
     while (HeapTupleIsValid(tuple = systable_getnext(scan)))
         CatalogTupleDelete(pgstatistic, &tuple->t_self);
  
     systable_endscan(scan);
  
     table_close(pgstatistic, RowExclusiveLock);
 }

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(), heap_drop_with_catalog(), index_drop(), and RemoveAttributeById().

◆ SetAttrMissing()

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

Definition at line 2003 of file heap.c.

 {
     Datum       valuesAtt[Natts_pg_attribute] = {0};
     bool        nullsAtt[Natts_pg_attribute] = {0};
     bool        replacesAtt[Natts_pg_attribute] = {0};
     Datum       missingval;
     Form_pg_attribute attStruct;
     Relation    attrrel,
                 tablerel;
     HeapTuple   atttup,
                 newtup;
  
     /* lock the table the attribute belongs to */
     tablerel = table_open(relid, AccessExclusiveLock);
  
     /* Don't do anything unless it's a plain table */
     if (tablerel->rd_rel->relkind != RELKIND_RELATION)
     {
         table_close(tablerel, AccessExclusiveLock);
         return;
     }
  
     /* Lock the attribute row and get the data */
     attrrel = table_open(AttributeRelationId, RowExclusiveLock);
     atttup = SearchSysCacheAttName(relid, attname);
     if (!HeapTupleIsValid(atttup))
         elog(ERROR, "cache lookup failed for attribute %s of relation %u",
              attname, relid);
     attStruct = (Form_pg_attribute) GETSTRUCT(atttup);
  
     /* get an array value from the value string */
     missingval = OidFunctionCall3(F_ARRAY_IN,
                                   CStringGetDatum(value),
                                   ObjectIdGetDatum(attStruct->atttypid),
                                   Int32GetDatum(attStruct->atttypmod));
  
     /* update the tuple - set atthasmissing and attmissingval */
     valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);
     replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
     valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
     replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
  
     newtup = heap_modify_tuple(atttup, RelationGetDescr(attrrel),
                                valuesAtt, nullsAtt, replacesAtt);
     CatalogTupleUpdate(attrrel, &newtup->t_self, newtup);
  
     /* clean up */
     ReleaseSysCache(atttup);
     table_close(attrrel, RowExclusiveLock);
     table_close(tablerel, AccessExclusiveLock);
 }

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 2646 of file heap.c.

 {
     Relation    relrel;
     HeapTuple   reltup;
     Form_pg_class relStruct;
  
     relrel = table_open(RelationRelationId, RowExclusiveLock);
     reltup = SearchSysCacheCopy1(RELOID,
                                  ObjectIdGetDatum(RelationGetRelid(rel)));
     if (!HeapTupleIsValid(reltup))
         elog(ERROR, "cache lookup failed for relation %u",
              RelationGetRelid(rel));
     relStruct = (Form_pg_class) GETSTRUCT(reltup);
  
     if (relStruct->relchecks != numchecks)
     {
         relStruct->relchecks = numchecks;
  
         CatalogTupleUpdate(relrel, &reltup->t_self, reltup);
     }
     else
     {
         /* Skip the disk update, but force relcache inval anyway */
         CacheInvalidateRelcache(rel);
     }
  
     heap_freetuple(reltup);
     table_close(relrel, RowExclusiveLock);
 }

References CacheInvalidateRelcache(), CatalogTupleUpdate(), elog(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RelationGetRelid, RELOID, 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 2174 of file heap.c.

 {
     int         numchecks = 0;
     ListCell   *lc;
  
     if (cooked_constraints == NIL)
         return;                 /* nothing to do */
  
     /*
      * Deparsing of constraint expressions will fail unless the just-created
      * pg_attribute tuples for this relation are made visible.  So, bump the
      * command counter.  CAUTION: this will cause a relcache entry rebuild.
      */
     CommandCounterIncrement();
  
     foreach(lc, cooked_constraints)
     {
         CookedConstraint *con = (CookedConstraint *) lfirst(lc);
  
         switch (con->contype)
         {
             case CONSTR_DEFAULT:
                 con->conoid = StoreAttrDefault(rel, con->attnum, con->expr,
                                                is_internal, false);
                 break;
             case CONSTR_CHECK:
                 con->conoid =
                     StoreRelCheck(rel, con->name, con->expr,
                                   !con->skip_validation, con->is_local,
                                   con->inhcount, con->is_no_inherit,
                                   is_internal);
                 numchecks++;
                 break;
             default:
                 elog(ERROR, "unrecognized constraint type: %d",
                      (int) con->contype);
         }
     }
  
     if (numchecks > 0)
         SetRelationNumChecks(rel, numchecks);
 }

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 3464 of file heap.c.

 {
     Relation    classRel;
     HeapTuple   tuple,
                 newtuple;
     Datum       new_val[Natts_pg_class];
     bool        new_null[Natts_pg_class],
                 new_repl[Natts_pg_class];
     Oid         defaultPartOid;
  
     /* Update pg_class tuple */
     classRel = table_open(RelationRelationId, RowExclusiveLock);
     tuple = SearchSysCacheCopy1(RELOID,
                                 ObjectIdGetDatum(RelationGetRelid(rel)));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for relation %u",
              RelationGetRelid(rel));
  
 #ifdef USE_ASSERT_CHECKING
     {
         Form_pg_class classForm;
         bool        isnull;
  
         classForm = (Form_pg_class) GETSTRUCT(tuple);
         Assert(!classForm->relispartition);
         (void) SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relpartbound,
                                &isnull);
         Assert(isnull);
     }
 #endif
  
     /* Fill in relpartbound value */
     memset(new_val, 0, sizeof(new_val));
     memset(new_null, false, sizeof(new_null));
     memset(new_repl, false, sizeof(new_repl));
     new_val[Anum_pg_class_relpartbound - 1] = CStringGetTextDatum(nodeToString(bound));
     new_null[Anum_pg_class_relpartbound - 1] = false;
     new_repl[Anum_pg_class_relpartbound - 1] = true;
     newtuple = heap_modify_tuple(tuple, RelationGetDescr(classRel),
                                  new_val, new_null, new_repl);
     /* Also set the flag */
     ((Form_pg_class) GETSTRUCT(newtuple))->relispartition = true;
     CatalogTupleUpdate(classRel, &newtuple->t_self, newtuple);
     heap_freetuple(newtuple);
     table_close(classRel, RowExclusiveLock);
  
     /*
      * If we're storing bounds for the default partition, update
      * pg_partitioned_table too.
      */
     if (bound->is_default)
         update_default_partition_oid(RelationGetRelid(parent),
                                      RelationGetRelid(rel));
  
     /* Make these updates visible */
     CommandCounterIncrement();
  
     /*
      * The partition constraint for the default partition depends on the
      * partition bounds of every other partition, so we must invalidate the
      * relcache entry for that partition every time a partition is added or
      * removed.
      */
     defaultPartOid =
         get_default_oid_from_partdesc(RelationGetPartitionDesc(parent, true));
     if (OidIsValid(defaultPartOid))
         CacheInvalidateRelcacheByRelid(defaultPartOid);
  
     CacheInvalidateRelcache(parent);
 }

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, RelationGetDescr, RelationGetPartitionDesc(), RelationGetRelid, RELOID, 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 3308 of file heap.c.

 {
     int         i;
     int2vector *partattrs_vec;
     oidvector  *partopclass_vec;
     oidvector  *partcollation_vec;
     Datum       partexprDatum;
     Relation    pg_partitioned_table;
     HeapTuple   tuple;
     Datum       values[Natts_pg_partitioned_table];
     bool        nulls[Natts_pg_partitioned_table] = {0};
     ObjectAddress myself;
     ObjectAddress referenced;
     ObjectAddresses *addrs;
  
     Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
  
     /* Copy the partition attribute numbers, opclass OIDs into arrays */
     partattrs_vec = buildint2vector(partattrs, partnatts);
     partopclass_vec = buildoidvector(partopclass, partnatts);
     partcollation_vec = buildoidvector(partcollation, partnatts);
  
     /* Convert the expressions (if any) to a text datum */
     if (partexprs)
     {
         char       *exprString;
  
         exprString = nodeToString(partexprs);
         partexprDatum = CStringGetTextDatum(exprString);
         pfree(exprString);
     }
     else
         partexprDatum = (Datum) 0;
  
     pg_partitioned_table = table_open(PartitionedRelationId, RowExclusiveLock);
  
     /* Only this can ever be NULL */
     if (!partexprDatum)
         nulls[Anum_pg_partitioned_table_partexprs - 1] = true;
  
     values[Anum_pg_partitioned_table_partrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
     values[Anum_pg_partitioned_table_partstrat - 1] = CharGetDatum(strategy);
     values[Anum_pg_partitioned_table_partnatts - 1] = Int16GetDatum(partnatts);
     values[Anum_pg_partitioned_table_partdefid - 1] = ObjectIdGetDatum(InvalidOid);
     values[Anum_pg_partitioned_table_partattrs - 1] = PointerGetDatum(partattrs_vec);
     values[Anum_pg_partitioned_table_partclass - 1] = PointerGetDatum(partopclass_vec);
     values[Anum_pg_partitioned_table_partcollation - 1] = PointerGetDatum(partcollation_vec);
     values[Anum_pg_partitioned_table_partexprs - 1] = partexprDatum;
  
     tuple = heap_form_tuple(RelationGetDescr(pg_partitioned_table), values, nulls);
  
     CatalogTupleInsert(pg_partitioned_table, tuple);
     table_close(pg_partitioned_table, RowExclusiveLock);
  
     /* Mark this relation as dependent on a few things as follows */
     addrs = new_object_addresses();
     ObjectAddressSet(myself, RelationRelationId, RelationGetRelid(rel));
  
     /* Operator class and collation per key column */
     for (i = 0; i < partnatts; i++)
     {
         ObjectAddressSet(referenced, OperatorClassRelationId, partopclass[i]);
         add_exact_object_address(&referenced, addrs);
  
         /* The default collation is pinned, so don't bother recording it */
         if (OidIsValid(partcollation[i]) &&
             partcollation[i] != DEFAULT_COLLATION_OID)
         {
             ObjectAddressSet(referenced, CollationRelationId, partcollation[i]);
             add_exact_object_address(&referenced, addrs);
         }
     }
  
     record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
     free_object_addresses(addrs);
  
     /*
      * The partitioning columns are made internally dependent on the table,
      * because we cannot drop any of them without dropping the whole table.
      * (ATExecDropColumn independently enforces that, but it's not bulletproof
      * so we need the dependencies too.)
      */
     for (i = 0; i < partnatts; i++)
     {
         if (partattrs[i] == 0)
             continue;           /* ignore expressions here */
  
         ObjectAddressSubSet(referenced, RelationRelationId,
                             RelationGetRelid(rel), partattrs[i]);
         recordDependencyOn(&referenced, &myself, DEPENDENCY_INTERNAL);
     }
  
     /*
      * Also consider anything mentioned in partition expressions.  External
      * references (e.g. functions) get NORMAL dependencies.  Table columns
      * mentioned in the expressions are handled the same as plain partitioning
      * columns, i.e. they become internally dependent on the whole table.
      */
     if (partexprs)
         recordDependencyOnSingleRelExpr(&myself,
                                         (Node *) partexprs,
                                         RelationGetRelid(rel),
                                         DEPENDENCY_NORMAL,
                                         DEPENDENCY_INTERNAL,
                                         true /* reverse the self-deps */ );
  
     /*
      * We must invalidate the relcache so that the next
      * CommandCounterIncrement() will cause the same to be rebuilt using the
      * information in just created catalog entry.
      */
     CacheInvalidateRelcache(rel);
 }

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,
		int	inhcount,
		bool	is_no_inherit,
		bool	is_internal
	)

static

Definition at line 2064 of file heap.c.

 {
     char       *ccbin;
     List       *varList;
     int         keycount;
     int16      *attNos;
     Oid         constrOid;
  
     /*
      * Flatten expression to string form for storage.
      */
     ccbin = nodeToString(expr);
  
     /*
      * Find columns of rel that are used in expr
      *
      * NB: pull_var_clause is okay here only because we don't allow subselects
      * in check constraints; it would fail to examine the contents of
      * subselects.
      */
     varList = pull_var_clause(expr, 0);
     keycount = list_length(varList);
  
     if (keycount > 0)
     {
         ListCell   *vl;
         int         i = 0;
  
         attNos = (int16 *) palloc(keycount * sizeof(int16));
         foreach(vl, varList)
         {
             Var        *var = (Var *) lfirst(vl);
             int         j;
  
             for (j = 0; j < i; j++)
                 if (attNos[j] == var->varattno)
                     break;
             if (j == i)
                 attNos[i++] = var->varattno;
         }
         keycount = i;
     }
     else
         attNos = NULL;
  
     /*
      * Partitioned tables do not contain any rows themselves, so a NO INHERIT
      * constraint makes no sense.
      */
     if (is_no_inherit &&
         rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                  errmsg("cannot add NO INHERIT constraint to partitioned table \"%s\"",
                         RelationGetRelationName(rel))));
  
     /*
      * Create the Check Constraint
      */
     constrOid =
         CreateConstraintEntry(ccname,   /* Constraint Name */
                               RelationGetNamespace(rel),    /* namespace */
                               CONSTRAINT_CHECK, /* Constraint Type */
                               false,    /* Is Deferrable */
                               false,    /* Is Deferred */
                               is_validated,
                               InvalidOid,   /* no parent constraint */
                               RelationGetRelid(rel),    /* relation */
                               attNos,   /* attrs in the constraint */
                               keycount, /* # key attrs in the constraint */
                               keycount, /* # total attrs in the constraint */
                               InvalidOid,   /* not a domain constraint */
                               InvalidOid,   /* no associated index */
                               InvalidOid,   /* Foreign key fields */
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               0,
                               ' ',
                               ' ',
                               NULL,
                               0,
                               ' ',
                               NULL, /* not an exclusion constraint */
                               expr, /* Tree form of check constraint */
                               ccbin,    /* Binary form of check constraint */
                               is_local, /* conislocal */
                               inhcount, /* coninhcount */
                               is_no_inherit,    /* connoinherit */
                               is_internal); /* internally constructed? */
  
     pfree(ccbin);
  
     return constrOid;
 }

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 251 of file heap.c.

 {
     int         j;
  
     for (j = 0; j < (int) lengthof(SysAtt); j++)
     {
         const FormData_pg_attribute *att = SysAtt[j];
  
         if (strcmp(NameStr(att->attname), attname) == 0)
             return att;
     }
  
     return NULL;
 }

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 239 of file heap.c.

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

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),
    .attnum = SelfItemPointerAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = false,
    .attalign = TYPALIGN_SHORT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 141 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),
    .attnum = MinTransactionIdAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = true,
    .attalign = TYPALIGN_INT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 155 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),
    .attnum = MinCommandIdAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = true,
    .attalign = TYPALIGN_INT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 169 of file heap.c.

◆ a4

const FormData_pg_attribute a4

static

Initial value:

= {
    .attname = {"xmax"},
    .atttypid = XIDOID,
    .attlen = sizeof(TransactionId),
    .attnum = MaxTransactionIdAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = true,
    .attalign = TYPALIGN_INT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 183 of file heap.c.

◆ a5

const FormData_pg_attribute a5

static

Initial value:

= {
    .attname = {"cmax"},
    .atttypid = CIDOID,
    .attlen = sizeof(CommandId),
    .attnum = MaxCommandIdAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = true,
    .attalign = TYPALIGN_INT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 197 of file heap.c.

◆ a6

const FormData_pg_attribute a6

static

Initial value:

= {
    .attname = {"tableoid"},
    .atttypid = OIDOID,
    .attlen = sizeof(Oid),
    .attnum = TableOidAttributeNumber,
    .attcacheoff = -1,
    .atttypmod = -1,
    .attbyval = true,
    .attalign = TYPALIGN_INT,
    .attstorage = TYPSTORAGE_PLAIN,
    .attnotnull = true,
    .attislocal = true,
}

Definition at line 217 of file heap.c.

◆ binary_upgrade_next_heap_pg_class_oid

Oid binary_upgrade_next_heap_pg_class_oid = InvalidOid

Definition at line 79 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

Definition at line 81 of file heap.c.

Referenced by binary_upgrade_set_next_heap_relfilenode(), heap_create_with_catalog(), and RelationSetNewRelfilenumber().

◆ binary_upgrade_next_toast_pg_class_oid

Oid binary_upgrade_next_toast_pg_class_oid = InvalidOid

Definition at line 80 of file heap.c.

Referenced by binary_upgrade_set_next_toast_pg_class_oid(), create_toast_table(), and heap_create_with_catalog().

◆ binary_upgrade_next_toast_pg_class_relfilenumber

RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber = InvalidRelFileNumber

Definition at line 82 of file heap.c.

Referenced by binary_upgrade_set_next_toast_relfilenode(), and heap_create_with_catalog().

◆ SysAtt

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

static

Definition at line 231 of file heap.c.

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

Functions

Variables

Function Documentation

◆ AddNewAttributeTuples()

◆ AddNewRelationTuple()

◆ AddNewRelationType()

◆ AddRelationNewConstraints()

◆ check_nested_generated()

◆ check_nested_generated_walker()

◆ CheckAttributeNamesTypes()

◆ CheckAttributeType()

◆ cookConstraint()

◆ cookDefault()

◆ CopyStatistics()

◆ DeleteAttributeTuples()

◆ DeleteRelationTuple()

◆ DeleteSystemAttributeTuples()

◆ heap_create()

◆ heap_create_with_catalog()

◆ heap_drop_with_catalog()

◆ heap_truncate()

◆ heap_truncate_check_FKs()

◆ heap_truncate_find_FKs()

◆ heap_truncate_one_rel()

◆ InsertPgAttributeTuples()

◆ InsertPgClassTuple()

◆ MergeWithExistingConstraint()

◆ RelationClearMissing()

◆ RelationRemoveInheritance()

◆ RelationTruncateIndexes()

◆ RemoveAttributeById()

◆ RemovePartitionKeyByRelId()

◆ RemoveStatistics()

◆ SetAttrMissing()

◆ SetRelationNumChecks()

◆ StoreConstraints()

◆ StorePartitionBound()

◆ StorePartitionKey()

◆ StoreRelCheck()

◆ SystemAttributeByName()

◆ SystemAttributeDefinition()

Variable Documentation

◆ a1

◆ a2

◆ a3

◆ a4

◆ a5

◆ a6

◆ 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

◆ SysAtt