parse_utilcmd.h File Reference

#include "parser/parse_node.h"

Include dependency graph for parse_utilcmd.h:

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

Go to the source code of this file.

Typedefs
typedef struct AttrMap	AttrMap

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 (ParseState *pstate, 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 AttrMap *attmap, Oid *constraintOid)

Typedef Documentation

AttrMap

typedef struct AttrMap AttrMap

Definition at line 19 of file parse_utilcmd.h.

Function Documentation

expandTableLikeClause()

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

extern

Definition at line 1342 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        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 = ccenforced;    /* sic */
            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, build_attrmap_by_name(), ConstrCheck::ccbin, ConstrCheck::ccenforced, ConstrCheck::ccname, ConstrCheck::ccnoinherit, TupleConstr::check, comment, Constraint::conname, 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, elog, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), generateClonedExtStatsStmt(), generateClonedIndexStmt(), get_relation_constraint_oid(), GetComment(), 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(), NameStr, NIL, nodeToString(), NoLock, TupleConstr::num_check, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OidIsValid, pstrdup(), Constraint::raw_expr, RelationData::rd_rel, relation_open(), relation_openrv(), RelationGetDescr, RelationGetIndexList(), RelationGetRelationName, RelationGetRelid, RelationGetStatExtList(), RangeVar::relname, result, RangeVar::schemaname, Constraint::skip_validation, stmt, stringToNode(), table_close(), TupleDescAttr(), and TupleDescGetDefault().

Referenced by ProcessUtilitySlow().

generateClonedIndexStmt()

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

extern

Definition at line 1690 of file parse_utilcmd.c.

