#include "parser/parse_node.h"

Include dependency graph for parse_utilcmd.h:

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

Functions
List *	transformCreateStmt (CreateStmt stmt, const char queryString)

AlterTableStmt *	transformAlterTableStmt (Oid relid, AlterTableStmt stmt, const char queryString, List beforeStmts, List afterStmts)

IndexStmt *	transformIndexStmt (Oid relid, IndexStmt stmt, const char queryString)

CreateStatsStmt *	transformStatsStmt (Oid relid, CreateStatsStmt stmt, const char queryString)

void	transformRuleStmt (RuleStmt stmt, const char queryString, List actions, Node whereClause)

List *	transformCreateSchemaStmtElements (List schemaElts, const char schemaName)

PartitionBoundSpec *	transformPartitionBound (ParseState pstate, Relation parent, PartitionBoundSpec spec)

List *	expandTableLikeClause (RangeVar heapRel, TableLikeClause table_like_clause)

IndexStmt *	generateClonedIndexStmt (RangeVar heapRel, Relation source_idx, const struct AttrMap attmap, Oid *constraintOid)

Function Documentation

◆ expandTableLikeClause()

List* expandTableLikeClause	(	RangeVar *	heapRel,
		TableLikeClause *	table_like_clause
	)

Definition at line 1301 of file parse_utilcmd.c.

 {
     List       *result = NIL;
     List       *atsubcmds = NIL;
     AttrNumber  parent_attno;
     Relation    relation;
     Relation    childrel;
     TupleDesc   tupleDesc;
     TupleConstr *constr;
     AttrMap    *attmap;
     char       *comment;
     bool        at_pushed = false;
     ListCell   *lc;
  
     /*
      * Open the relation referenced by the LIKE clause.  We should still have
      * the table lock obtained by transformTableLikeClause (and this'll throw
      * an assertion failure if not).  Hence, no need to recheck privileges
      * etc.  We must open the rel by OID not name, to be sure we get the same
      * table.
      */
     if (!OidIsValid(table_like_clause->relationOid))
         elog(ERROR, "expandTableLikeClause called on untransformed LIKE clause");
  
     relation = relation_open(table_like_clause->relationOid, NoLock);
  
     tupleDesc = RelationGetDescr(relation);
     constr = tupleDesc->constr;
  
     /*
      * Open the newly-created child relation; we have lock on that too.
      */
     childrel = relation_openrv(heapRel, NoLock);
  
     /*
      * Construct a map from the LIKE relation's attnos to the child rel's.
      * This re-checks type match etc, although it shouldn't be possible to
      * have a failure since both tables are locked.
      */
     attmap = build_attrmap_by_name(RelationGetDescr(childrel),
                                    tupleDesc,
                                    false);
  
     /*
      * Process defaults, if required.
      */
     if ((table_like_clause->options &
          (CREATE_TABLE_LIKE_DEFAULTS | CREATE_TABLE_LIKE_GENERATED)) &&
         constr != NULL)
     {
         for (parent_attno = 1; parent_attno <= tupleDesc->natts;
              parent_attno++)
         {
             Form_pg_attribute attribute = TupleDescAttr(tupleDesc,
                                                         parent_attno - 1);
  
             /*
              * Ignore dropped columns in the parent.
              */
             if (attribute->attisdropped)
                 continue;
  
             /*
              * Copy default, if present and it should be copied.  We have
              * separate options for plain default expressions and GENERATED
              * defaults.
              */
             if (attribute->atthasdef &&
                 (attribute->attgenerated ?
                  (table_like_clause->options & CREATE_TABLE_LIKE_GENERATED) :
                  (table_like_clause->options & CREATE_TABLE_LIKE_DEFAULTS)))
             {
                 Node       *this_default;
                 AlterTableCmd *atsubcmd;
                 bool        found_whole_row;
  
                 this_default = TupleDescGetDefault(tupleDesc, parent_attno);
                 if (this_default == NULL)
                     elog(ERROR, "default expression not found for attribute %d of relation \"%s\"",
                          parent_attno, RelationGetRelationName(relation));
  
                 atsubcmd = makeNode(AlterTableCmd);
                 atsubcmd->subtype = AT_CookedColumnDefault;
                 atsubcmd->num = attmap->attnums[parent_attno - 1];
                 atsubcmd->def = map_variable_attnos(this_default,
                                                     1, 0,
                                                     attmap,
                                                     InvalidOid,
                                                     &found_whole_row);
  
                 /*
                  * Prevent this for the same reason as for constraints below.
                  * Note that defaults cannot contain any vars, so it's OK that
                  * the error message refers to generated columns.
                  */
                 if (found_whole_row)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("cannot convert whole-row table reference"),
                              errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
                                        NameStr(attribute->attname),
                                        RelationGetRelationName(relation))));
  
                 atsubcmds = lappend(atsubcmds, atsubcmd);
             }
         }
     }
  
     /*
      * Copy CHECK constraints if requested, being careful to adjust attribute
      * numbers so they match the child.
      */
     if ((table_like_clause->options & CREATE_TABLE_LIKE_CONSTRAINTS) &&
         constr != NULL)
     {
         int         ccnum;
  
         for (ccnum = 0; ccnum < constr->num_check; ccnum++)
         {
             char       *ccname = constr->check[ccnum].ccname;
             char       *ccbin = constr->check[ccnum].ccbin;
             bool        ccnoinherit = constr->check[ccnum].ccnoinherit;
             Node       *ccbin_node;
             bool        found_whole_row;
             Constraint *n;
             AlterTableCmd *atsubcmd;
  
             ccbin_node = map_variable_attnos(stringToNode(ccbin),
                                              1, 0,
                                              attmap,
                                              InvalidOid, &found_whole_row);
  
             /*
              * We reject whole-row variables because the whole point of LIKE
              * is that the new table's rowtype might later diverge from the
              * parent's.  So, while translation might be possible right now,
              * it wouldn't be possible to guarantee it would work in future.
              */
             if (found_whole_row)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot convert whole-row table reference"),
                          errdetail("Constraint \"%s\" contains a whole-row reference to table \"%s\".",
                                    ccname,
                                    RelationGetRelationName(relation))));
  
             n = makeNode(Constraint);
             n->contype = CONSTR_CHECK;
             n->conname = pstrdup(ccname);
             n->location = -1;
             n->is_no_inherit = ccnoinherit;
             n->raw_expr = NULL;
             n->cooked_expr = nodeToString(ccbin_node);
  
             /* We can skip validation, since the new table should be empty. */
             n->skip_validation = true;
             n->initially_valid = true;
  
             atsubcmd = makeNode(AlterTableCmd);
             atsubcmd->subtype = AT_AddConstraint;
             atsubcmd->def = (Node *) n;
             atsubcmds = lappend(atsubcmds, atsubcmd);
  
             /* Copy comment on constraint */
             if ((table_like_clause->options & CREATE_TABLE_LIKE_COMMENTS) &&
                 (comment = GetComment(get_relation_constraint_oid(RelationGetRelid(relation),
                                                                   n->conname, false),
                                       ConstraintRelationId,
                                       0)) != NULL)
             {
                 CommentStmt *stmt = makeNode(CommentStmt);
  
                 stmt->objtype = OBJECT_TABCONSTRAINT;
                 stmt->object = (Node *) list_make3(makeString(heapRel->schemaname),
                                                    makeString(heapRel->relname),
                                                    makeString(n->conname));
                 stmt->comment = comment;
  
                 result = lappend(result, stmt);
             }
         }
     }
  
     /*
      * Copy not-null constraints, too (these do not require any option to have
      * been given).
      */
     foreach(lc, RelationGetNotNullConstraints(RelationGetRelid(relation), false))
     {
         AlterTableCmd *atsubcmd;
  
         atsubcmd = makeNode(AlterTableCmd);
         atsubcmd->subtype = AT_AddConstraint;
         atsubcmd->def = (Node *) lfirst_node(Constraint, lc);
         atsubcmds = lappend(atsubcmds, atsubcmd);
     }
  
     /*
      * If we generated any ALTER TABLE actions above, wrap them into a single
      * ALTER TABLE command.  Stick it at the front of the result, so it runs
      * before any CommentStmts we made above.
      */
     if (atsubcmds)
     {
         AlterTableStmt *atcmd = makeNode(AlterTableStmt);
  
         atcmd->relation = copyObject(heapRel);
         atcmd->cmds = atsubcmds;
         atcmd->objtype = OBJECT_TABLE;
         atcmd->missing_ok = false;
         result = lcons(atcmd, result);
  
         at_pushed = true;
     }
  
     /*
      * Process indexes if required.
      */
     if ((table_like_clause->options & CREATE_TABLE_LIKE_INDEXES) &&
         relation->rd_rel->relhasindex)
     {
         List       *parent_indexes;
         ListCell   *l;
  
         parent_indexes = RelationGetIndexList(relation);
  
         foreach(l, parent_indexes)
         {
             Oid         parent_index_oid = lfirst_oid(l);
             Relation    parent_index;
             IndexStmt  *index_stmt;
  
             parent_index = index_open(parent_index_oid, AccessShareLock);
  
             /* Build CREATE INDEX statement to recreate the parent_index */
             index_stmt = generateClonedIndexStmt(heapRel,
                                                  parent_index,
                                                  attmap,
                                                  NULL);
  
             /*
              * The PK columns might not yet non-nullable, so make sure they
              * become so.
              */
             if (index_stmt->primary)
             {
                 foreach(lc, index_stmt->indexParams)
                 {
                     IndexElem  *col = lfirst_node(IndexElem, lc);
                     AlterTableCmd *notnullcmd = makeNode(AlterTableCmd);
  
                     notnullcmd->subtype = AT_SetAttNotNull;
                     notnullcmd->name = pstrdup(col->name);
                     /* Luckily we can still add more AT-subcmds here */
                     atsubcmds = lappend(atsubcmds, notnullcmd);
                 }
  
                 /*
                  * If we had already put the AlterTableStmt into the output
                  * list, we don't need to do so again; otherwise do it.
                  */
                 if (!at_pushed)
                 {
                     AlterTableStmt *atcmd = makeNode(AlterTableStmt);
  
                     atcmd->relation = copyObject(heapRel);
                     atcmd->cmds = atsubcmds;
                     atcmd->objtype = OBJECT_TABLE;
                     atcmd->missing_ok = false;
                     result = lcons(atcmd, result);
                 }
             }
  
             /* Copy comment on index, if requested */
             if (table_like_clause->options & CREATE_TABLE_LIKE_COMMENTS)
             {
                 comment = GetComment(parent_index_oid, RelationRelationId, 0);
  
                 /*
                  * We make use of IndexStmt's idxcomment option, so as not to
                  * need to know now what name the index will have.
                  */
                 index_stmt->idxcomment = comment;
             }
  
             result = lappend(result, index_stmt);
  
             index_close(parent_index, AccessShareLock);
         }
     }
  
     /* Done with child rel */
     table_close(childrel, NoLock);
  
     /*
      * Close the parent rel, but keep our AccessShareLock on it until xact
      * commit.  That will prevent someone else from deleting or ALTERing the
      * parent before the child is committed.
      */
     table_close(relation, NoLock);
  
     return result;
 }

