#include "catalog/indexing.h"
#include "catalog/objectaddress.h"
#include "parser/parse_node.h"

Include dependency graph for heap.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	RawColumnDefault

struct	CookedConstraint

Macros
#define	CHKATYPE_ANYARRAY 0x01 /* allow ANYARRAY */

#define	CHKATYPE_ANYRECORD 0x02 /* allow RECORD and RECORD[] */

#define	CHKATYPE_IS_PARTKEY 0x04 /* attname is part key # not column */

Typedefs
typedef struct RawColumnDefault	RawColumnDefault

typedef struct CookedConstraint	CookedConstraint

Functions
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)

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	heap_drop_with_catalog (Oid relid)

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	InsertPgAttributeTuples (Relation pg_attribute_rel, TupleDesc tupdesc, Oid new_rel_oid, const Datum *attoptions, CatalogIndexState indstate)

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

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

List *	AddRelationNotNullConstraints (Relation rel, List constraints, List additional_notnulls)

void	RelationClearMissing (Relation rel)

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

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

void	DeleteRelationTuple (Oid relid)

void	DeleteAttributeTuples (Oid relid)

void	DeleteSystemAttributeTuples (Oid relid)

void	RemoveAttributeById (Oid relid, AttrNumber attnum)

void	CopyStatistics (Oid fromrelid, Oid torelid)

void	RemoveStatistics (Oid relid, AttrNumber attnum)

const FormData_pg_attribute *	SystemAttributeDefinition (AttrNumber attno)

const FormData_pg_attribute *	SystemAttributeByName (const char *attname)

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

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

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)

Macro Definition Documentation

◆ CHKATYPE_ANYARRAY

#define CHKATYPE_ANYARRAY 0x01 /* allow ANYARRAY */

Definition at line 23 of file heap.h.

◆ CHKATYPE_ANYRECORD

#define CHKATYPE_ANYRECORD 0x02 /* allow RECORD and RECORD[] */

Definition at line 24 of file heap.h.

◆ CHKATYPE_IS_PARTKEY

#define CHKATYPE_IS_PARTKEY 0x04 /* attname is part key # not column */

Definition at line 25 of file heap.h.

Typedef Documentation

◆ CookedConstraint

typedef struct CookedConstraint CookedConstraint

◆ RawColumnDefault

typedef struct RawColumnDefault RawColumnDefault

Function Documentation

◆ AddRelationNewConstraints()

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