{
    Oid         source_relid = RelationGetRelid(source_idx);
    HeapTuple   ht_idxrel;
    HeapTuple   ht_idx;
    HeapTuple   ht_am;
    Form_pg_class idxrelrec;
    Form_pg_index idxrec;
    Form_pg_am  amrec;
    oidvector  *indcollation;
    oidvector  *indclass;
    IndexStmt  *index;
    List       *indexprs;
    ListCell   *indexpr_item;
    Oid         indrelid;
    int         keyno;
    Oid         keycoltype;
    Datum       datum;
    bool        isnull;
 
    if (constraintOid)
        *constraintOid = InvalidOid;
 
    /*
     * Fetch pg_class tuple of source index.  We can't use the copy in the
     * relcache entry because it doesn't include optional fields.
     */
    ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(source_relid));
    if (!HeapTupleIsValid(ht_idxrel))
        elog(ERROR, "cache lookup failed for relation %u", source_relid);
    idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
 
    /* Fetch pg_index tuple for source index from relcache entry */
    ht_idx = source_idx->rd_indextuple;
    idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
    indrelid = idxrec->indrelid;
 
    /* Fetch the pg_am tuple of the index' access method */
    ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(idxrelrec->relam));
    if (!HeapTupleIsValid(ht_am))
        elog(ERROR, "cache lookup failed for access method %u",
             idxrelrec->relam);
    amrec = (Form_pg_am) GETSTRUCT(ht_am);
 
    /* Extract indcollation from the pg_index tuple */
    datum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx,
                                   Anum_pg_index_indcollation);
    indcollation = (oidvector *) DatumGetPointer(datum);
 
    /* Extract indclass from the pg_index tuple */
    datum = SysCacheGetAttrNotNull(INDEXRELID, ht_idx, Anum_pg_index_indclass);
    indclass = (oidvector *) DatumGetPointer(datum);
 
    /* Begin building the IndexStmt */
    index = makeNode(IndexStmt);
    index->relation = heapRel;
    index->accessMethod = pstrdup(NameStr(amrec->amname));
    if (OidIsValid(idxrelrec->reltablespace))
        index->tableSpace = get_tablespace_name(idxrelrec->reltablespace);
    else
        index->tableSpace = NULL;
    index->excludeOpNames = NIL;
    index->idxcomment = NULL;
    index->indexOid = InvalidOid;
    index->oldNumber = InvalidRelFileNumber;
    index->oldCreateSubid = InvalidSubTransactionId;
    index->oldFirstRelfilelocatorSubid = InvalidSubTransactionId;
    index->unique = idxrec->indisunique;
    index->nulls_not_distinct = idxrec->indnullsnotdistinct;
    index->primary = idxrec->indisprimary;
    index->iswithoutoverlaps = (idxrec->indisprimary || idxrec->indisunique) && idxrec->indisexclusion;
    index->transformed = true;  /* don't need transformIndexStmt */
    index->concurrent = false;
    index->if_not_exists = false;
    index->reset_default_tblspc = false;
 
    /*
     * We don't try to preserve the name of the source index; instead, just
     * let DefineIndex() choose a reasonable name.  (If we tried to preserve
     * the name, we'd get duplicate-relation-name failures unless the source
     * table was in a different schema.)
     */
    index->idxname = NULL;
 
    /*
     * If the index is marked PRIMARY or has an exclusion condition, it's
     * certainly from a constraint; else, if it's not marked UNIQUE, it
     * certainly isn't.  If it is or might be from a constraint, we have to
     * fetch the pg_constraint record.
     */
    if (index->primary || index->unique || idxrec->indisexclusion)
    {
        Oid         constraintId = get_index_constraint(source_relid);
 
        if (OidIsValid(constraintId))
        {
            HeapTuple   ht_constr;
            Form_pg_constraint conrec;
 
            if (constraintOid)
                *constraintOid = constraintId;
 
            ht_constr = SearchSysCache1(CONSTROID,
                                        ObjectIdGetDatum(constraintId));
            if (!HeapTupleIsValid(ht_constr))
                elog(ERROR, "cache lookup failed for constraint %u",
                     constraintId);
            conrec = (Form_pg_constraint) GETSTRUCT(ht_constr);
 
            index->isconstraint = true;
            index->deferrable = conrec->condeferrable;
            index->initdeferred = conrec->condeferred;
 
            /* If it's an exclusion constraint, we need the operator names */
            if (idxrec->indisexclusion)
            {
                Datum      *elems;
                int         nElems;
                int         i;
 
                Assert(conrec->contype == CONSTRAINT_EXCLUSION ||
                       (index->iswithoutoverlaps &&
                        (conrec->contype == CONSTRAINT_PRIMARY || conrec->contype == CONSTRAINT_UNIQUE)));
                /* Extract operator OIDs from the pg_constraint tuple */
                datum = SysCacheGetAttrNotNull(CONSTROID, ht_constr,
                                               Anum_pg_constraint_conexclop);
                deconstruct_array_builtin(DatumGetArrayTypeP(datum), OIDOID, &elems, NULL, &nElems);
 
                for (i = 0; i < nElems; i++)
                {
                    Oid         operid = DatumGetObjectId(elems[i]);
                    HeapTuple   opertup;
                    Form_pg_operator operform;
                    char       *oprname;
                    char       *nspname;
                    List       *namelist;
 
                    opertup = SearchSysCache1(OPEROID,
                                              ObjectIdGetDatum(operid));
                    if (!HeapTupleIsValid(opertup))
                        elog(ERROR, "cache lookup failed for operator %u",
                             operid);
                    operform = (Form_pg_operator) GETSTRUCT(opertup);
                    oprname = pstrdup(NameStr(operform->oprname));
                    /* For simplicity we always schema-qualify the op name */
                    nspname = get_namespace_name(operform->oprnamespace);
                    namelist = list_make2(makeString(nspname),
                                          makeString(oprname));
                    index->excludeOpNames = lappend(index->excludeOpNames,
                                                    namelist);
                    ReleaseSysCache(opertup);
                }
            }
 
            ReleaseSysCache(ht_constr);
        }
        else
            index->isconstraint = false;
    }
    else
        index->isconstraint = false;
 
    /* Get the index expressions, if any */
    datum = SysCacheGetAttr(INDEXRELID, ht_idx,
                            Anum_pg_index_indexprs, &isnull);
    if (!isnull)
    {
        char       *exprsString;
 
        exprsString = TextDatumGetCString(datum);
        indexprs = (List *) stringToNode(exprsString);
    }
    else
        indexprs = NIL;
 
    /* Build the list of IndexElem */
    index->indexParams = NIL;
    index->indexIncludingParams = NIL;
 
    indexpr_item = list_head(indexprs);
    for (keyno = 0; keyno < idxrec->indnkeyatts; keyno++)
    {
        IndexElem  *iparam;
        AttrNumber  attnum = idxrec->indkey.values[keyno];
        Form_pg_attribute attr = TupleDescAttr(RelationGetDescr(source_idx),
                                               keyno);
        int16       opt = source_idx->rd_indoption[keyno];
 
        iparam = makeNode(IndexElem);
 
        if (AttributeNumberIsValid(attnum))
        {
            /* Simple index column */
            char       *attname;
 
            attname = get_attname(indrelid, attnum, false);
            keycoltype = get_atttype(indrelid, attnum);
 
            iparam->name = attname;
            iparam->expr = NULL;
        }
        else
        {
            /* Expressional index */
            Node       *indexkey;
            bool        found_whole_row;
 
            if (indexpr_item == NULL)
                elog(ERROR, "too few entries in indexprs list");
            indexkey = (Node *) lfirst(indexpr_item);
            indexpr_item = lnext(indexprs, indexpr_item);
 
            /* Adjust Vars to match new table's column numbering */
            indexkey = map_variable_attnos(indexkey,
                                           1, 0,
                                           attmap,
                                           InvalidOid, &found_whole_row);
 
            /* As in expandTableLikeClause, reject whole-row variables */
            if (found_whole_row)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert whole-row table reference"),
                         errdetail("Index \"%s\" contains a whole-row table reference.",
                                   RelationGetRelationName(source_idx))));
 
            iparam->name = NULL;
            iparam->expr = indexkey;
 
            keycoltype = exprType(indexkey);
        }
 
        /* Copy the original index column name */
        iparam->indexcolname = pstrdup(NameStr(attr->attname));
 
        /* Add the collation name, if non-default */
        iparam->collation = get_collation(indcollation->values[keyno], keycoltype);
 
        /* Add the operator class name, if non-default */
        iparam->opclass = get_opclass(indclass->values[keyno], keycoltype);
        iparam->opclassopts =
            untransformRelOptions(get_attoptions(source_relid, keyno + 1));
 
        iparam->ordering = SORTBY_DEFAULT;
        iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
 
        /* Adjust options if necessary */
        if (source_idx->rd_indam->amcanorder)
        {
            /*
             * If it supports sort ordering, copy DESC and NULLS opts. Don't
             * set non-default settings unnecessarily, though, so as to
             * improve the chance of recognizing equivalence to constraint
             * indexes.
             */
            if (opt & INDOPTION_DESC)
            {
                iparam->ordering = SORTBY_DESC;
                if ((opt & INDOPTION_NULLS_FIRST) == 0)
                    iparam->nulls_ordering = SORTBY_NULLS_LAST;
            }
            else
            {
                if (opt & INDOPTION_NULLS_FIRST)
                    iparam->nulls_ordering = SORTBY_NULLS_FIRST;
            }
        }
 
        iparam->location = -1;
 
        index->indexParams = lappend(index->indexParams, iparam);
    }
 
    /* Handle included columns separately */
    for (keyno = idxrec->indnkeyatts; keyno < idxrec->indnatts; keyno++)
    {
        IndexElem  *iparam;
        AttrNumber  attnum = idxrec->indkey.values[keyno];
        Form_pg_attribute attr = TupleDescAttr(RelationGetDescr(source_idx),
                                               keyno);
 
        iparam = makeNode(IndexElem);
 
        if (AttributeNumberIsValid(attnum))
        {
            /* Simple index column */
            char       *attname;
 
            attname = get_attname(indrelid, attnum, false);
 
            iparam->name = attname;
            iparam->expr = NULL;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("expressions are not supported in included columns")));
 
        /* Copy the original index column name */
        iparam->indexcolname = pstrdup(NameStr(attr->attname));
 
        iparam->location = -1;
 
        index->indexIncludingParams = lappend(index->indexIncludingParams, iparam);
    }
    /* Copy reloptions if any */
    datum = SysCacheGetAttr(RELOID, ht_idxrel,
                            Anum_pg_class_reloptions, &isnull);
    if (!isnull)
        index->options = untransformRelOptions(datum);
 
    /* If it's a partial index, decompile and append the predicate */
    datum = SysCacheGetAttr(INDEXRELID, ht_idx,
                            Anum_pg_index_indpred, &isnull);
    if (!isnull)
    {
        char       *pred_str;
        Node       *pred_tree;
        bool        found_whole_row;
 
        /* Convert text string to node tree */
        pred_str = TextDatumGetCString(datum);
        pred_tree = (Node *) stringToNode(pred_str);
 
        /* Adjust Vars to match new table's column numbering */
        pred_tree = map_variable_attnos(pred_tree,
                                        1, 0,
                                        attmap,
                                        InvalidOid, &found_whole_row);
 
        /* As in expandTableLikeClause, reject whole-row variables */
        if (found_whole_row)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert whole-row table reference"),
                     errdetail("Index \"%s\" contains a whole-row table reference.",
                               RelationGetRelationName(source_idx))));
 
        index->whereClause = pred_tree;
    }
 
    /* Clean up */
    ReleaseSysCache(ht_idxrel);
    ReleaseSysCache(ht_am);
 
    return index;
}