References AccessShareLock, AT_AddConstraint, AT_CookedColumnDefault, AT_SetAttNotNull, AttrMap::attnums, build_attrmap_by_name(), ConstrCheck::ccbin, ConstrCheck::ccname, ConstrCheck::ccnoinherit, TupleConstr::check, AlterTableStmt::cmds, comment, Constraint::conname, TupleDescData::constr, CONSTR_CHECK, Constraint::contype, Constraint::cooked_expr, copyObject, CREATE_TABLE_LIKE_COMMENTS, CREATE_TABLE_LIKE_CONSTRAINTS, CREATE_TABLE_LIKE_DEFAULTS, CREATE_TABLE_LIKE_GENERATED, CREATE_TABLE_LIKE_INDEXES, AlterTableCmd::def, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, generateClonedIndexStmt(), get_relation_constraint_oid(), GetComment(), IndexStmt::idxcomment, index_close(), index_open(), IndexStmt::indexParams, Constraint::initially_valid, InvalidOid, Constraint::is_no_inherit, lappend(), lcons(), lfirst_node, lfirst_oid, list_make3, Constraint::location, makeNode, makeString(), map_variable_attnos(), AlterTableStmt::missing_ok, IndexElem::name, AlterTableCmd::name, NameStr, TupleDescData::natts, NIL, nodeToString(), NoLock, AlterTableCmd::num, TupleConstr::num_check, OBJECT_TABCONSTRAINT, OBJECT_TABLE, AlterTableStmt::objtype, OidIsValid, TableLikeClause::options, IndexStmt::primary, pstrdup(), Constraint::raw_expr, RelationData::rd_rel, AlterTableStmt::relation, relation_open(), relation_openrv(), RelationGetDescr, RelationGetIndexList(), RelationGetNotNullConstraints(), RelationGetRelationName, RelationGetRelid, TableLikeClause::relationOid, RangeVar::relname, RangeVar::schemaname, Constraint::skip_validation, stmt, stringToNode(), AlterTableCmd::subtype, table_close(), TupleDescAttr, and TupleDescGetDefault().

Referenced by ProcessUtilitySlow().

◆ generateClonedIndexStmt()

IndexStmt* generateClonedIndexStmt	(	RangeVar *	heapRel,
		Relation	source_idx,
		const struct AttrMap *	attmap,
		Oid *	constraintOid
	)

◆ transformAlterTableStmt()

AlterTableStmt* transformAlterTableStmt	(	Oid	relid,
		AlterTableStmt *	stmt,
		const char *	queryString,
		List **	beforeStmts,
		List **	afterStmts
	)

