#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 1322 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;
 
    /*
     * 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        ccenforced = constr->check[ccnum].ccenforced;
            bool        ccvalid = constr->check[ccnum].ccvalid;
            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_enforced = ccenforced;
            n->initially_valid = ccvalid;
            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;
 
            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);
            }
        }
    }
 
    /*
     * 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);
    }
 
    /*
     * Process indexes if required.
     */
    if ((table_like_clause->options & CREATE_TABLE_LIKE_INDEXES) &&
        relation->rd_rel->relhasindex &&
        childrel->rd_rel->relkind != RELKIND_FOREIGN_TABLE)
    {
        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);
 
            /* 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);
        }
    }
 
    /*
     * Process extended statistics if required.
     */
    if (table_like_clause->options & CREATE_TABLE_LIKE_STATISTICS)
    {
        List       *parent_extstats;
        ListCell   *l;
 
        parent_extstats = RelationGetStatExtList(relation);
 
        foreach(l, parent_extstats)
        {
            Oid         parent_stat_oid = lfirst_oid(l);
            CreateStatsStmt *stats_stmt;
 
            stats_stmt = generateClonedExtStatsStmt(heapRel,
                                                    RelationGetRelid(childrel),
                                                    parent_stat_oid,
                                                    attmap);
 
            /* Copy comment on statistics object, if requested */
            if (table_like_clause->options & CREATE_TABLE_LIKE_COMMENTS)
            {
                comment = GetComment(parent_stat_oid, StatisticExtRelationId, 0);
 
                /*
                 * We make use of CreateStatsStmt's stxcomment option, so as
                 * not to need to know now what name the statistics will have.
                 */
                stats_stmt->stxcomment = comment;
            }
 
            result = lappend(result, stats_stmt);
        }
 
        list_free(parent_extstats);
    }
 
    /* 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, AttrMap::attnums, build_attrmap_by_name(), ConstrCheck::ccbin, ConstrCheck::ccenforced, ConstrCheck::ccname, ConstrCheck::ccnoinherit, ConstrCheck::ccvalid, 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, CREATE_TABLE_LIKE_STATISTICS, AlterTableCmd::def, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, generateClonedExtStatsStmt(), generateClonedIndexStmt(), get_relation_constraint_oid(), GetComment(), IndexStmt::idxcomment, index_close(), index_open(), Constraint::initially_valid, InvalidOid, Constraint::is_enforced, Constraint::is_no_inherit, lappend(), lcons(), lfirst_oid, list_free(), list_make3, Constraint::location, makeNode, makeString(), map_variable_attnos(), AlterTableStmt::missing_ok, NameStr, TupleDescData::natts, NIL, nodeToString(), NoLock, AlterTableCmd::num, TupleConstr::num_check, OBJECT_TABCONSTRAINT, OBJECT_TABLE, AlterTableStmt::objtype, OidIsValid, TableLikeClause::options, pstrdup(), Constraint::raw_expr, RelationData::rd_rel, AlterTableStmt::relation, relation_open(), relation_openrv(), RelationGetDescr, RelationGetIndexList(), RelationGetRelationName, RelationGetRelid, RelationGetStatExtList(), TableLikeClause::relationOid, RangeVar::relname, RangeVar::schemaname, Constraint::skip_validation, stmt, stringToNode(), CreateStatsStmt::stxcomment, 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 3504 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.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. Identity sequence
                     * is associated with the top level partitioned table.
                     * Hence ignore partitions.
                     */
                    if (!RelationGetForm(rel)->relispartition)
                    {
                        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(rel, 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(rel, 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);
                    /* assign transformed value of the partition bound */
                    partcmd->bound = cxt.partbound;
                }
 
                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 generated
         * from primary key constraints.
         */
        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
            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_node(Constraint, def, cxt.ckconstraints)
    {
        newcmd = makeNode(AlterTableCmd);
        newcmd->subtype = AT_AddConstraint;
        newcmd->def = (Node *) def;
        newcmds = lappend(newcmds, newcmd);
    }
    foreach_node(Constraint, def, cxt.nnconstraints)
    {
        newcmd = makeNode(AlterTableCmd);
        newcmd->subtype = AT_AddConstraint;
        newcmd->def = (Node *) def;
        newcmds = lappend(newcmds, newcmd);
    }
    foreach_node(Constraint, def, cxt.fkconstraints)
    {
        newcmd = makeNode(AlterTableCmd);
        newcmd->subtype = AT_AddConstraint;
        newcmd->def = (Node *) def;
        newcmds = lappend(newcmds, newcmd);
    }
 
    /* 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 4081 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 164 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.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);
 
    /*
     * Before processing index constraints, which could include a primary key,
     * we must scan all not-null constraints to propagate the is_not_null flag
     * to each corresponding ColumnDef.  This is necessary because table-level
     * not-null constraints have not been marked in each ColumnDef, and the PK
     * processing code needs to know whether one constraint has already been
     * declared in order not to declare a redundant one.
     */
    foreach_node(Constraint, nn, cxt.nnconstraints)
    {
        char       *colname = strVal(linitial(nn->keys));
 
        foreach_node(ColumnDef, cd, cxt.columns)
        {
            /* not our column? */
            if (strcmp(cd->colname, colname) != 0)
                continue;
            /* Already marked not-null? Nothing to do */
            if (cd->is_not_null)
                break;
            /* Bingo, we're done for this constraint */
            cd->is_not_null = true;
            break;
        }
    }
 
    /*
     * 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);
 
    /*
     * 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 3028 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 4257 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 3198 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 3123 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