Definition at line 2290 of file heap.c.

 {
     List       *cookedConstraints = NIL;
     TupleDesc   tupleDesc;
     TupleConstr *oldconstr;
     int         numoldchecks;
     ParseState *pstate;
     ParseNamespaceItem *nsitem;
     int         numchecks;
     List       *checknames;
     List       *nnnames;
     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;
     nnnames = NIL;
     foreach(cell, newConstraints)
     {
         Constraint *cdef = (Constraint *) lfirst(cell);
         Oid         constrOid;
  
         if (cdef->contype == CONSTR_CHECK)
         {
             char       *ccname;
  
             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);
         }
         else if (cdef->contype == CONSTR_NOTNULL)
         {
             CookedConstraint *nncooked;
             AttrNumber  colnum;
             char       *nnname;
  
             /* Determine which column to modify */
             colnum = get_attnum(RelationGetRelid(rel), strVal(linitial(cdef->keys)));
             if (colnum == InvalidAttrNumber)    /* shouldn't happen */
                 elog(ERROR, "cache lookup failed for attribute \"%s\" of relation %u",
                      strVal(linitial(cdef->keys)), RelationGetRelid(rel));
  
             /*
              * If the column already has a not-null constraint, we need only
              * update its catalog status and we're done.
              */
             if (AdjustNotNullInheritance1(RelationGetRelid(rel), colnum,
                                           cdef->inhcount, cdef->is_no_inherit))
                 continue;
  
             /*
              * If a constraint name is specified, check that it isn't already
              * used.  Otherwise, choose a non-conflicting one ourselves.
              */
             if (cdef->conname)
             {
                 if (ConstraintNameIsUsed(CONSTRAINT_RELATION,
                                          RelationGetRelid(rel),
                                          cdef->conname))
                     ereport(ERROR,
                             errcode(ERRCODE_DUPLICATE_OBJECT),
                             errmsg("constraint \"%s\" for relation \"%s\" already exists",
                                    cdef->conname, RelationGetRelationName(rel)));
                 nnname = cdef->conname;
             }
             else
                 nnname = ChooseConstraintName(RelationGetRelationName(rel),
                                               strVal(linitial(cdef->keys)),
                                               "not_null",
                                               RelationGetNamespace(rel),
                                               nnnames);
             nnnames = lappend(nnnames, nnname);
  
             constrOid =
                 StoreRelNotNull(rel, nnname, colnum,
                                 cdef->initially_valid,
                                 cdef->inhcount == 0,
                                 cdef->inhcount,
                                 cdef->is_no_inherit);
  
             nncooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
             nncooked->contype = CONSTR_NOTNULL;
             nncooked->conoid = constrOid;
             nncooked->name = nnname;
             nncooked->attnum = colnum;
             nncooked->expr = NULL;
             nncooked->skip_validation = cdef->skip_validation;
             nncooked->is_local = is_local;
             nncooked->inhcount = cdef->inhcount;
             nncooked->is_no_inherit = cdef->is_no_inherit;
  
             cookedConstraints = lappend(cookedConstraints, nncooked);
         }
     }
  
     /*
      * 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 ATAddCheckNNConstraint(), ATExecAddColumn(), ATExecColumnDefault(), ATExecSetNotNull(), and DefineRelation().

◆ AddRelationNotNullConstraints()

List* AddRelationNotNullConstraints	(	Relation	rel,
		List *	constraints,
		List *	additional_notnulls
	)

Definition at line 2785 of file heap.c.

 {
     List       *givennames;
     List       *nnnames;
     List       *nncols = NIL;
     ListCell   *lc;
  
     /*
      * We track two lists of names: nnnames keeps all the constraint names,
      * givennames tracks user-generated names.  The distinction is important,
      * because we must raise error for user-generated name conflicts, but for
      * system-generated name conflicts we just generate another.
      */
     nnnames = NIL;
     givennames = NIL;
  
     /*
      * First, create all not-null constraints that are directly specified by
      * the user.  Note that inheritance might have given us another source for
      * each, so we must scan the old_notnulls list and increment inhcount for
      * each element with identical attnum.  We delete from there any element
      * that we process.
      */
     foreach(lc, constraints)
     {
         Constraint *constr = lfirst_node(Constraint, lc);
         AttrNumber  attnum;
         char       *conname;
         bool        is_local = true;
         int         inhcount = 0;
         ListCell   *lc2;
  
         Assert(constr->contype == CONSTR_NOTNULL);
  
         attnum = get_attnum(RelationGetRelid(rel),
                             strVal(linitial(constr->keys)));
  
         /*
          * Search in the list of inherited constraints for any entries on the
          * same column.
          */
         foreach(lc2, old_notnulls)
         {
             CookedConstraint *old = (CookedConstraint *) lfirst(lc2);
  
             if (old->attnum == attnum)
             {
                 /*
                  * If we get a constraint from the parent, having a local NO
                  * INHERIT one doesn't work.
                  */
                 if (constr->is_no_inherit)
                     ereport(ERROR,
                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                              errmsg("cannot define not-null constraint on column \"%s\" with NO INHERIT",
                                     strVal(linitial(constr->keys))),
                              errdetail("The column has an inherited not-null constraint.")));
  
                 inhcount++;
                 old_notnulls = foreach_delete_current(old_notnulls, lc2);
             }
         }
  
         /*
          * Determine a constraint name, which may have been specified by the
          * user, or raise an error if a conflict exists with another
          * user-specified name.
          */
         if (constr->conname)
         {
             foreach(lc2, givennames)
             {
                 if (strcmp(lfirst(lc2), constr->conname) == 0)
                     ereport(ERROR,
                             errcode(ERRCODE_DUPLICATE_OBJECT),
                             errmsg("constraint \"%s\" for relation \"%s\" already exists",
                                    constr->conname,
                                    RelationGetRelationName(rel)));
             }
  
             conname = constr->conname;
             givennames = lappend(givennames, conname);
         }
         else
             conname = ChooseConstraintName(RelationGetRelationName(rel),
                                            get_attname(RelationGetRelid(rel),
                                                        attnum, false),
                                            "not_null",
                                            RelationGetNamespace(rel),
                                            nnnames);
         nnnames = lappend(nnnames, conname);
  
         StoreRelNotNull(rel, conname,
                         attnum, true, is_local,
                         inhcount, constr->is_no_inherit);
  
         nncols = lappend_int(nncols, attnum);
     }
  
     /*
      * If any column remains in the old_notnulls list, we must create a not-
      * null constraint marked not-local.  Because multiple parents could
      * specify a not-null constraint for the same column, we must count how
      * many there are and add to the original inhcount accordingly, deleting
      * elements we've already processed.  We sort the list to make it easy.
      *
      * We don't use foreach() here because we have two nested loops over the
      * constraint list, with possible element deletions in the inner one. If
      * we used foreach_delete_current() it could only fix up the state of one
      * of the loops, so it seems cleaner to use looping over list indexes for
      * both loops.  Note that any deletion will happen beyond where the outer
      * loop is, so its index never needs adjustment.
      */
     list_sort(old_notnulls, list_cookedconstr_attnum_cmp);
     for (int outerpos = 0; outerpos < list_length(old_notnulls); outerpos++)
     {
         CookedConstraint *cooked;
         char       *conname = NULL;
         int         add_inhcount = 0;
         ListCell   *lc2;
  
         cooked = (CookedConstraint *) list_nth(old_notnulls, outerpos);
         Assert(cooked->contype == CONSTR_NOTNULL);
  
         /*
          * Preserve the first non-conflicting constraint name we come across,
          * if any
          */
         if (conname == NULL && cooked->name)
             conname = cooked->name;
  
         for (int restpos = outerpos + 1; restpos < list_length(old_notnulls);)
         {
             CookedConstraint *other;
  
             other = (CookedConstraint *) list_nth(old_notnulls, restpos);
             if (other->attnum == cooked->attnum)
             {
                 if (conname == NULL && other->name)
                     conname = other->name;
  
                 add_inhcount++;
                 old_notnulls = list_delete_nth_cell(old_notnulls, restpos);
             }
             else
                 restpos++;
         }
  
         /* If we got a name, make sure it isn't one we've already used */
         if (conname != NULL)
         {
             foreach(lc2, nnnames)
             {
                 if (strcmp(lfirst(lc2), conname) == 0)
                 {
                     conname = NULL;
                     break;
                 }
             }
         }
  
         /* and choose a name, if needed */
         if (conname == NULL)
             conname = ChooseConstraintName(RelationGetRelationName(rel),
                                            get_attname(RelationGetRelid(rel),
                                                        cooked->attnum, false),
                                            "not_null",
                                            RelationGetNamespace(rel),
                                            nnnames);
         nnnames = lappend(nnnames, conname);
  
         StoreRelNotNull(rel, conname, cooked->attnum, true,
                         cooked->is_local, cooked->inhcount + add_inhcount,
                         cooked->is_no_inherit);
  
         nncols = lappend_int(nncols, cooked->attnum);
     }
  
     return nncols;
 }