Definition at line 3581 of file parse_utilcmd.c.

 {
     Relation    rel;
     TupleDesc   tupdesc;
     ParseState *pstate;
     CreateStmtContext cxt;
     List       *save_alist;
     ListCell   *lcmd,
                *l;
     List       *newcmds = NIL;
     bool        skipValidation = true;
     AlterTableCmd *newcmd;
     ParseNamespaceItem *nsitem;
  
     /* Caller is responsible for locking the relation */
     rel = relation_open(relid, NoLock);
     tupdesc = RelationGetDescr(rel);
  
     /* Set up pstate */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
     nsitem = addRangeTableEntryForRelation(pstate,
                                            rel,
                                            AccessShareLock,
                                            NULL,
                                            false,
                                            true);
     addNSItemToQuery(pstate, nsitem, false, true, true);
  
     /* Set up CreateStmtContext */
     cxt.pstate = pstate;
     if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
     {
         cxt.stmtType = "ALTER FOREIGN TABLE";
         cxt.isforeign = true;
     }
     else
     {
         cxt.stmtType = "ALTER TABLE";
         cxt.isforeign = false;
     }
     cxt.relation = stmt->relation;
     cxt.rel = rel;
     cxt.inhRelations = NIL;
     cxt.isalter = true;
     cxt.columns = NIL;
     cxt.ckconstraints = NIL;
     cxt.nnconstraints = NIL;
     cxt.fkconstraints = NIL;
     cxt.ixconstraints = NIL;
     cxt.likeclauses = NIL;
     cxt.extstats = NIL;
     cxt.blist = NIL;
     cxt.alist = NIL;
     cxt.pkey = NULL;
     cxt.ispartitioned = (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
     cxt.partbound = NULL;
     cxt.ofType = false;
  
     /*
      * Transform ALTER subcommands that need it (most don't).  These largely
      * re-use code from CREATE TABLE.
      */
     foreach(lcmd, stmt->cmds)
     {
         AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
  
         switch (cmd->subtype)
         {
             case AT_AddColumn:
                 {
                     ColumnDef  *def = castNode(ColumnDef, cmd->def);
  
                     transformColumnDefinition(&cxt, def);
  
                     /*
                      * If the column has a non-null default, we can't skip
                      * validation of foreign keys.
                      */
                     if (def->raw_default != NULL)
                         skipValidation = false;
  
                     /*
                      * All constraints are processed in other ways. Remove the
                      * original list
                      */
                     def->constraints = NIL;
  
                     newcmds = lappend(newcmds, cmd);
                     break;
                 }
  
             case AT_AddConstraint:
  
                 /*
                  * The original AddConstraint cmd node doesn't go to newcmds
                  */
                 if (IsA(cmd->def, Constraint))
                 {
                     transformTableConstraint(&cxt, (Constraint *) cmd->def);
                     if (((Constraint *) cmd->def)->contype == CONSTR_FOREIGN)
                         skipValidation = false;
                 }
                 else
                     elog(ERROR, "unrecognized node type: %d",
                          (int) nodeTag(cmd->def));
                 break;
  
             case AT_AlterColumnType:
                 {
                     ColumnDef  *def = castNode(ColumnDef, cmd->def);
                     AttrNumber  attnum;
  
                     /*
                      * For ALTER COLUMN TYPE, transform the USING clause if
                      * one was specified.
                      */
                     if (def->raw_default)
                     {
                         def->cooked_default =
                             transformExpr(pstate, def->raw_default,
                                           EXPR_KIND_ALTER_COL_TRANSFORM);
                     }
  
                     /*
                      * For identity column, create ALTER SEQUENCE command to
                      * change the data type of the sequence.
                      */
                     attnum = get_attnum(relid, cmd->name);
                     if (attnum == InvalidAttrNumber)
                         ereport(ERROR,
                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
                                  errmsg("column \"%s\" of relation \"%s\" does not exist",
                                         cmd->name, RelationGetRelationName(rel))));
  
                     if (attnum > 0 &&
                         TupleDescAttr(tupdesc, attnum - 1)->attidentity)
                     {
                         Oid         seq_relid = getIdentitySequence(relid, attnum, false);
                         Oid         typeOid = typenameTypeId(pstate, def->typeName);
                         AlterSeqStmt *altseqstmt = makeNode(AlterSeqStmt);
  
                         altseqstmt->sequence = makeRangeVar(get_namespace_name(get_rel_namespace(seq_relid)),
                                                             get_rel_name(seq_relid),
                                                             -1);
                         altseqstmt->options = list_make1(makeDefElem("as", (Node *) makeTypeNameFromOid(typeOid, -1), -1));
                         altseqstmt->for_identity = true;
                         cxt.blist = lappend(cxt.blist, altseqstmt);
                     }
  
                     newcmds = lappend(newcmds, cmd);
                     break;
                 }
  
             case AT_AddIdentity:
                 {
                     Constraint *def = castNode(Constraint, cmd->def);
                     ColumnDef  *newdef = makeNode(ColumnDef);
                     AttrNumber  attnum;
  
                     newdef->colname = cmd->name;
                     newdef->identity = def->generated_when;
                     cmd->def = (Node *) newdef;
  
                     attnum = get_attnum(relid, cmd->name);
                     if (attnum == InvalidAttrNumber)
                         ereport(ERROR,
                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
                                  errmsg("column \"%s\" of relation \"%s\" does not exist",
                                         cmd->name, RelationGetRelationName(rel))));
  
                     generateSerialExtraStmts(&cxt, newdef,
                                              get_atttype(relid, attnum),
                                              def->options, true, true,
                                              NULL, NULL);
  
                     newcmds = lappend(newcmds, cmd);
                     break;
                 }
  
             case AT_SetIdentity:
                 {
                     /*
                      * Create an ALTER SEQUENCE statement for the internal
                      * sequence of the identity column.
                      */
                     ListCell   *lc;
                     List       *newseqopts = NIL;
                     List       *newdef = NIL;
                     AttrNumber  attnum;
                     Oid         seq_relid;
  
                     /*
                      * Split options into those handled by ALTER SEQUENCE and
                      * those for ALTER TABLE proper.
                      */
                     foreach(lc, castNode(List, cmd->def))
                     {
                         DefElem    *def = lfirst_node(DefElem, lc);
  
                         if (strcmp(def->defname, "generated") == 0)
                             newdef = lappend(newdef, def);
                         else
                             newseqopts = lappend(newseqopts, def);
                     }
  
                     attnum = get_attnum(relid, cmd->name);
                     if (attnum == InvalidAttrNumber)
                         ereport(ERROR,
                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
                                  errmsg("column \"%s\" of relation \"%s\" does not exist",
                                         cmd->name, RelationGetRelationName(rel))));
  
                     seq_relid = getIdentitySequence(relid, attnum, true);
  
                     if (seq_relid)
                     {
                         AlterSeqStmt *seqstmt;
  
                         seqstmt = makeNode(AlterSeqStmt);
                         seqstmt->sequence = makeRangeVar(get_namespace_name(get_rel_namespace(seq_relid)),
                                                          get_rel_name(seq_relid), -1);
                         seqstmt->options = newseqopts;
                         seqstmt->for_identity = true;
                         seqstmt->missing_ok = false;
  
                         cxt.blist = lappend(cxt.blist, seqstmt);
                     }
  
                     /*
                      * If column was not an identity column, we just let the
                      * ALTER TABLE command error out later.  (There are cases
                      * this fails to cover, but we'll need to restructure
                      * where creation of the sequence dependency linkage
                      * happens before we can fix it.)
                      */
  
                     cmd->def = (Node *) newdef;
                     newcmds = lappend(newcmds, cmd);
                     break;
                 }
  
             case AT_AttachPartition:
             case AT_DetachPartition:
                 {
                     PartitionCmd *partcmd = (PartitionCmd *) cmd->def;
  
                     transformPartitionCmd(&cxt, partcmd->bound);
                     /* assign transformed value of the partition bound */
                     partcmd->bound = cxt.partbound;
                 }
  
                 newcmds = lappend(newcmds, cmd);
                 break;
  
             case AT_SplitPartition:
             case AT_MergePartitions:
                 {
                     PartitionCmd *partcmd = (PartitionCmd *) cmd->def;
  
                     if (list_length(partcmd->partlist) < 2)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("list of new partitions should contain at least two items")));
  
                     if (cmd->subtype == AT_SplitPartition)
                         transformPartitionCmdForSplit(&cxt, partcmd);
                     else
                         transformPartitionCmdForMerge(&cxt, partcmd);
                     newcmds = lappend(newcmds, cmd);
                     break;
                 }
  
             default:
  
                 /*
                  * Currently, we shouldn't actually get here for subcommand
                  * types that don't require transformation; but if we do, just
                  * emit them unchanged.
                  */
                 newcmds = lappend(newcmds, cmd);
                 break;
         }
     }
  
     /*
      * Transfer anything we already have in cxt.alist into save_alist, to keep
      * it separate from the output of transformIndexConstraints.
      */
     save_alist = cxt.alist;
     cxt.alist = NIL;
  
     /* Postprocess constraints */
     transformIndexConstraints(&cxt);
     transformFKConstraints(&cxt, skipValidation, true);
     transformCheckConstraints(&cxt, false);
  
     /*
      * Push any index-creation commands into the ALTER, so that they can be
      * scheduled nicely by tablecmds.c.  Note that tablecmds.c assumes that
      * the IndexStmt attached to an AT_AddIndex or AT_AddIndexConstraint
      * subcommand has already been through transformIndexStmt.
      */
     foreach(l, cxt.alist)
     {
         Node       *istmt = (Node *) lfirst(l);
  
         /*
          * We assume here that cxt.alist contains only IndexStmts and possibly
          * AT_SetAttNotNull statements generated from primary key constraints.
          * We absorb the subcommands of the latter directly.
          */
         if (IsA(istmt, IndexStmt))
         {
             IndexStmt  *idxstmt = (IndexStmt *) istmt;
  
             idxstmt = transformIndexStmt(relid, idxstmt, queryString);
             newcmd = makeNode(AlterTableCmd);
             newcmd->subtype = OidIsValid(idxstmt->indexOid) ? AT_AddIndexConstraint : AT_AddIndex;
             newcmd->def = (Node *) idxstmt;
             newcmds = lappend(newcmds, newcmd);
         }
         else if (IsA(istmt, AlterTableStmt))
         {
             AlterTableStmt *alterstmt = (AlterTableStmt *) istmt;
  
             newcmds = list_concat(newcmds, alterstmt->cmds);
         }
         else
             elog(ERROR, "unexpected stmt type %d", (int) nodeTag(istmt));
     }
     cxt.alist = NIL;
  
     /* Append any CHECK, NOT NULL or FK constraints to the commands list */
     foreach(l, cxt.ckconstraints)
     {
         newcmd = makeNode(AlterTableCmd);
         newcmd->subtype = AT_AddConstraint;
         newcmd->def = (Node *) lfirst_node(Constraint, l);
         newcmds = lappend(newcmds, newcmd);
     }
     foreach(l, cxt.nnconstraints)
     {
         newcmd = makeNode(AlterTableCmd);
         newcmd->subtype = AT_AddConstraint;
         newcmd->def = (Node *) lfirst_node(Constraint, l);
         newcmds = lappend(newcmds, newcmd);
     }
     foreach(l, cxt.fkconstraints)
     {
         newcmd = makeNode(AlterTableCmd);
         newcmd->subtype = AT_AddConstraint;
         newcmd->def = (Node *) lfirst_node(Constraint, l);
         newcmds = lappend(newcmds, newcmd);
     }
  
     /* Append extended statistics objects */
     transformExtendedStatistics(&cxt);
  
     /* Close rel */
     relation_close(rel, NoLock);
  
     /*
      * Output results.
      */
     stmt->cmds = newcmds;
  
     *beforeStmts = cxt.blist;
     *afterStmts = list_concat(cxt.alist, save_alist);
  
     return stmt;
 }