References Assert, attname, attnum, AttributeNumberIsValid, DatumGetArrayTypeP, DatumGetObjectId(), DatumGetPointer(), deconstruct_array_builtin(), elog, ereport, errcode(), errdetail(), errmsg, ERROR, exprType(), fb(), Form_pg_am, Form_pg_constraint, Form_pg_index, Form_pg_operator, get_attname(), get_attoptions(), get_atttype(), get_collation(), get_index_constraint(), get_namespace_name(), get_opclass(), get_tablespace_name(), GETSTRUCT(), HeapTupleIsValid, i, InvalidOid, InvalidRelFileNumber, InvalidSubTransactionId, lappend(), lfirst, list_head(), list_make2, lnext(), makeNode, makeString(), map_variable_attnos(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, pstrdup(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), SearchSysCache1(), SORTBY_DEFAULT, SORTBY_DESC, SORTBY_NULLS_DEFAULT, SORTBY_NULLS_FIRST, SORTBY_NULLS_LAST, stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, TupleDescAttr(), and untransformRelOptions().

Referenced by AttachPartitionEnsureIndexes(), DefineIndex(), DefineRelation(), and expandTableLikeClause().

transformAlterTableStmt()

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

extern

Definition at line 3835 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->bound);
                    /* assign the transformed value of the partition bound */
                    partcmd->bound = cxt.partbound;
                }
 
                newcmds = lappend(newcmds, cmd);
                break;
 
            case AT_MergePartitions:
                {
                    PartitionCmd *partcmd = (PartitionCmd *) cmd->def;
 
                    if (list_length(partcmd->partlist) < 2)
                        ereport(ERROR,
                                errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                errmsg("list of partitions to be merged should include at least two partitions"));
 
                    transformPartitionCmdForMerge(&cxt, partcmd);
                    newcmds = lappend(newcmds, cmd);
                    break;
                }
 
            case AT_SplitPartition:
                {
                    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 partitions"));
 
                    transformPartitionCmdForSplit(&cxt, partcmd);
                    newcmds = lappend(newcmds, cmd);
                    break;
                }
 
            default:
 
                /*
                 * Currently, we shouldn't actually get here for the
                 * 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;
}

References AccessShareLock, addNSItemToQuery(), addRangeTableEntryForRelation(), CreateStmtContext::alist, AT_AddColumn, AT_AddConstraint, AT_AddIdentity, AT_AddIndex, AT_AddIndexConstraint, AT_AlterColumnType, AT_AttachPartition, AT_DetachPartition, AT_MergePartitions, AT_SetIdentity, AT_SplitPartition, attnum, CreateStmtContext::blist, castNode, CreateStmtContext::ckconstraints, CreateStmtContext::columns, CONSTR_FOREIGN, ColumnDef::constraints, ColumnDef::cooked_default, AlterTableCmd::def, DefElem::defname, elog, ereport, errcode(), errmsg, ERROR, EXPR_KIND_ALTER_COL_TRANSFORM, fb(), CreateStmtContext::fkconstraints, foreach_node, Constraint::generated_when, generateSerialExtraStmts(), get_attnum(), get_atttype(), get_namespace_name(), get_rel_name(), get_rel_namespace(), getIdentitySequence(), CreateStmtContext::inhRelations, InvalidAttrNumber, IsA, CreateStmtContext::isalter, CreateStmtContext::isforeign, CreateStmtContext::ispartitioned, CreateStmtContext::ixconstraints, lappend(), lfirst, lfirst_node, CreateStmtContext::likeclauses, list_concat(), list_length(), list_make1, make_parsestate(), makeDefElem(), makeNode, makeRangeVar(), makeTypeNameFromOid(), AlterTableCmd::name, NIL, CreateStmtContext::nnconstraints, nodeTag, NoLock, CreateStmtContext::ofType, OidIsValid, Constraint::options, ParseState::p_sourcetext, CreateStmtContext::partbound, CreateStmtContext::pkey, CreateStmtContext::pstate, ColumnDef::raw_default, RelationData::rd_rel, CreateStmtContext::rel, CreateStmtContext::relation, relation_close(), relation_open(), RelationGetDescr, RelationGetForm, RelationGetRelationName, stmt, CreateStmtContext::stmtType, AlterTableCmd::subtype, transformCheckConstraints(), transformColumnDefinition(), transformExpr(), transformFKConstraints(), transformIndexConstraints(), transformIndexStmt(), transformPartitionCmd(), transformPartitionCmdForMerge(), transformPartitionCmdForSplit(), transformTableConstraint(), TupleDescAttr(), ColumnDef::typeName, and typenameTypeId().

Referenced by ATParseTransformCmd(), and ATPostAlterTypeParse().

transformCreateSchemaStmtElements()

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

extern

Definition at line 4444 of file parse_utilcmd.c.

{
    List       *elements = NIL;
    List       *fk_elements = NIL;
    ListCell   *lc;
 
    /*
     * Run through each schema element in the schema element list.  Check
     * target schema names, and collect the list of actions to be done.
     */
    foreach(lc, schemaElts)
    {
        Node       *element = lfirst(lc);
 
        switch (nodeTag(element))
        {
            case T_CreateSeqStmt:
                {
                    CreateSeqStmt *elp = (CreateSeqStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->sequence);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateStmt:
                {
                    CreateStmt *elp = (CreateStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->relation);
                    /* Pull out any foreign key clauses, add to fk_elements */
                    elp = transformCreateSchemaCreateTable(pstate,
                                                           elp,
                                                           &fk_elements);
                    elements = lappend(elements, elp);
                }
                break;
 
            case T_ViewStmt:
                {
                    ViewStmt   *elp = (ViewStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->view);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_IndexStmt:
                {
                    IndexStmt  *elp = (IndexStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->relation);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateTrigStmt:
                {
                    CreateTrigStmt *elp = (CreateTrigStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->relation);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateDomainStmt:
                {
                    CreateDomainStmt *elp = (CreateDomainStmt *) element;
 
                    checkSchemaNameList(schemaName, elp->domainname);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateFunctionStmt:
                {
                    CreateFunctionStmt *elp = (CreateFunctionStmt *) element;
 
                    checkSchemaNameList(schemaName, elp->funcname);
                    elements = lappend(elements, element);
                }
                break;
 
                /*
                 * CREATE TYPE can produce a DefineStmt, but also
                 * CreateEnumStmt, CreateRangeStmt, and CompositeTypeStmt.
                 * Allowing DefineStmt also provides support for several other
                 * commands: currently, CREATE AGGREGATE, CREATE COLLATION,
                 * CREATE OPERATOR, and text search objects.
                 */
 
            case T_DefineStmt:
                {
                    DefineStmt *elp = (DefineStmt *) element;
 
                    checkSchemaNameList(schemaName, elp->defnames);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateEnumStmt:
                {
                    CreateEnumStmt *elp = (CreateEnumStmt *) element;
 
                    checkSchemaNameList(schemaName, elp->typeName);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CreateRangeStmt:
                {
                    CreateRangeStmt *elp = (CreateRangeStmt *) element;
 
                    checkSchemaNameList(schemaName, elp->typeName);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_CompositeTypeStmt:
                {
                    CompositeTypeStmt *elp = (CompositeTypeStmt *) element;
 
                    checkSchemaNameRV(pstate, schemaName, elp->typevar);
                    elements = lappend(elements, element);
                }
                break;
 
            case T_GrantStmt:
                elements = lappend(elements, element);
                break;
 
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(element));
        }
    }
 
    return list_concat(elements, fk_elements);
}

References checkSchemaNameList(), checkSchemaNameRV(), element(), elog, ERROR, fb(), lappend(), lfirst, list_concat(), NIL, nodeTag, and transformCreateSchemaCreateTable().

Referenced by CreateSchemaCommand().

transformCreateStmt()

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

extern

Definition at line 162 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;
}

References CreateStmtContext::alist, Assert, CreateStmtContext::blist, cancel_parser_errposition_callback(), checkMembershipInCurrentExtension(), CreateStmtContext::ckconstraints, CreateStmtContext::columns, element(), elog, ereport, errcode(), errmsg, ERROR, fb(), CreateStmtContext::fkconstraints, foreach_node, get_namespace_name(), CreateStmtContext::inhRelations, IsA, CreateStmtContext::isalter, CreateStmtContext::isforeign, CreateStmtContext::ispartitioned, CreateStmtContext::ixconstraints, lappend(), lfirst, CreateStmtContext::likeclauses, linitial, list_concat(), make_parsestate(), NIL, CreateStmtContext::nnconstraints, nodeTag, NoLock, NOTICE, ObjectAddressSet, CreateStmtContext::ofType, OidIsValid, ParseState::p_sourcetext, CreateStmtContext::partbound, CreateStmtContext::pkey, CreateStmtContext::pstate, RangeVarGetAndCheckCreationNamespace(), CreateStmtContext::rel, CreateStmtContext::relation, result, setup_parser_errposition_callback(), stmt, CreateStmtContext::stmtType, strVal, transformCheckConstraints(), transformColumnDefinition(), transformFKConstraints(), transformIndexConstraints(), transformOfType(), transformTableConstraint(), and transformTableLikeClause().

Referenced by ProcessUtilitySlow().

transformIndexStmt()

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

extern

Definition at line 3062 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)
        {
            /* 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.
             */
        }
    }
 
    /*
     * Likewise take care of any expressions in INCLUDING.  (At this writing,
     * those will be rejected later on, but probably someday we'll wish to
     * support them.)
     */
    foreach(l, stmt->indexIncludingParams)
    {
        IndexElem  *ielem = (IndexElem *) lfirst(l);
 
        if (ielem->expr)
        {
            /* 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);
        }
    }
 
    /*
     * 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, fb(), free_parsestate(), 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  )

extern

Definition at line 4859 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(), fb(), get_attname(), get_partition_col_collation(), get_partition_col_typid(), get_partition_col_typmod(), get_partition_exprs(), get_partition_natts(), get_partition_strategy(), lappend(), lfirst, lfirst_node, linitial, list_length(), NIL, parser_errposition(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, RelationGetPartitionKey(), RelationGetRelationName, RelationGetRelid, transformPartitionBoundValue(), transformPartitionRangeBounds(), and value.

Referenced by DefineRelation(), and transformPartitionCmd().

transformRuleStmt()

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

extern

Definition at line 3248 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, addNSItemToQuery(), addRangeTableEntryForRelation(), assign_expr_collations(), CMD_DELETE, CMD_INSERT, CMD_NOTHING, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, elog, ereport, errcode(), errmsg, ERROR, EXPR_KIND_WHERE, fb(), free_parsestate(), getInsertSelectQuery(), lappend(), lfirst, list_length(), list_make1, make_parsestate(), makeAlias(), makeFromExpr(), makeNode, NIL, NoLock, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_sourcetext, PRS2_NEW_VARNO, PRS2_OLD_VARNO, rangeTableEntry_used(), RelationData::rd_rel, stmt, table_close(), table_openrv(), transformStmt(), and transformWhereClause().

Referenced by DefineRule().

transformStatsStmt()

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

extern

Definition at line 3173 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, fb(), 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().