References Assert(), CookedConstraint::attnum, attnum, ChooseConstraintName(), Constraint::conname, CONSTR_NOTNULL, CookedConstraint::contype, Constraint::contype, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errmsg(), ERROR, foreach_delete_current, get_attname(), get_attnum(), CookedConstraint::inhcount, CookedConstraint::is_local, CookedConstraint::is_no_inherit, Constraint::is_no_inherit, Constraint::keys, lappend(), lappend_int(), lfirst, lfirst_node, linitial, list_cookedconstr_attnum_cmp(), list_delete_nth_cell(), list_length(), list_nth(), list_sort(), CookedConstraint::name, NIL, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, StoreRelNotNull(), and strVal.

Referenced by DefineRelation().

◆ 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().

◆ cookDefault()

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

Definition at line 3072 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 3185 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 1742 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 3333 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 3418 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 3513 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 3374 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,
		const 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_attlen - 1] = Int16GetDatum(attrs->attlen);
         slot[slotCount]->tts_values[Anum_pg_attribute_attnum - 1] = Int16GetDatum(attrs->attnum);
         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_attndims - 1] = Int16GetDatum(attrs->attndims);
         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] = Int16GetDatum(attrs->attinhcount);
         slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = Int16GetDatum(attrs->attstattarget);
         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().

◆ RelationClearMissing()

void RelationClearMissing ( Relation rel )

Definition at line 1922 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().

◆ 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);
  
     /* 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);
  
     RemoveStatistics(relid, attnum);
  
     relation_close(rel, NoLock);
 }

References AccessExclusiveLock, attnum, ATTNUM, BoolGetDatum(), 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 3765 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 3238 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 1990 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().

◆ StorePartitionBound()

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

Definition at line 3796 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 3640 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.