Referenced by ATParseTransformCmd(), and ATPostAlterTypeParse().

◆ transformCreateSchemaStmtElements()

List* transformCreateSchemaStmtElements	(	List *	schemaElts,
		const char *	schemaName
	)

Definition at line 4139 of file parse_utilcmd.c.

 {
     CreateSchemaStmtContext cxt;
     List       *result;
     ListCell   *elements;
  
     cxt.schemaname = schemaName;
     cxt.sequences = NIL;
     cxt.tables = NIL;
     cxt.views = NIL;
     cxt.indexes = NIL;
     cxt.triggers = NIL;
     cxt.grants = NIL;
  
     /*
      * Run through each schema element in the schema element list. Separate
      * statements by type, and do preliminary analysis.
      */
     foreach(elements, schemaElts)
     {
         Node       *element = lfirst(elements);
  
         switch (nodeTag(element))
         {
             case T_CreateSeqStmt:
                 {
                     CreateSeqStmt *elp = (CreateSeqStmt *) element;
  
                     setSchemaName(cxt.schemaname, &elp->sequence->schemaname);
                     cxt.sequences = lappend(cxt.sequences, element);
                 }
                 break;
  
             case T_CreateStmt:
                 {
                     CreateStmt *elp = (CreateStmt *) element;
  
                     setSchemaName(cxt.schemaname, &elp->relation->schemaname);
  
                     /*
                      * XXX todo: deal with constraints
                      */
                     cxt.tables = lappend(cxt.tables, element);
                 }
                 break;
  
             case T_ViewStmt:
                 {
                     ViewStmt   *elp = (ViewStmt *) element;
  
                     setSchemaName(cxt.schemaname, &elp->view->schemaname);
  
                     /*
                      * XXX todo: deal with references between views
                      */
                     cxt.views = lappend(cxt.views, element);
                 }
                 break;
  
             case T_IndexStmt:
                 {
                     IndexStmt  *elp = (IndexStmt *) element;
  
                     setSchemaName(cxt.schemaname, &elp->relation->schemaname);
                     cxt.indexes = lappend(cxt.indexes, element);
                 }
                 break;
  
             case T_CreateTrigStmt:
                 {
                     CreateTrigStmt *elp = (CreateTrigStmt *) element;
  
                     setSchemaName(cxt.schemaname, &elp->relation->schemaname);
                     cxt.triggers = lappend(cxt.triggers, element);
                 }
                 break;
  
             case T_GrantStmt:
                 cxt.grants = lappend(cxt.grants, element);
                 break;
  
             default:
                 elog(ERROR, "unrecognized node type: %d",
                      (int) nodeTag(element));
         }
     }
  
     result = NIL;
     result = list_concat(result, cxt.sequences);
     result = list_concat(result, cxt.tables);
     result = list_concat(result, cxt.views);
     result = list_concat(result, cxt.indexes);
     result = list_concat(result, cxt.triggers);
     result = list_concat(result, cxt.grants);
  
     return result;
 }

References element(), elog, ERROR, CreateSchemaStmtContext::grants, CreateSchemaStmtContext::indexes, lappend(), lfirst, list_concat(), NIL, nodeTag, CreateStmt::relation, CreateTrigStmt::relation, IndexStmt::relation, CreateSchemaStmtContext::schemaname, RangeVar::schemaname, CreateSeqStmt::sequence, CreateSchemaStmtContext::sequences, setSchemaName(), CreateSchemaStmtContext::tables, CreateSchemaStmtContext::triggers, ViewStmt::view, and CreateSchemaStmtContext::views.

Referenced by CreateSchemaCommand().

◆ transformCreateStmt()

List* transformCreateStmt	(	CreateStmt *	stmt,
		const char *	queryString
	)

Definition at line 167 of file parse_utilcmd.c.

 {
     ParseState *pstate;
     CreateStmtContext cxt;
     List       *result;
     List       *save_alist;
     ListCell   *elements;
     Oid         namespaceid;
     Oid         existing_relid;
     ParseCallbackState pcbstate;
  
     /* Set up pstate */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
  
     /*
      * Look up the creation namespace.  This also checks permissions on the
      * target namespace, locks it against concurrent drops, checks for a
      * preexisting relation in that namespace with the same name, and updates
      * stmt->relation->relpersistence if the selected namespace is temporary.
      */
     setup_parser_errposition_callback(&pcbstate, pstate,
                                       stmt->relation->location);
     namespaceid =
         RangeVarGetAndCheckCreationNamespace(stmt->relation, NoLock,
                                              &existing_relid);
     cancel_parser_errposition_callback(&pcbstate);
  
     /*
      * If the relation already exists and the user specified "IF NOT EXISTS",
      * bail out with a NOTICE.
      */
     if (stmt->if_not_exists && OidIsValid(existing_relid))
     {
         /*
          * If we are in an extension script, insist that the pre-existing
          * object be a member of the extension, to avoid security risks.
          */
         ObjectAddress address;
  
         ObjectAddressSet(address, RelationRelationId, existing_relid);
         checkMembershipInCurrentExtension(&address);
  
         /* OK to skip */
         ereport(NOTICE,
                 (errcode(ERRCODE_DUPLICATE_TABLE),
                  errmsg("relation \"%s\" already exists, skipping",
                         stmt->relation->relname)));
         return NIL;
     }
  
     /*
      * If the target relation name isn't schema-qualified, make it so.  This
      * prevents some corner cases in which added-on rewritten commands might
      * think they should apply to other relations that have the same name and
      * are earlier in the search path.  But a local temp table is effectively
      * specified to be in pg_temp, so no need for anything extra in that case.
      */
     if (stmt->relation->schemaname == NULL
         && stmt->relation->relpersistence != RELPERSISTENCE_TEMP)
         stmt->relation->schemaname = get_namespace_name(namespaceid);
  
     /* Set up CreateStmtContext */
     cxt.pstate = pstate;
     if (IsA(stmt, CreateForeignTableStmt))
     {
         cxt.stmtType = "CREATE FOREIGN TABLE";
         cxt.isforeign = true;
     }
     else
     {
         cxt.stmtType = "CREATE TABLE";
         cxt.isforeign = false;
     }
     cxt.relation = stmt->relation;
     cxt.rel = NULL;
     cxt.inhRelations = stmt->inhRelations;
     cxt.isalter = false;
     cxt.columns = NIL;
     cxt.ckconstraints = NIL;
     cxt.nnconstraints = NIL;
     cxt.fkconstraints = NIL;
     cxt.ixconstraints = NIL;
     cxt.likeclauses = NIL;
     cxt.extstats = NIL;
     cxt.blist = NIL;
     cxt.alist = NIL;
     cxt.pkey = NULL;
     cxt.ispartitioned = stmt->partspec != NULL;
     cxt.partbound = stmt->partbound;
     cxt.ofType = (stmt->ofTypename != NULL);
  
     Assert(!stmt->ofTypename || !stmt->inhRelations);   /* grammar enforces */
  
     if (stmt->ofTypename)
         transformOfType(&cxt, stmt->ofTypename);
  
     if (stmt->partspec)
     {
         if (stmt->inhRelations && !stmt->partbound)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cannot create partitioned table as inheritance child")));
     }
  
     /*
      * Run through each primary element in the table creation clause. Separate
      * column defs from constraints, and do preliminary analysis.
      */
     foreach(elements, stmt->tableElts)
     {
         Node       *element = lfirst(elements);
  
         switch (nodeTag(element))
         {
             case T_ColumnDef:
                 transformColumnDefinition(&cxt, (ColumnDef *) element);
                 break;
  
             case T_Constraint:
                 transformTableConstraint(&cxt, (Constraint *) element);
                 break;
  
             case T_TableLikeClause:
                 transformTableLikeClause(&cxt, (TableLikeClause *) element);
                 break;
  
             default:
                 elog(ERROR, "unrecognized node type: %d",
                      (int) nodeTag(element));
                 break;
         }
     }
  
     /*
      * Transfer anything we already have in cxt.alist into save_alist, to keep
      * it separate from the output of transformIndexConstraints.  (This may
      * not be necessary anymore, but we'll keep doing it to preserve the
      * historical order of execution of the alist commands.)
      */
     save_alist = cxt.alist;
     cxt.alist = NIL;
  
     Assert(stmt->constraints == NIL);
  
     /*
      * Postprocess constraints that give rise to index definitions.
      */
     transformIndexConstraints(&cxt);
  
     /*
      * Re-consideration of LIKE clauses should happen after creation of
      * indexes, but before creation of foreign keys.  This order is critical
      * because a LIKE clause may attempt to create a primary key.  If there's
      * also a pkey in the main CREATE TABLE list, creation of that will not
      * check for a duplicate at runtime (since index_check_primary_key()
      * expects that we rejected dups here).  Creation of the LIKE-generated
      * pkey behaves like ALTER TABLE ADD, so it will check, but obviously that
      * only works if it happens second.  On the other hand, we want to make
      * pkeys before foreign key constraints, in case the user tries to make a
      * self-referential FK.
      */
     cxt.alist = list_concat(cxt.alist, cxt.likeclauses);
  
     /*
      * Postprocess foreign-key constraints.
      */
     transformFKConstraints(&cxt, true, false);
  
     /*
      * Postprocess check constraints.
      *
      * For regular tables all constraints can be marked valid immediately,
      * because the table is new therefore empty. Not so for foreign tables.
      */
     transformCheckConstraints(&cxt, !cxt.isforeign);
  
     /*
      * Postprocess extended statistics.
      */
     transformExtendedStatistics(&cxt);
  
     /*
      * Output results.
      */
     stmt->tableElts = cxt.columns;
     stmt->constraints = cxt.ckconstraints;
     stmt->nnconstraints = cxt.nnconstraints;
  
     result = lappend(cxt.blist, stmt);
     result = list_concat(result, cxt.alist);
     result = list_concat(result, save_alist);
  
     return result;
 }

Referenced by ProcessUtilitySlow().

◆ transformIndexStmt()

IndexStmt* transformIndexStmt	(	Oid	relid,
		IndexStmt *	stmt,
		const char *	queryString
	)

Definition at line 2956 of file parse_utilcmd.c.

 {
     ParseState *pstate;
     ParseNamespaceItem *nsitem;
     ListCell   *l;
     Relation    rel;
  
     /* Nothing to do if statement already transformed. */
     if (stmt->transformed)
         return stmt;
  
     /* Set up pstate */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
  
     /*
      * Put the parent table into the rtable so that the expressions can refer
      * to its fields without qualification.  Caller is responsible for locking
      * relation, but we still need to open it.
      */
     rel = relation_open(relid, NoLock);
     nsitem = addRangeTableEntryForRelation(pstate, rel,
                                            AccessShareLock,
                                            NULL, false, true);
  
     /* no to join list, yes to namespaces */
     addNSItemToQuery(pstate, nsitem, false, true, true);
  
     /* take care of the where clause */
     if (stmt->whereClause)
     {
         stmt->whereClause = transformWhereClause(pstate,
                                                  stmt->whereClause,
                                                  EXPR_KIND_INDEX_PREDICATE,
                                                  "WHERE");
         /* we have to fix its collations too */
         assign_expr_collations(pstate, stmt->whereClause);
     }
  
     /* take care of any index expressions */
     foreach(l, stmt->indexParams)
     {
         IndexElem  *ielem = (IndexElem *) lfirst(l);
  
         if (ielem->expr)
         {
             /* Extract preliminary index col name before transforming expr */
             if (ielem->indexcolname == NULL)
                 ielem->indexcolname = FigureIndexColname(ielem->expr);
  
             /* Now do parse transformation of the expression */
             ielem->expr = transformExpr(pstate, ielem->expr,
                                         EXPR_KIND_INDEX_EXPRESSION);
  
             /* We have to fix its collations too */
             assign_expr_collations(pstate, ielem->expr);
  
             /*
              * transformExpr() should have already rejected subqueries,
              * aggregates, window functions, and SRFs, based on the EXPR_KIND_
              * for an index expression.
              *
              * DefineIndex() will make more checks.
              */
         }
     }
  
     /*
      * Check that only the base rel is mentioned.  (This should be dead code
      * now that add_missing_from is history.)
      */
     if (list_length(pstate->p_rtable) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("index expressions and predicates can refer only to the table being indexed")));
  
     free_parsestate(pstate);
  
     /* Close relation */
     table_close(rel, NoLock);
  
     /* Mark statement as successfully transformed */
     stmt->transformed = true;
  
     return stmt;
 }

References AccessShareLock, addNSItemToQuery(), addRangeTableEntryForRelation(), assign_expr_collations(), ereport, errcode(), errmsg(), ERROR, IndexElem::expr, EXPR_KIND_INDEX_EXPRESSION, EXPR_KIND_INDEX_PREDICATE, FigureIndexColname(), free_parsestate(), IndexElem::indexcolname, lfirst, list_length(), make_parsestate(), NoLock, ParseState::p_rtable, ParseState::p_sourcetext, relation_open(), stmt, table_close(), transformExpr(), and transformWhereClause().

Referenced by ATPostAlterTypeParse(), ProcessUtilitySlow(), and transformAlterTableStmt().

◆ transformPartitionBound()

PartitionBoundSpec* transformPartitionBound	(	ParseState *	pstate,
		Relation	parent,
		PartitionBoundSpec *	spec
	)

Definition at line 4315 of file parse_utilcmd.c.

 {
     PartitionBoundSpec *result_spec;
     PartitionKey key = RelationGetPartitionKey(parent);
     char        strategy = get_partition_strategy(key);
     int         partnatts = get_partition_natts(key);
     List       *partexprs = get_partition_exprs(key);
  
     /* Avoid scribbling on input */
     result_spec = copyObject(spec);
  
     if (spec->is_default)
     {
         /*
          * Hash partitioning does not support a default partition; there's no
          * use case for it (since the set of partitions to create is perfectly
          * defined), and if users do get into it accidentally, it's hard to
          * back out from it afterwards.
          */
         if (strategy == PARTITION_STRATEGY_HASH)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("a hash-partitioned table may not have a default partition")));
  
         /*
          * In case of the default partition, parser had no way to identify the
          * partition strategy. Assign the parent's strategy to the default
          * partition bound spec.
          */
         result_spec->strategy = strategy;
  
         return result_spec;
     }
  
     if (strategy == PARTITION_STRATEGY_HASH)
     {
         if (spec->strategy != PARTITION_STRATEGY_HASH)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("invalid bound specification for a hash partition"),
                      parser_errposition(pstate, exprLocation((Node *) spec))));
  
         if (spec->modulus <= 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("modulus for hash partition must be an integer value greater than zero")));
  
         Assert(spec->remainder >= 0);
  
         if (spec->remainder >= spec->modulus)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("remainder for hash partition must be less than modulus")));
     }
     else if (strategy == PARTITION_STRATEGY_LIST)
     {
         ListCell   *cell;
         char       *colname;
         Oid         coltype;
         int32       coltypmod;
         Oid         partcollation;
  
         if (spec->strategy != PARTITION_STRATEGY_LIST)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("invalid bound specification for a list partition"),
                      parser_errposition(pstate, exprLocation((Node *) spec))));
  
         /* Get the only column's name in case we need to output an error */
         if (key->partattrs[0] != 0)
             colname = get_attname(RelationGetRelid(parent),
                                   key->partattrs[0], false);
         else
             colname = deparse_expression((Node *) linitial(partexprs),
                                          deparse_context_for(RelationGetRelationName(parent),
                                                              RelationGetRelid(parent)),
                                          false, false);
         /* Need its type data too */
         coltype = get_partition_col_typid(key, 0);
         coltypmod = get_partition_col_typmod(key, 0);
         partcollation = get_partition_col_collation(key, 0);
  
         result_spec->listdatums = NIL;
         foreach(cell, spec->listdatums)
         {
             Node       *expr = lfirst(cell);
             Const      *value;
             ListCell   *cell2;
             bool        duplicate;
  
             value = transformPartitionBoundValue(pstate, expr,
                                                  colname, coltype, coltypmod,
                                                  partcollation);
  
             /* Don't add to the result if the value is a duplicate */
             duplicate = false;
             foreach(cell2, result_spec->listdatums)
             {
                 Const      *value2 = lfirst_node(Const, cell2);
  
                 if (equal(value, value2))
                 {
                     duplicate = true;
                     break;
                 }
             }
             if (duplicate)
                 continue;
  
             result_spec->listdatums = lappend(result_spec->listdatums,
                                               value);
         }
     }
     else if (strategy == PARTITION_STRATEGY_RANGE)
     {
         if (spec->strategy != PARTITION_STRATEGY_RANGE)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("invalid bound specification for a range partition"),
                      parser_errposition(pstate, exprLocation((Node *) spec))));
  
         if (list_length(spec->lowerdatums) != partnatts)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("FROM must specify exactly one value per partitioning column")));
         if (list_length(spec->upperdatums) != partnatts)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                      errmsg("TO must specify exactly one value per partitioning column")));
  
         /*
          * Convert raw parse nodes into PartitionRangeDatum nodes and perform
          * any necessary validation.
          */
         result_spec->lowerdatums =
             transformPartitionRangeBounds(pstate, spec->lowerdatums,
                                           parent);
         result_spec->upperdatums =
             transformPartitionRangeBounds(pstate, spec->upperdatums,
                                           parent);
     }
     else
         elog(ERROR, "unexpected partition strategy: %d", (int) strategy);
  
     return result_spec;
 }

References Assert, copyObject, deparse_context_for(), deparse_expression(), elog, equal(), ereport, errcode(), errmsg(), ERROR, exprLocation(), get_attname(), get_partition_col_collation(), get_partition_col_typid(), get_partition_col_typmod(), get_partition_exprs(), get_partition_natts(), get_partition_strategy(), PartitionBoundSpec::is_default, sort-test::key, lappend(), lfirst, lfirst_node, linitial, list_length(), PartitionBoundSpec::listdatums, PartitionBoundSpec::lowerdatums, NIL, parser_errposition(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, RelationGetPartitionKey(), RelationGetRelationName, RelationGetRelid, PartitionBoundSpec::strategy, transformPartitionBoundValue(), transformPartitionRangeBounds(), PartitionBoundSpec::upperdatums, and value.

Referenced by DefineRelation(), and transformPartitionCmd().

◆ transformRuleStmt()

void transformRuleStmt	(	RuleStmt *	stmt,
		const char *	queryString,
		List **	actions,
		Node **	whereClause
	)

Definition at line 3126 of file parse_utilcmd.c.

 {
     Relation    rel;
     ParseState *pstate;
     ParseNamespaceItem *oldnsitem;
     ParseNamespaceItem *newnsitem;
  
     /*
      * To avoid deadlock, make sure the first thing we do is grab
      * AccessExclusiveLock on the target relation.  This will be needed by
      * DefineQueryRewrite(), and we don't want to grab a lesser lock
      * beforehand.
      */
     rel = table_openrv(stmt->relation, AccessExclusiveLock);
  
     if (rel->rd_rel->relkind == RELKIND_MATVIEW)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("rules on materialized views are not supported")));
  
     /* Set up pstate */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
  
     /*
      * NOTE: 'OLD' must always have a varno equal to 1 and 'NEW' equal to 2.
      * Set up their ParseNamespaceItems in the main pstate for use in parsing
      * the rule qualification.
      */
     oldnsitem = addRangeTableEntryForRelation(pstate, rel,
                                               AccessShareLock,
                                               makeAlias("old", NIL),
                                               false, false);
     newnsitem = addRangeTableEntryForRelation(pstate, rel,
                                               AccessShareLock,
                                               makeAlias("new", NIL),
                                               false, false);
  
     /*
      * They must be in the namespace too for lookup purposes, but only add the
      * one(s) that are relevant for the current kind of rule.  In an UPDATE
      * rule, quals must refer to OLD.field or NEW.field to be unambiguous, but
      * there's no need to be so picky for INSERT & DELETE.  We do not add them
      * to the joinlist.
      */
     switch (stmt->event)
     {
         case CMD_SELECT:
             addNSItemToQuery(pstate, oldnsitem, false, true, true);
             break;
         case CMD_UPDATE:
             addNSItemToQuery(pstate, oldnsitem, false, true, true);
             addNSItemToQuery(pstate, newnsitem, false, true, true);
             break;
         case CMD_INSERT:
             addNSItemToQuery(pstate, newnsitem, false, true, true);
             break;
         case CMD_DELETE:
             addNSItemToQuery(pstate, oldnsitem, false, true, true);
             break;
         default:
             elog(ERROR, "unrecognized event type: %d",
                  (int) stmt->event);
             break;
     }
  
     /* take care of the where clause */
     *whereClause = transformWhereClause(pstate,
                                         stmt->whereClause,
                                         EXPR_KIND_WHERE,
                                         "WHERE");
     /* we have to fix its collations too */
     assign_expr_collations(pstate, *whereClause);
  
     /* this is probably dead code without add_missing_from: */
     if (list_length(pstate->p_rtable) != 2) /* naughty, naughty... */
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("rule WHERE condition cannot contain references to other relations")));
  
     /*
      * 'instead nothing' rules with a qualification need a query rangetable so
      * the rewrite handler can add the negated rule qualification to the
      * original query. We create a query with the new command type CMD_NOTHING
      * here that is treated specially by the rewrite system.
      */
     if (stmt->actions == NIL)
     {
         Query      *nothing_qry = makeNode(Query);
  
         nothing_qry->commandType = CMD_NOTHING;
         nothing_qry->rtable = pstate->p_rtable;
         nothing_qry->rteperminfos = pstate->p_rteperminfos;
         nothing_qry->jointree = makeFromExpr(NIL, NULL);    /* no join wanted */
  
         *actions = list_make1(nothing_qry);
     }
     else
     {
         ListCell   *l;
         List       *newactions = NIL;
  
         /*
          * transform each statement, like parse_sub_analyze()
          */
         foreach(l, stmt->actions)
         {
             Node       *action = (Node *) lfirst(l);
             ParseState *sub_pstate = make_parsestate(NULL);
             Query      *sub_qry,
                        *top_subqry;
             bool        has_old,
                         has_new;
  
             /*
              * Since outer ParseState isn't parent of inner, have to pass down
              * the query text by hand.
              */
             sub_pstate->p_sourcetext = queryString;
  
             /*
              * Set up OLD/NEW in the rtable for this statement.  The entries
              * are added only to relnamespace, not varnamespace, because we
              * don't want them to be referred to by unqualified field names
              * nor "*" in the rule actions.  We decide later whether to put
              * them in the joinlist.
              */
             oldnsitem = addRangeTableEntryForRelation(sub_pstate, rel,
                                                       AccessShareLock,
                                                       makeAlias("old", NIL),
                                                       false, false);
             newnsitem = addRangeTableEntryForRelation(sub_pstate, rel,
                                                       AccessShareLock,
                                                       makeAlias("new", NIL),
                                                       false, false);
             addNSItemToQuery(sub_pstate, oldnsitem, false, true, false);
             addNSItemToQuery(sub_pstate, newnsitem, false, true, false);
  
             /* Transform the rule action statement */
             top_subqry = transformStmt(sub_pstate, action);
  
             /*
              * We cannot support utility-statement actions (eg NOTIFY) with
              * nonempty rule WHERE conditions, because there's no way to make
              * the utility action execute conditionally.
              */
             if (top_subqry->commandType == CMD_UTILITY &&
                 *whereClause != NULL)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                          errmsg("rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions")));
  
             /*
              * If the action is INSERT...SELECT, OLD/NEW have been pushed down
              * into the SELECT, and that's what we need to look at. (Ugly
              * kluge ... try to fix this when we redesign querytrees.)
              */
             sub_qry = getInsertSelectQuery(top_subqry, NULL);
  
             /*
              * If the sub_qry is a setop, we cannot attach any qualifications
              * to it, because the planner won't notice them.  This could
              * perhaps be relaxed someday, but for now, we may as well reject
              * such a rule immediately.
              */
             if (sub_qry->setOperations != NULL && *whereClause != NULL)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
  
             /*
              * Validate action's use of OLD/NEW, qual too
              */
             has_old =
                 rangeTableEntry_used((Node *) sub_qry, PRS2_OLD_VARNO, 0) ||
                 rangeTableEntry_used(*whereClause, PRS2_OLD_VARNO, 0);
             has_new =
                 rangeTableEntry_used((Node *) sub_qry, PRS2_NEW_VARNO, 0) ||
                 rangeTableEntry_used(*whereClause, PRS2_NEW_VARNO, 0);
  
             switch (stmt->event)
             {
                 case CMD_SELECT:
                     if (has_old)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("ON SELECT rule cannot use OLD")));
                     if (has_new)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("ON SELECT rule cannot use NEW")));
                     break;
                 case CMD_UPDATE:
                     /* both are OK */
                     break;
                 case CMD_INSERT:
                     if (has_old)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("ON INSERT rule cannot use OLD")));
                     break;
                 case CMD_DELETE:
                     if (has_new)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                  errmsg("ON DELETE rule cannot use NEW")));
                     break;
                 default:
                     elog(ERROR, "unrecognized event type: %d",
                          (int) stmt->event);
                     break;
             }
  
             /*
              * OLD/NEW are not allowed in WITH queries, because they would
              * amount to outer references for the WITH, which we disallow.
              * However, they were already in the outer rangetable when we
              * analyzed the query, so we have to check.
              *
              * Note that in the INSERT...SELECT case, we need to examine the
              * CTE lists of both top_subqry and sub_qry.
              *
              * Note that we aren't digging into the body of the query looking
              * for WITHs in nested sub-SELECTs.  A WITH down there can
              * legitimately refer to OLD/NEW, because it'd be an
              * indirect-correlated outer reference.
              */
             if (rangeTableEntry_used((Node *) top_subqry->cteList,
                                      PRS2_OLD_VARNO, 0) ||
                 rangeTableEntry_used((Node *) sub_qry->cteList,
                                      PRS2_OLD_VARNO, 0))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot refer to OLD within WITH query")));
             if (rangeTableEntry_used((Node *) top_subqry->cteList,
                                      PRS2_NEW_VARNO, 0) ||
                 rangeTableEntry_used((Node *) sub_qry->cteList,
                                      PRS2_NEW_VARNO, 0))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot refer to NEW within WITH query")));
  
             /*
              * For efficiency's sake, add OLD to the rule action's jointree
              * only if it was actually referenced in the statement or qual.
              *
              * For INSERT, NEW is not really a relation (only a reference to
              * the to-be-inserted tuple) and should never be added to the
              * jointree.
              *
              * For UPDATE, we treat NEW as being another kind of reference to
              * OLD, because it represents references to *transformed* tuples
              * of the existing relation.  It would be wrong to enter NEW
              * separately in the jointree, since that would cause a double
              * join of the updated relation.  It's also wrong to fail to make
              * a jointree entry if only NEW and not OLD is mentioned.
              */
             if (has_old || (has_new && stmt->event == CMD_UPDATE))
             {
                 RangeTblRef *rtr;
  
                 /*
                  * If sub_qry is a setop, manipulating its jointree will do no
                  * good at all, because the jointree is dummy. (This should be
                  * a can't-happen case because of prior tests.)
                  */
                 if (sub_qry->setOperations != NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
                 /* hackishly add OLD to the already-built FROM clause */
                 rtr = makeNode(RangeTblRef);
                 rtr->rtindex = oldnsitem->p_rtindex;
                 sub_qry->jointree->fromlist =
                     lappend(sub_qry->jointree->fromlist, rtr);
             }
  
             newactions = lappend(newactions, top_subqry);
  
             free_parsestate(sub_pstate);
         }
  
         *actions = newactions;
     }
  
     free_parsestate(pstate);
  
     /* Close relation, but keep the exclusive lock */
     table_close(rel, NoLock);
 }

References AccessExclusiveLock, AccessShareLock, generate_unaccent_rules::action, addNSItemToQuery(), addRangeTableEntryForRelation(), assign_expr_collations(), CMD_DELETE, CMD_INSERT, CMD_NOTHING, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, Query::commandType, Query::cteList, elog, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_WHERE, free_parsestate(), FromExpr::fromlist, getInsertSelectQuery(), Query::jointree, lappend(), lfirst, list_length(), list_make1, make_parsestate(), makeAlias(), makeFromExpr(), makeNode, NIL, NoLock, ParseState::p_rtable, ParseState::p_rteperminfos, ParseNamespaceItem::p_rtindex, ParseState::p_sourcetext, PRS2_NEW_VARNO, PRS2_OLD_VARNO, rangeTableEntry_used(), RelationData::rd_rel, Query::rtable, RangeTblRef::rtindex, Query::setOperations, stmt, table_close(), table_openrv(), transformStmt(), and transformWhereClause().

Referenced by DefineRule().

◆ transformStatsStmt()

CreateStatsStmt* transformStatsStmt	(	Oid	relid,
		CreateStatsStmt *	stmt,
		const char *	queryString
	)

Definition at line 3051 of file parse_utilcmd.c.

 {
     ParseState *pstate;
     ParseNamespaceItem *nsitem;
     ListCell   *l;
     Relation    rel;
  
     /* Nothing to do if statement already transformed. */
     if (stmt->transformed)
         return stmt;
  
     /* Set up pstate */
     pstate = make_parsestate(NULL);
     pstate->p_sourcetext = queryString;
  
     /*
      * Put the parent table into the rtable so that the expressions can refer
      * to its fields without qualification.  Caller is responsible for locking
      * relation, but we still need to open it.
      */
     rel = relation_open(relid, NoLock);
     nsitem = addRangeTableEntryForRelation(pstate, rel,
                                            AccessShareLock,
                                            NULL, false, true);
  
     /* no to join list, yes to namespaces */
     addNSItemToQuery(pstate, nsitem, false, true, true);
  
     /* take care of any expressions */
     foreach(l, stmt->exprs)
     {
         StatsElem  *selem = (StatsElem *) lfirst(l);
  
         if (selem->expr)
         {
             /* Now do parse transformation of the expression */
             selem->expr = transformExpr(pstate, selem->expr,
                                         EXPR_KIND_STATS_EXPRESSION);
  
             /* We have to fix its collations too */
             assign_expr_collations(pstate, selem->expr);
         }
     }
  
     /*
      * Check that only the base rel is mentioned.  (This should be dead code
      * now that add_missing_from is history.)
      */
     if (list_length(pstate->p_rtable) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("statistics expressions can refer only to the table being referenced")));
  
     free_parsestate(pstate);
  
     /* Close relation */
     table_close(rel, NoLock);
  
     /* Mark statement as successfully transformed */
     stmt->transformed = true;
  
     return stmt;
 }

References AccessShareLock, addNSItemToQuery(), addRangeTableEntryForRelation(), assign_expr_collations(), ereport, errcode(), errmsg(), ERROR, StatsElem::expr, EXPR_KIND_STATS_EXPRESSION, free_parsestate(), lfirst, list_length(), make_parsestate(), NoLock, ParseState::p_rtable, ParseState::p_sourcetext, relation_open(), stmt, table_close(), and transformExpr().

Referenced by ATPostAlterTypeParse(), and ProcessUtilitySlow().

Functions