#include "postgres.h"
#include "access/amapi.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/reloptions.h"
#include "access/table.h"
#include "access/toast_compression.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/partition.h"
#include "catalog/pg_am.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_type.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/sequence.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/analyze.h"
#include "parser/parse_clause.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parse_utilcmd.h"
#include "parser/parser.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
#include "rewrite/rewriteManip.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/partcache.h"
#include "utils/rel.h"
#include "utils/ruleutils.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for parse_utilcmd.c:

Data Structures
struct	CreateStmtContext

struct	CreateSchemaStmtContext

Macros
#define	SUPPORTS_ATTRS(node)

Functions
static void	transformColumnDefinition (CreateStmtContext cxt, ColumnDef column)

static void	transformTableConstraint (CreateStmtContext cxt, Constraint constraint)

static void	transformTableLikeClause (CreateStmtContext cxt, TableLikeClause table_like_clause)

static void	transformOfType (CreateStmtContext cxt, TypeName ofTypename)

static CreateStatsStmt *	generateClonedExtStatsStmt (RangeVar heapRel, Oid heapRelid, Oid source_statsid, const AttrMap attmap)

static List *	get_collation (Oid collation, Oid actual_datatype)

static List *	get_opclass (Oid opclass, Oid actual_datatype)

static void	transformIndexConstraints (CreateStmtContext *cxt)

static IndexStmt *	transformIndexConstraint (Constraint constraint, CreateStmtContext cxt)

static void	transformFKConstraints (CreateStmtContext *cxt, bool skipValidation, bool isAddConstraint)

static void	transformCheckConstraints (CreateStmtContext *cxt, bool skipValidation)

static void	transformConstraintAttrs (CreateStmtContext cxt, List constraintList)

static void	transformColumnType (CreateStmtContext cxt, ColumnDef column)

static void	setSchemaName (const char context_schema, char *stmt_schema_name)

static void	transformPartitionCmd (CreateStmtContext cxt, PartitionBoundSpec bound)

static List *	transformPartitionRangeBounds (ParseState pstate, List blist, Relation parent)

static void	validateInfiniteBounds (ParseState pstate, List blist)

static Const *	transformPartitionBoundValue (ParseState pstate, Node val, const char *colName, Oid colType, int32 colTypmod, Oid partCollation)

List *	transformCreateStmt (CreateStmt stmt, const char queryString)

static void	generateSerialExtraStmts (CreateStmtContext cxt, ColumnDef column, Oid seqtypid, List seqoptions, bool for_identity, bool col_exists, char snamespace_p, char *sname_p)

List *	expandTableLikeClause (RangeVar heapRel, TableLikeClause table_like_clause)

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

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)

static void	checkPartition (Relation rel, Oid partRelOid, bool isMerge)

static void	transformPartitionCmdForSplit (CreateStmtContext cxt, PartitionCmd partcmd)

static void	transformPartitionCmdForMerge (CreateStmtContext cxt, PartitionCmd partcmd)

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

List *	transformCreateSchemaStmtElements (List schemaElts, const char schemaName)

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

Macro Definition Documentation

◆ SUPPORTS_ATTRS

#define SUPPORTS_ATTRS ( node )

Value:

    ((node) != NULL &&                      \
     ((node)->contype == CONSTR_PRIMARY ||  \
      (node)->contype == CONSTR_UNIQUE ||   \
      (node)->contype == CONSTR_EXCLUSION || \
      (node)->contype == CONSTR_FOREIGN))

Function Documentation

◆ checkPartition()

static void checkPartition	(	Relation	rel,
		Oid	partRelOid,
		bool	isMerge
	)

static

Definition at line 3528 of file parse_utilcmd.c.

{
    Relation    partRel;
 
    partRel = table_open(partRelOid, NoLock);
 
    if (partRel->rd_rel->relkind != RELKIND_RELATION)
        ereport(ERROR,
                errcode(ERRCODE_WRONG_OBJECT_TYPE),
                errmsg("\"%s\" is not a table", RelationGetRelationName(partRel)),
                isMerge
                ? errhint("ALTER TABLE ... MERGE PARTITIONS can only merge partitions don't have sub-partitions")
                : errhint("ALTER TABLE ... SPLIT PARTITION can only split partitions don't have sub-partitions"));
 
    if (!partRel->rd_rel->relispartition)
        ereport(ERROR,
                errcode(ERRCODE_WRONG_OBJECT_TYPE),
                errmsg("\"%s\" is not a partition of partitioned table \"%s\"",
                       RelationGetRelationName(partRel), RelationGetRelationName(rel)),
                isMerge
                ? errhint("ALTER TABLE ... MERGE PARTITIONS can only merge partitions don't have sub-partitions")
                : errhint("ALTER TABLE ... SPLIT PARTITION can only split partitions don't have sub-partitions"));
 
    if (get_partition_parent(partRelOid, false) != RelationGetRelid(rel))
        ereport(ERROR,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("relation \"%s\" is not a partition of relation \"%s\"",
                       RelationGetRelationName(partRel), RelationGetRelationName(rel)),
                isMerge
                ? errhint("ALTER TABLE ... MERGE PARTITIONS can only merge partitions don't have sub-partitions")
                : errhint("ALTER TABLE ... SPLIT PARTITION can only split partitions don't have sub-partitions"));
 
    table_close(partRel, NoLock);
}

References ereport, errcode(), errhint(), errmsg(), ERROR, fb(), get_partition_parent(), NoLock, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, table_close(), and table_open().

Referenced by transformPartitionCmdForMerge(), and transformPartitionCmdForSplit().

◆ expandTableLikeClause()

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

Definition at line 1347 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, RangeVar::schemaname, Constraint::skip_validation, stmt, stringToNode(), table_close(), TupleDescAttr(), and TupleDescGetDefault().

Referenced by ProcessUtilitySlow().

◆ generateClonedExtStatsStmt()

static CreateStatsStmt * generateClonedExtStatsStmt	(	RangeVar *	heapRel,
		Oid	heapRelid,
		Oid	source_statsid,
		const AttrMap *	attmap
	)

static

Definition at line 2053 of file parse_utilcmd.c.

{
    HeapTuple   ht_stats;
    Form_pg_statistic_ext statsrec;
    CreateStatsStmt *stats;
    List       *stat_types = NIL;
    List       *def_names = NIL;
    bool        isnull;
    Datum       datum;
    ArrayType  *arr;
    char       *enabled;
    int         i;
 
    Assert(OidIsValid(heapRelid));
    Assert(heapRel != NULL);
 
    /*
     * Fetch pg_statistic_ext tuple of source statistics object.
     */
    ht_stats = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(source_statsid));
    if (!HeapTupleIsValid(ht_stats))
        elog(ERROR, "cache lookup failed for statistics object %u", source_statsid);
    statsrec = (Form_pg_statistic_ext) GETSTRUCT(ht_stats);
 
    /* Determine which statistics types exist */
    datum = SysCacheGetAttrNotNull(STATEXTOID, ht_stats,
                                   Anum_pg_statistic_ext_stxkind);
    arr = DatumGetArrayTypeP(datum);
    if (ARR_NDIM(arr) != 1 ||
        ARR_HASNULL(arr) ||
        ARR_ELEMTYPE(arr) != CHAROID)
        elog(ERROR, "stxkind is not a 1-D char array");
    enabled = (char *) ARR_DATA_PTR(arr);
    for (i = 0; i < ARR_DIMS(arr)[0]; i++)
    {
        if (enabled[i] == STATS_EXT_NDISTINCT)
            stat_types = lappend(stat_types, makeString("ndistinct"));
        else if (enabled[i] == STATS_EXT_DEPENDENCIES)
            stat_types = lappend(stat_types, makeString("dependencies"));
        else if (enabled[i] == STATS_EXT_MCV)
            stat_types = lappend(stat_types, makeString("mcv"));
        else if (enabled[i] == STATS_EXT_EXPRESSIONS)
            /* expression stats are not exposed to users */
            continue;
        else
            elog(ERROR, "unrecognized statistics kind %c", enabled[i]);
    }
 
    /* Determine which columns the statistics are on */
    for (i = 0; i < statsrec->stxkeys.dim1; i++)
    {
        StatsElem  *selem = makeNode(StatsElem);
        AttrNumber  attnum = statsrec->stxkeys.values[i];
 
        selem->name = get_attname(heapRelid, attnum, false);
        selem->expr = NULL;
 
        def_names = lappend(def_names, selem);
    }
 
    /*
     * Now handle expressions, if there are any. The order (with respect to
     * regular attributes) does not really matter for extended stats, so we
     * simply append them after simple column references.
     *
     * XXX Some places during build/estimation treat expressions as if they
     * are before attributes, but for the CREATE command that's entirely
     * irrelevant.
     */
    datum = SysCacheGetAttr(STATEXTOID, ht_stats,
                            Anum_pg_statistic_ext_stxexprs, &isnull);
 
    if (!isnull)
    {
        ListCell   *lc;
        List       *exprs = NIL;
        char       *exprsString;
 
        exprsString = TextDatumGetCString(datum);
        exprs = (List *) stringToNode(exprsString);
 
        foreach(lc, exprs)
        {
            Node       *expr = (Node *) lfirst(lc);
            StatsElem  *selem = makeNode(StatsElem);
            bool        found_whole_row;
 
            /* Adjust Vars to match new table's column numbering */
            expr = map_variable_attnos(expr,
                                       1, 0,
                                       attmap,
                                       InvalidOid,
                                       &found_whole_row);
 
            selem->name = NULL;
            selem->expr = expr;
 
            def_names = lappend(def_names, selem);
        }
 
        pfree(exprsString);
    }
 
    /* finally, build the output node */
    stats = makeNode(CreateStatsStmt);
    stats->defnames = NULL;
    stats->stat_types = stat_types;
    stats->exprs = def_names;
    stats->relations = list_make1(heapRel);
    stats->stxcomment = NULL;
    stats->transformed = true;  /* don't need transformStatsStmt again */
    stats->if_not_exists = false;
 
    /* Clean up */
    ReleaseSysCache(ht_stats);
 
    return stats;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert, attnum, DatumGetArrayTypeP, CreateStatsStmt::defnames, elog, ERROR, CreateStatsStmt::exprs, fb(), get_attname(), GETSTRUCT(), HeapTupleIsValid, i, CreateStatsStmt::if_not_exists, InvalidOid, lappend(), lfirst, list_make1, makeNode, makeString(), map_variable_attnos(), NIL, ObjectIdGetDatum(), OidIsValid, pfree(), CreateStatsStmt::relations, ReleaseSysCache(), SearchSysCache1(), CreateStatsStmt::stat_types, stringToNode(), CreateStatsStmt::stxcomment, SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, and CreateStatsStmt::transformed.

Referenced by expandTableLikeClause().

◆ generateClonedIndexStmt()

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

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

◆ generateSerialExtraStmts()

static void generateSerialExtraStmts	(	CreateStmtContext *	cxt,
		ColumnDef *	column,
		Oid	seqtypid,
		List *	seqoptions,
		bool	for_identity,
		bool	col_exists,
		char **	snamespace_p,
		char **	sname_p
	)

static

Definition at line 393 of file parse_utilcmd.c.

{
    ListCell   *option;
    DefElem    *nameEl = NULL;
    DefElem    *loggedEl = NULL;
    Oid         snamespaceid;
    char       *snamespace;
    char       *sname;
    char        seqpersistence;
    CreateSeqStmt *seqstmt;
    AlterSeqStmt *altseqstmt;
    List       *attnamelist;
 
    /* Make a copy of this as we may end up modifying it in the code below */
    seqoptions = list_copy(seqoptions);
 
    /*
     * Check for non-SQL-standard options (not supported within CREATE
     * SEQUENCE, because they'd be redundant), and remove them from the
     * seqoptions list if found.
     */
    foreach(option, seqoptions)
    {
        DefElem    *defel = lfirst_node(DefElem, option);
 
        if (strcmp(defel->defname, "sequence_name") == 0)
        {
            if (nameEl)
                errorConflictingDefElem(defel, cxt->pstate);
            nameEl = defel;
            seqoptions = foreach_delete_current(seqoptions, option);
        }
        else if (strcmp(defel->defname, "logged") == 0 ||
                 strcmp(defel->defname, "unlogged") == 0)
        {
            if (loggedEl)
                errorConflictingDefElem(defel, cxt->pstate);
            loggedEl = defel;
            seqoptions = foreach_delete_current(seqoptions, option);
        }
    }
 
    /*
     * Determine namespace and name to use for the sequence.
     */
    if (nameEl)
    {
        /* Use specified name */
        RangeVar   *rv = makeRangeVarFromNameList(castNode(List, nameEl->arg));
 
        snamespace = rv->schemaname;
        if (!snamespace)
        {
            /* Given unqualified SEQUENCE NAME, select namespace */
            if (cxt->rel)
                snamespaceid = RelationGetNamespace(cxt->rel);
            else
                snamespaceid = RangeVarGetCreationNamespace(cxt->relation);
            snamespace = get_namespace_name(snamespaceid);
        }
        sname = rv->relname;
    }
    else
    {
        /*
         * Generate a name.
         *
         * Although we use ChooseRelationName, it's not guaranteed that the
         * selected sequence name won't conflict; given sufficiently long
         * field names, two different serial columns in the same table could
         * be assigned the same sequence name, and we'd not notice since we
         * aren't creating the sequence quite yet.  In practice this seems
         * quite unlikely to be a problem, especially since few people would
         * need two serial columns in one table.
         */
        if (cxt->rel)
            snamespaceid = RelationGetNamespace(cxt->rel);
        else
        {
            snamespaceid = RangeVarGetCreationNamespace(cxt->relation);
            RangeVarAdjustRelationPersistence(cxt->relation, snamespaceid);
        }
        snamespace = get_namespace_name(snamespaceid);
        sname = ChooseRelationName(cxt->relation->relname,
                                   column->colname,
                                   "seq",
                                   snamespaceid,
                                   false);
    }
 
    ereport(DEBUG1,
            (errmsg_internal("%s will create implicit sequence \"%s\" for serial column \"%s.%s\"",
                             cxt->stmtType, sname,
                             cxt->relation->relname, column->colname)));
 
    /*
     * Determine the persistence of the sequence.  By default we copy the
     * persistence of the table, but if LOGGED or UNLOGGED was specified, use
     * that (as long as the table isn't TEMP).
     *
     * For CREATE TABLE, we get the persistence from cxt->relation, which
     * comes from the CreateStmt in progress.  For ALTER TABLE, the parser
     * won't set cxt->relation->relpersistence, but we have cxt->rel as the
     * existing table, so we copy the persistence from there.
     */
    seqpersistence = cxt->rel ? cxt->rel->rd_rel->relpersistence : cxt->relation->relpersistence;
    if (loggedEl)
    {
        if (seqpersistence == RELPERSISTENCE_TEMP)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("cannot set logged status of a temporary sequence"),
                     parser_errposition(cxt->pstate, loggedEl->location)));
        else if (strcmp(loggedEl->defname, "logged") == 0)
            seqpersistence = RELPERSISTENCE_PERMANENT;
        else
            seqpersistence = RELPERSISTENCE_UNLOGGED;
    }
 
    /*
     * Build a CREATE SEQUENCE command to create the sequence object, and add
     * it to the list of things to be done before this CREATE/ALTER TABLE.
     */
    seqstmt = makeNode(CreateSeqStmt);
    seqstmt->for_identity = for_identity;
    seqstmt->sequence = makeRangeVar(snamespace, sname, -1);
    seqstmt->sequence->relpersistence = seqpersistence;
    seqstmt->options = seqoptions;
 
    /*
     * If a sequence data type was specified, add it to the options.  Prepend
     * to the list rather than append; in case a user supplied their own AS
     * clause, the "redundant options" error will point to their occurrence,
     * not our synthetic one.
     */
    if (seqtypid)
        seqstmt->options = lcons(makeDefElem("as",
                                             (Node *) makeTypeNameFromOid(seqtypid, -1),
                                             -1),
                                 seqstmt->options);
 
    /*
     * If this is ALTER ADD COLUMN, make sure the sequence will be owned by
     * the table's owner.  The current user might be someone else (perhaps a
     * superuser, or someone who's only a member of the owning role), but the
     * SEQUENCE OWNED BY mechanisms will bleat unless table and sequence have
     * exactly the same owning role.
     */
    if (cxt->rel)
        seqstmt->ownerId = cxt->rel->rd_rel->relowner;
    else
        seqstmt->ownerId = InvalidOid;
 
    cxt->blist = lappend(cxt->blist, seqstmt);
 
    /*
     * Store the identity sequence name that we decided on.  ALTER TABLE ...
     * ADD COLUMN ... IDENTITY needs this so that it can fill the new column
     * with values from the sequence, while the association of the sequence
     * with the table is not set until after the ALTER TABLE.
     */
    column->identitySequence = seqstmt->sequence;
 
    /*
     * Build an ALTER SEQUENCE ... OWNED BY command to mark the sequence as
     * owned by this column, and add it to the appropriate list of things to
     * be done along with this CREATE/ALTER TABLE.  In a CREATE or ALTER ADD
     * COLUMN, it must be done after the statement because we don't know the
     * column's attnum yet.  But if we do have the attnum (in AT_AddIdentity),
     * we can do the marking immediately, which improves some ALTER TABLE
     * behaviors.
     */
    altseqstmt = makeNode(AlterSeqStmt);
    altseqstmt->sequence = makeRangeVar(snamespace, sname, -1);
    attnamelist = list_make3(makeString(snamespace),
                             makeString(cxt->relation->relname),
                             makeString(column->colname));
    altseqstmt->options = list_make1(makeDefElem("owned_by",
                                                 (Node *) attnamelist, -1));
    altseqstmt->for_identity = for_identity;
 
    if (col_exists)
        cxt->blist = lappend(cxt->blist, altseqstmt);
    else
        cxt->alist = lappend(cxt->alist, altseqstmt);
 
    if (snamespace_p)
        *snamespace_p = snamespace;
    if (sname_p)
        *sname_p = sname;
}

References CreateStmtContext::alist, CreateStmtContext::blist, castNode, ChooseRelationName(), DEBUG1, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, errorConflictingDefElem(), fb(), foreach_delete_current, get_namespace_name(), InvalidOid, lappend(), lcons(), lfirst_node, list_copy(), list_make1, list_make3, makeDefElem(), makeNode, makeRangeVar(), makeRangeVarFromNameList(), makeString(), makeTypeNameFromOid(), parser_errposition(), CreateStmtContext::pstate, RangeVarAdjustRelationPersistence(), RangeVarGetCreationNamespace(), RelationData::rd_rel, CreateStmtContext::rel, CreateStmtContext::relation, RelationGetNamespace, RangeVar::relname, RangeVar::relpersistence, RangeVar::schemaname, and CreateStmtContext::stmtType.

Referenced by transformAlterTableStmt(), transformColumnDefinition(), and transformTableLikeClause().

◆ get_collation()

static List * get_collation	(	Oid	collation,
		Oid	actual_datatype
	)

static

Definition at line 2180 of file parse_utilcmd.c.

{
    List       *result;
    HeapTuple   ht_coll;
    Form_pg_collation coll_rec;
    char       *nsp_name;
    char       *coll_name;
 
    if (!OidIsValid(collation))
        return NIL;             /* easy case */
    if (collation == get_typcollation(actual_datatype))
        return NIL;             /* just let it default */
 
    ht_coll = SearchSysCache1(COLLOID, ObjectIdGetDatum(collation));
    if (!HeapTupleIsValid(ht_coll))
        elog(ERROR, "cache lookup failed for collation %u", collation);
    coll_rec = (Form_pg_collation) GETSTRUCT(ht_coll);
 
    /* For simplicity, we always schema-qualify the name */
    nsp_name = get_namespace_name(coll_rec->collnamespace);
    coll_name = pstrdup(NameStr(coll_rec->collname));
    result = list_make2(makeString(nsp_name), makeString(coll_name));
 
    ReleaseSysCache(ht_coll);
    return result;
}

References elog, ERROR, fb(), get_namespace_name(), get_typcollation(), GETSTRUCT(), HeapTupleIsValid, list_make2, makeString(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, pstrdup(), ReleaseSysCache(), and SearchSysCache1().

Referenced by generateClonedIndexStmt().

◆ get_opclass()

static List * get_opclass	(	Oid	opclass,
		Oid	actual_datatype
	)

static

Definition at line 2214 of file parse_utilcmd.c.

{
    List       *result = NIL;
    HeapTuple   ht_opc;
    Form_pg_opclass opc_rec;
 
    ht_opc = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(ht_opc))
        elog(ERROR, "cache lookup failed for opclass %u", opclass);
    opc_rec = (Form_pg_opclass) GETSTRUCT(ht_opc);
 
    if (GetDefaultOpClass(actual_datatype, opc_rec->opcmethod) != opclass)
    {
        /* For simplicity, we always schema-qualify the name */
        char       *nsp_name = get_namespace_name(opc_rec->opcnamespace);
        char       *opc_name = pstrdup(NameStr(opc_rec->opcname));
 
        result = list_make2(makeString(nsp_name), makeString(opc_name));
    }
 
    ReleaseSysCache(ht_opc);
    return result;
}

References elog, ERROR, fb(), get_namespace_name(), GetDefaultOpClass(), GETSTRUCT(), HeapTupleIsValid, list_make2, makeString(), NameStr, NIL, ObjectIdGetDatum(), pstrdup(), ReleaseSysCache(), and SearchSysCache1().

Referenced by generateClonedIndexStmt().

◆ setSchemaName()

static void setSchemaName	(	const char *	context_schema,
		char **	stmt_schema_name
	)

static

Definition at line 4524 of file parse_utilcmd.c.

{
    if (*stmt_schema_name == NULL)
        *stmt_schema_name = unconstify(char *, context_schema);
    else if (strcmp(context_schema, *stmt_schema_name) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_SCHEMA_DEFINITION),
                 errmsg("CREATE specifies a schema (%s) "
                        "different from the one being created (%s)",
                        *stmt_schema_name, context_schema)));
}

References ereport, errcode(), errmsg(), ERROR, fb(), and unconstify.

Referenced by transformCreateSchemaStmtElements().

◆ transformAlterTableStmt()

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

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

Referenced by ATParseTransformCmd(), and ATPostAlterTypeParse().

◆ transformCheckConstraints()

static void transformCheckConstraints	(	CreateStmtContext *	cxt,
		bool	skipValidation
	)

static

Definition at line 2954 of file parse_utilcmd.c.

{
    ListCell   *ckclist;
 
    if (cxt->ckconstraints == NIL)
        return;
 
    /*
     * When creating a new table (but not a foreign table), we can safely skip
     * the validation of check constraints and mark them as valid based on the
     * constraint enforcement flag, since NOT ENFORCED constraints must always
     * be marked as NOT VALID. (This will override any user-supplied NOT VALID
     * flag.)
     */
    if (skipValidation)
    {
        foreach(ckclist, cxt->ckconstraints)
        {
            Constraint *constraint = (Constraint *) lfirst(ckclist);
 
            constraint->skip_validation = true;
            constraint->initially_valid = constraint->is_enforced;
        }
    }
}

References CreateStmtContext::ckconstraints, fb(), Constraint::initially_valid, Constraint::is_enforced, lfirst, NIL, and Constraint::skip_validation.

Referenced by transformAlterTableStmt(), and transformCreateStmt().

◆ transformColumnDefinition()

static void transformColumnDefinition	(	CreateStmtContext *	cxt,
		ColumnDef *	column
	)

static

Definition at line 594 of file parse_utilcmd.c.

{
    bool        is_serial;
    bool        saw_nullable;
    bool        saw_default;
    bool        saw_identity;
    bool        saw_generated;
    bool        need_notnull = false;
    bool        disallow_noinherit_notnull = false;
    Constraint *notnull_constraint = NULL;
 
    cxt->columns = lappend(cxt->columns, column);
 
    /* Check for SERIAL pseudo-types */
    is_serial = false;
    if (column->typeName
        && list_length(column->typeName->names) == 1
        && !column->typeName->pct_type)
    {
        char       *typname = strVal(linitial(column->typeName->names));
 
        if (strcmp(typname, "smallserial") == 0 ||
            strcmp(typname, "serial2") == 0)
        {
            is_serial = true;
            column->typeName->names = NIL;
            column->typeName->typeOid = INT2OID;
        }
        else if (strcmp(typname, "serial") == 0 ||
                 strcmp(typname, "serial4") == 0)
        {
            is_serial = true;
            column->typeName->names = NIL;
            column->typeName->typeOid = INT4OID;
        }
        else if (strcmp(typname, "bigserial") == 0 ||
                 strcmp(typname, "serial8") == 0)
        {
            is_serial = true;
            column->typeName->names = NIL;
            column->typeName->typeOid = INT8OID;
        }
 
        /*
         * We have to reject "serial[]" explicitly, because once we've set
         * typeid, LookupTypeName won't notice arrayBounds.  We don't need any
         * special coding for serial(typmod) though.
         */
        if (is_serial && column->typeName->arrayBounds != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("array of serial is not implemented"),
                     parser_errposition(cxt->pstate,
                                        column->typeName->location)));
    }
 
    /* Do necessary work on the column type declaration */
    if (column->typeName)
        transformColumnType(cxt, column);
 
    /* Special actions for SERIAL pseudo-types */
    if (is_serial)
    {
        char       *snamespace;
        char       *sname;
        char       *qstring;
        A_Const    *snamenode;
        TypeCast   *castnode;
        FuncCall   *funccallnode;
        Constraint *constraint;
 
        generateSerialExtraStmts(cxt, column,
                                 column->typeName->typeOid, NIL,
                                 false, false,
                                 &snamespace, &sname);
 
        /*
         * Create appropriate constraints for SERIAL.  We do this in full,
         * rather than shortcutting, so that we will detect any conflicting
         * constraints the user wrote (like a different DEFAULT).
         *
         * Create an expression tree representing the function call
         * nextval('sequencename').  We cannot reduce the raw tree to cooked
         * form until after the sequence is created, but there's no need to do
         * so.
         */
        qstring = quote_qualified_identifier(snamespace, sname);
        snamenode = makeNode(A_Const);
        snamenode->val.node.type = T_String;
        snamenode->val.sval.sval = qstring;
        snamenode->location = -1;
        castnode = makeNode(TypeCast);
        castnode->typeName = SystemTypeName("regclass");
        castnode->arg = (Node *) snamenode;
        castnode->location = -1;
        funccallnode = makeFuncCall(SystemFuncName("nextval"),
                                    list_make1(castnode),
                                    COERCE_EXPLICIT_CALL,
                                    -1);
        constraint = makeNode(Constraint);
        constraint->contype = CONSTR_DEFAULT;
        constraint->location = -1;
        constraint->raw_expr = (Node *) funccallnode;
        constraint->cooked_expr = NULL;
        column->constraints = lappend(column->constraints, constraint);
 
        /* have a not-null constraint added later */
        need_notnull = true;
        disallow_noinherit_notnull = true;
    }
 
    /* Process column constraints, if any... */
    transformConstraintAttrs(cxt, column->constraints);
 
    /*
     * First, scan the column's constraints to see if a not-null constraint
     * that we add must be prevented from being NO INHERIT.  This should be
     * enforced only for PRIMARY KEY, not IDENTITY or SERIAL.  However, if the
     * not-null constraint is specified as a table constraint rather than as a
     * column constraint, AddRelationNotNullConstraints would raise an error
     * if a NO INHERIT mismatch is found.  To avoid inconsistently disallowing
     * it in the table constraint case but not the column constraint case, we
     * disallow it here as well.  Maybe AddRelationNotNullConstraints can be
     * improved someday, so that it doesn't complain, and then we can remove
     * the restriction for SERIAL and IDENTITY here as well.
     */
    if (!disallow_noinherit_notnull)
    {
        foreach_node(Constraint, constraint, column->constraints)
        {
            switch (constraint->contype)
            {
                case CONSTR_IDENTITY:
                case CONSTR_PRIMARY:
                    disallow_noinherit_notnull = true;
                    break;
                default:
                    break;
            }
        }
    }
 
    /* Now scan them again to do full processing */
    saw_nullable = false;
    saw_default = false;
    saw_identity = false;
    saw_generated = false;
 
    foreach_node(Constraint, constraint, column->constraints)
    {
        switch (constraint->contype)
        {
            case CONSTR_NULL:
                if ((saw_nullable && column->is_not_null) || need_notnull)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
                                    column->colname, cxt->relation->relname),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                column->is_not_null = false;
                saw_nullable = true;
                break;
 
            case CONSTR_NOTNULL:
                if (cxt->ispartitioned && constraint->is_no_inherit)
                    ereport(ERROR,
                            errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            errmsg("not-null constraints on partitioned tables cannot be NO INHERIT"));
 
                /* Disallow conflicting [NOT] NULL markings */
                if (saw_nullable && !column->is_not_null)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
                                    column->colname, cxt->relation->relname),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
 
                if (disallow_noinherit_notnull && constraint->is_no_inherit)
                    ereport(ERROR,
                            errcode(ERRCODE_SYNTAX_ERROR),
                            errmsg("conflicting NO INHERIT declarations for not-null constraints on column \"%s\"",
                                   column->colname));
 
                /*
                 * If this is the first time we see this column being marked
                 * not-null, add the constraint entry and keep track of it.
                 * Also, remove previous markings that we need one.
                 *
                 * If this is a redundant not-null specification, just check
                 * that it doesn't conflict with what was specified earlier.
                 *
                 * Any conflicts with table constraints will be further
                 * checked in AddRelationNotNullConstraints().
                 */
                if (!column->is_not_null)
                {
                    column->is_not_null = true;
                    saw_nullable = true;
                    need_notnull = false;
 
                    constraint->keys = list_make1(makeString(column->colname));
                    notnull_constraint = constraint;
                    cxt->nnconstraints = lappend(cxt->nnconstraints, constraint);
                }
                else if (notnull_constraint)
                {
                    if (constraint->conname &&
                        notnull_constraint->conname &&
                        strcmp(notnull_constraint->conname, constraint->conname) != 0)
                        elog(ERROR, "conflicting not-null constraint names \"%s\" and \"%s\"",
                             notnull_constraint->conname, constraint->conname);
 
                    if (notnull_constraint->is_no_inherit != constraint->is_no_inherit)
                        ereport(ERROR,
                                errcode(ERRCODE_SYNTAX_ERROR),
                                errmsg("conflicting NO INHERIT declarations for not-null constraints on column \"%s\"",
                                       column->colname));
 
                    if (!notnull_constraint->conname && constraint->conname)
                        notnull_constraint->conname = constraint->conname;
                }
 
                break;
 
            case CONSTR_DEFAULT:
                if (saw_default)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple default values specified for column \"%s\" of table \"%s\"",
                                    column->colname, cxt->relation->relname),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                column->raw_default = constraint->raw_expr;
                Assert(constraint->cooked_expr == NULL);
                saw_default = true;
                break;
 
            case CONSTR_IDENTITY:
                {
                    Type        ctype;
                    Oid         typeOid;
 
                    if (cxt->ofType)
                        ereport(ERROR,
                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                 errmsg("identity columns are not supported on typed tables")));
                    if (cxt->partbound)
                        ereport(ERROR,
                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                 errmsg("identity columns are not supported on partitions")));
 
                    ctype = typenameType(cxt->pstate, column->typeName, NULL);
                    typeOid = ((Form_pg_type) GETSTRUCT(ctype))->oid;
                    ReleaseSysCache(ctype);
 
                    if (saw_identity)
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("multiple identity specifications for column \"%s\" of table \"%s\"",
                                        column->colname, cxt->relation->relname),
                                 parser_errposition(cxt->pstate,
                                                    constraint->location)));
 
                    generateSerialExtraStmts(cxt, column,
                                             typeOid, constraint->options,
                                             true, false,
                                             NULL, NULL);
 
                    column->identity = constraint->generated_when;
                    saw_identity = true;
 
                    /*
                     * Identity columns are always NOT NULL, but we may have a
                     * constraint already.
                     */
                    if (!saw_nullable)
                        need_notnull = true;
                    else if (!column->is_not_null)
                        ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
                                        column->colname, cxt->relation->relname),
                                 parser_errposition(cxt->pstate,
                                                    constraint->location)));
                    break;
                }
 
            case CONSTR_GENERATED:
                if (cxt->ofType)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("generated columns are not supported on typed tables")));
                if (saw_generated)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple generation clauses specified for column \"%s\" of table \"%s\"",
                                    column->colname, cxt->relation->relname),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                column->generated = constraint->generated_kind;
                column->raw_default = constraint->raw_expr;
                Assert(constraint->cooked_expr == NULL);
                saw_generated = true;
                break;
 
            case CONSTR_CHECK:
                cxt->ckconstraints = lappend(cxt->ckconstraints, constraint);
                break;
 
            case CONSTR_PRIMARY:
                if (saw_nullable && !column->is_not_null)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
                                    column->colname, cxt->relation->relname),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                need_notnull = true;
 
                if (cxt->isforeign)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("primary key constraints are not supported on foreign tables"),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                /* FALL THRU */
 
            case CONSTR_UNIQUE:
                if (cxt->isforeign)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("unique constraints are not supported on foreign tables"),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
                if (constraint->keys == NIL)
                    constraint->keys = list_make1(makeString(column->colname));
                cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
                break;
 
            case CONSTR_EXCLUSION:
                /* grammar does not allow EXCLUDE as a column constraint */
                elog(ERROR, "column exclusion constraints are not supported");
                break;
 
            case CONSTR_FOREIGN:
                if (cxt->isforeign)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("foreign key constraints are not supported on foreign tables"),
                             parser_errposition(cxt->pstate,
                                                constraint->location)));
 
                /*
                 * Fill in the current attribute's name and throw it into the
                 * list of FK constraints to be processed later.
                 */
                constraint->fk_attrs = list_make1(makeString(column->colname));
                cxt->fkconstraints = lappend(cxt->fkconstraints, constraint);
                break;
 
            case CONSTR_ATTR_DEFERRABLE:
            case CONSTR_ATTR_NOT_DEFERRABLE:
            case CONSTR_ATTR_DEFERRED:
            case CONSTR_ATTR_IMMEDIATE:
            case CONSTR_ATTR_ENFORCED:
            case CONSTR_ATTR_NOT_ENFORCED:
                /* transformConstraintAttrs took care of these */
                break;
 
            default:
                elog(ERROR, "unrecognized constraint type: %d",
                     constraint->contype);
                break;
        }
 
        if (saw_default && saw_identity)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("both default and identity specified for column \"%s\" of table \"%s\"",
                            column->colname, cxt->relation->relname),
                     parser_errposition(cxt->pstate,
                                        constraint->location)));
 
        if (saw_default && saw_generated)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("both default and generation expression specified for column \"%s\" of table \"%s\"",
                            column->colname, cxt->relation->relname),
                     parser_errposition(cxt->pstate,
                                        constraint->location)));
 
        if (saw_identity && saw_generated)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("both identity and generation expression specified for column \"%s\" of table \"%s\"",
                            column->colname, cxt->relation->relname),
                     parser_errposition(cxt->pstate,
                                        constraint->location)));
    }
 
    /*
     * If we need a not-null constraint for PRIMARY KEY, SERIAL or IDENTITY,
     * and one was not explicitly specified, add one now.
     */
    if (need_notnull && !(saw_nullable && column->is_not_null))
    {
        column->is_not_null = true;
        notnull_constraint = makeNotNullConstraint(makeString(column->colname));
        cxt->nnconstraints = lappend(cxt->nnconstraints, notnull_constraint);
    }
 
    /*
     * If needed, generate ALTER FOREIGN TABLE ALTER COLUMN statement to add
     * per-column foreign data wrapper options to this column after creation.
     */
    if (column->fdwoptions != NIL)
    {
        AlterTableStmt *stmt;
        AlterTableCmd *cmd;
 
        cmd = makeNode(AlterTableCmd);
        cmd->subtype = AT_AlterColumnGenericOptions;
        cmd->name = column->colname;
        cmd->def = (Node *) column->fdwoptions;
        cmd->behavior = DROP_RESTRICT;
        cmd->missing_ok = false;
 
        stmt = makeNode(AlterTableStmt);
        stmt->relation = cxt->relation;
        stmt->cmds = NIL;
        stmt->objtype = OBJECT_FOREIGN_TABLE;
        stmt->cmds = lappend(stmt->cmds, cmd);
 
        cxt->alist = lappend(cxt->alist, stmt);
    }
}

Referenced by transformAlterTableStmt(), and transformCreateStmt().

◆ transformColumnType()

static void transformColumnType	(	CreateStmtContext *	cxt,
		ColumnDef *	column
	)

static

Definition at line 4364 of file parse_utilcmd.c.

{
    /*
     * All we really need to do here is verify that the type is valid,
     * including any collation spec that might be present.
     */
    Type        ctype = typenameType(cxt->pstate, column->typeName, NULL);
 
    if (column->collClause)
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(ctype);
 
        LookupCollation(cxt->pstate,
                        column->collClause->collname,
                        column->collClause->location);
        /* Complain if COLLATE is applied to an uncollatable type */
        if (!OidIsValid(typtup->typcollation))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("collations are not supported by type %s",
                            format_type_be(typtup->oid)),
                     parser_errposition(cxt->pstate,
                                        column->collClause->location)));
    }
 
    ReleaseSysCache(ctype);
}

References ereport, errcode(), errmsg(), ERROR, fb(), format_type_be(), GETSTRUCT(), LookupCollation(), OidIsValid, parser_errposition(), CreateStmtContext::pstate, ReleaseSysCache(), and typenameType().

Referenced by transformColumnDefinition().

◆ transformConstraintAttrs()

static void transformConstraintAttrs	(	CreateStmtContext *	cxt,
		List *	constraintList
	)

static

Definition at line 4209 of file parse_utilcmd.c.

{
    Constraint *lastprimarycon = NULL;
    bool        saw_deferrability = false;
    bool        saw_initially = false;
    bool        saw_enforced = false;
    ListCell   *clist;
 
#define SUPPORTS_ATTRS(node)                \
    ((node) != NULL &&                      \
     ((node)->contype == CONSTR_PRIMARY ||  \
      (node)->contype == CONSTR_UNIQUE ||   \
      (node)->contype == CONSTR_EXCLUSION || \
      (node)->contype == CONSTR_FOREIGN))
 
    foreach(clist, constraintList)
    {
        Constraint *con = (Constraint *) lfirst(clist);
 
        if (!IsA(con, Constraint))
            elog(ERROR, "unrecognized node type: %d",
                 (int) nodeTag(con));
        switch (con->contype)
        {
            case CONSTR_ATTR_DEFERRABLE:
                if (!SUPPORTS_ATTRS(lastprimarycon))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced DEFERRABLE clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_deferrability)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_deferrability = true;
                lastprimarycon->deferrable = true;
                break;
 
            case CONSTR_ATTR_NOT_DEFERRABLE:
                if (!SUPPORTS_ATTRS(lastprimarycon))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced NOT DEFERRABLE clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_deferrability)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_deferrability = true;
                lastprimarycon->deferrable = false;
                if (saw_initially &&
                    lastprimarycon->initdeferred)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
                             parser_errposition(cxt->pstate, con->location)));
                break;
 
            case CONSTR_ATTR_DEFERRED:
                if (!SUPPORTS_ATTRS(lastprimarycon))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced INITIALLY DEFERRED clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_initially)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_initially = true;
                lastprimarycon->initdeferred = true;
 
                /*
                 * If only INITIALLY DEFERRED appears, assume DEFERRABLE
                 */
                if (!saw_deferrability)
                    lastprimarycon->deferrable = true;
                else if (!lastprimarycon->deferrable)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
                             parser_errposition(cxt->pstate, con->location)));
                break;
 
            case CONSTR_ATTR_IMMEDIATE:
                if (!SUPPORTS_ATTRS(lastprimarycon))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced INITIALLY IMMEDIATE clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_initially)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_initially = true;
                lastprimarycon->initdeferred = false;
                break;
 
            case CONSTR_ATTR_ENFORCED:
                if (lastprimarycon == NULL ||
                    (lastprimarycon->contype != CONSTR_CHECK &&
                     lastprimarycon->contype != CONSTR_FOREIGN))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced ENFORCED clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_enforced)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple ENFORCED/NOT ENFORCED clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_enforced = true;
                lastprimarycon->is_enforced = true;
                break;
 
            case CONSTR_ATTR_NOT_ENFORCED:
                if (lastprimarycon == NULL ||
                    (lastprimarycon->contype != CONSTR_CHECK &&
                     lastprimarycon->contype != CONSTR_FOREIGN))
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("misplaced NOT ENFORCED clause"),
                             parser_errposition(cxt->pstate, con->location)));
                if (saw_enforced)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("multiple ENFORCED/NOT ENFORCED clauses not allowed"),
                             parser_errposition(cxt->pstate, con->location)));
                saw_enforced = true;
                lastprimarycon->is_enforced = false;
 
                /* A NOT ENFORCED constraint must be marked as invalid. */
                lastprimarycon->skip_validation = true;
                lastprimarycon->initially_valid = false;
                break;
 
            default:
                /* Otherwise it's not an attribute */
                lastprimarycon = con;
                /* reset flags for new primary node */
                saw_deferrability = false;
                saw_initially = false;
                saw_enforced = false;
                break;
        }
    }
}

References CONSTR_ATTR_DEFERRABLE, CONSTR_ATTR_DEFERRED, CONSTR_ATTR_ENFORCED, CONSTR_ATTR_IMMEDIATE, CONSTR_ATTR_NOT_DEFERRABLE, CONSTR_ATTR_NOT_ENFORCED, CONSTR_CHECK, CONSTR_FOREIGN, Constraint::contype, elog, ereport, errcode(), errmsg(), ERROR, fb(), IsA, lfirst, Constraint::location, nodeTag, parser_errposition(), CreateStmtContext::pstate, and SUPPORTS_ATTRS.

Referenced by transformColumnDefinition().

◆ transformCreateSchemaStmtElements()

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

Definition at line 4421 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, fb(), CreateSchemaStmtContext::grants, CreateSchemaStmtContext::indexes, lappend(), lfirst, list_concat(), NIL, nodeTag, CreateSchemaStmtContext::schemaname, CreateSchemaStmtContext::sequences, setSchemaName(), CreateSchemaStmtContext::tables, CreateSchemaStmtContext::triggers, and CreateSchemaStmtContext::views.

Referenced by CreateSchemaCommand().

◆ transformCreateStmt()

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

Definition at line 167 of file parse_utilcmd.c.

{
    ParseState *pstate;
    CreateStmtContext cxt;
    List       *result;
    List       *save_alist;
    ListCell   *elements;
    Oid         namespaceid;
    Oid         existing_relid;
    ParseCallbackState pcbstate;
 
    /* Set up pstate */
    pstate = make_parsestate(NULL);
    pstate->p_sourcetext = queryString;
 
    /*
     * Look up the creation namespace.  This also checks permissions on the
     * target namespace, locks it against concurrent drops, checks for a
     * preexisting relation in that namespace with the same name, and updates
     * stmt->relation->relpersistence if the selected namespace is temporary.
     */
    setup_parser_errposition_callback(&pcbstate, pstate,
                                      stmt->relation->location);
    namespaceid =
        RangeVarGetAndCheckCreationNamespace(stmt->relation, NoLock,
                                             &existing_relid);
    cancel_parser_errposition_callback(&pcbstate);
 
    /*
     * If the relation already exists and the user specified "IF NOT EXISTS",
     * bail out with a NOTICE.
     */
    if (stmt->if_not_exists && OidIsValid(existing_relid))
    {
        /*
         * If we are in an extension script, insist that the pre-existing
         * object be a member of the extension, to avoid security risks.
         */
        ObjectAddress address;
 
        ObjectAddressSet(address, RelationRelationId, existing_relid);
        checkMembershipInCurrentExtension(&address);
 
        /* OK to skip */
        ereport(NOTICE,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("relation \"%s\" already exists, skipping",
                        stmt->relation->relname)));
        return NIL;
    }
 
    /*
     * If the target relation name isn't schema-qualified, make it so.  This
     * prevents some corner cases in which added-on rewritten commands might
     * think they should apply to other relations that have the same name and
     * are earlier in the search path.  But a local temp table is effectively
     * specified to be in pg_temp, so no need for anything extra in that case.
     */
    if (stmt->relation->schemaname == NULL
        && stmt->relation->relpersistence != RELPERSISTENCE_TEMP)
        stmt->relation->schemaname = get_namespace_name(namespaceid);
 
    /* Set up CreateStmtContext */
    cxt.pstate = pstate;
    if (IsA(stmt, CreateForeignTableStmt))
    {
        cxt.stmtType = "CREATE FOREIGN TABLE";
        cxt.isforeign = true;
    }
    else
    {
        cxt.stmtType = "CREATE TABLE";
        cxt.isforeign = false;
    }
    cxt.relation = stmt->relation;
    cxt.rel = NULL;
    cxt.inhRelations = stmt->inhRelations;
    cxt.isalter = false;
    cxt.columns = NIL;
    cxt.ckconstraints = NIL;
    cxt.nnconstraints = NIL;
    cxt.fkconstraints = NIL;
    cxt.ixconstraints = NIL;
    cxt.likeclauses = NIL;
    cxt.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().

◆ transformFKConstraints()

static void transformFKConstraints	(	CreateStmtContext *	cxt,
		bool	skipValidation,
		bool	isAddConstraint
	)

static

Definition at line 2985 of file parse_utilcmd.c.

{
    ListCell   *fkclist;
 
    if (cxt->fkconstraints == NIL)
        return;
 
    /*
     * If CREATE TABLE or adding a column with NULL default, we can safely
     * skip validation of FK constraints, and mark them as valid based on the
     * constraint enforcement flag, since NOT ENFORCED constraints must always
     * be marked as NOT VALID. (This will override any user-supplied NOT VALID
     * flag.)
     */
    if (skipValidation)
    {
        foreach(fkclist, cxt->fkconstraints)
        {
            Constraint *constraint = (Constraint *) lfirst(fkclist);
 
            constraint->skip_validation = true;
            constraint->initially_valid = constraint->is_enforced;
        }
    }
 
    /*
     * For CREATE TABLE or ALTER TABLE ADD COLUMN, gin up an ALTER TABLE ADD
     * CONSTRAINT command to execute after the basic command is complete. (If
     * called from ADD CONSTRAINT, that routine will add the FK constraints to
     * its own subcommand list.)
     *
     * Note: the ADD CONSTRAINT command must also execute after any index
     * creation commands.  Thus, this should run after
     * transformIndexConstraints, so that the CREATE INDEX commands are
     * already in cxt->alist.  See also the handling of cxt->likeclauses.
     */
    if (!isAddConstraint)
    {
        AlterTableStmt *alterstmt = makeNode(AlterTableStmt);
 
        alterstmt->relation = cxt->relation;
        alterstmt->cmds = NIL;
        alterstmt->objtype = OBJECT_TABLE;
 
        foreach(fkclist, cxt->fkconstraints)
        {
            Constraint *constraint = (Constraint *) lfirst(fkclist);
            AlterTableCmd *altercmd = makeNode(AlterTableCmd);
 
            altercmd->subtype = AT_AddConstraint;
            altercmd->name = NULL;
            altercmd->def = (Node *) constraint;
            alterstmt->cmds = lappend(alterstmt->cmds, altercmd);
        }
 
        cxt->alist = lappend(cxt->alist, alterstmt);
    }
}

References CreateStmtContext::alist, AT_AddConstraint, fb(), CreateStmtContext::fkconstraints, Constraint::initially_valid, Constraint::is_enforced, lappend(), lfirst, makeNode, NIL, OBJECT_TABLE, CreateStmtContext::relation, and Constraint::skip_validation.

Referenced by transformAlterTableStmt(), and transformCreateStmt().

◆ transformIndexConstraint()

static IndexStmt * transformIndexConstraint	(	Constraint *	constraint,
		CreateStmtContext *	cxt
	)

static

Definition at line 2345 of file parse_utilcmd.c.

{
    IndexStmt  *index;
    ListCell   *lc;
 
    index = makeNode(IndexStmt);
 
    index->unique = (constraint->contype != CONSTR_EXCLUSION);
    index->primary = (constraint->contype == CONSTR_PRIMARY);
    if (index->primary)
    {
        if (cxt->pkey != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("multiple primary keys for table \"%s\" are not allowed",
                            cxt->relation->relname),
                     parser_errposition(cxt->pstate, constraint->location)));
        cxt->pkey = index;
 
        /*
         * In ALTER TABLE case, a primary index might already exist, but
         * DefineIndex will check for it.
         */
    }
    index->nulls_not_distinct = constraint->nulls_not_distinct;
    index->isconstraint = true;
    index->iswithoutoverlaps = constraint->without_overlaps;
    index->deferrable = constraint->deferrable;
    index->initdeferred = constraint->initdeferred;
 
    if (constraint->conname != NULL)
        index->idxname = pstrdup(constraint->conname);
    else
        index->idxname = NULL;  /* DefineIndex will choose name */
 
    index->relation = cxt->relation;
    index->accessMethod = constraint->access_method ? constraint->access_method : DEFAULT_INDEX_TYPE;
    index->options = constraint->options;
    index->tableSpace = constraint->indexspace;
    index->whereClause = constraint->where_clause;
    index->indexParams = NIL;
    index->indexIncludingParams = NIL;
    index->excludeOpNames = NIL;
    index->idxcomment = NULL;
    index->indexOid = InvalidOid;
    index->oldNumber = InvalidRelFileNumber;
    index->oldCreateSubid = InvalidSubTransactionId;
    index->oldFirstRelfilelocatorSubid = InvalidSubTransactionId;
    index->transformed = false;
    index->concurrent = false;
    index->if_not_exists = false;
    index->reset_default_tblspc = constraint->reset_default_tblspc;
 
    /*
     * If it's ALTER TABLE ADD CONSTRAINT USING INDEX, look up the index and
     * verify it's usable, then extract the implied column name list.  (We
     * will not actually need the column name list at runtime, but we need it
     * now to check for duplicate column entries below.)
     */
    if (constraint->indexname != NULL)
    {
        char       *index_name = constraint->indexname;
        Relation    heap_rel = cxt->rel;
        Oid         index_oid;
        Relation    index_rel;
        Form_pg_index index_form;
        oidvector  *indclass;
        Datum       indclassDatum;
        int         i;
 
        /* Grammar should not allow this with explicit column list */
        Assert(constraint->keys == NIL);
 
        /* Grammar should only allow PRIMARY and UNIQUE constraints */
        Assert(constraint->contype == CONSTR_PRIMARY ||
               constraint->contype == CONSTR_UNIQUE);
 
        /* Must be ALTER, not CREATE, but grammar doesn't enforce that */
        if (!cxt->isalter)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot use an existing index in CREATE TABLE"),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /* Look for the index in the same schema as the table */
        index_oid = get_relname_relid(index_name, RelationGetNamespace(heap_rel));
 
        if (!OidIsValid(index_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("index \"%s\" does not exist", index_name),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /* Open the index (this will throw an error if it is not an index) */
        index_rel = index_open(index_oid, AccessShareLock);
        index_form = index_rel->rd_index;
 
        /* Check that it does not have an associated constraint already */
        if (OidIsValid(get_index_constraint(index_oid)))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("index \"%s\" is already associated with a constraint",
                            index_name),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /* Perform validity checks on the index */
        if (index_form->indrelid != RelationGetRelid(heap_rel))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("index \"%s\" does not belong to table \"%s\"",
                            index_name, RelationGetRelationName(heap_rel)),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        if (!index_form->indisvalid)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("index \"%s\" is not valid", index_name),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /*
         * Today we forbid non-unique indexes, but we could permit GiST
         * indexes whose last entry is a range type and use that to create a
         * WITHOUT OVERLAPS constraint (i.e. a temporal constraint).
         */
        if (!index_form->indisunique)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is not a unique index", index_name),
                     errdetail("Cannot create a primary key or unique constraint using such an index."),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        if (RelationGetIndexExpressions(index_rel) != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("index \"%s\" contains expressions", index_name),
                     errdetail("Cannot create a primary key or unique constraint using such an index."),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        if (RelationGetIndexPredicate(index_rel) != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is a partial index", index_name),
                     errdetail("Cannot create a primary key or unique constraint using such an index."),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /*
         * It's probably unsafe to change a deferred index to non-deferred. (A
         * non-constraint index couldn't be deferred anyway, so this case
         * should never occur; no need to sweat, but let's check it.)
         */
        if (!index_form->indimmediate && !constraint->deferrable)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" is a deferrable index", index_name),
                     errdetail("Cannot create a non-deferrable constraint using a deferrable index."),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /*
         * Insist on it being a btree.  We must have an index that exactly
         * matches what you'd get from plain ADD CONSTRAINT syntax, else dump
         * and reload will produce a different index (breaking pg_upgrade in
         * particular).
         */
        if (index_rel->rd_rel->relam != get_index_am_oid(DEFAULT_INDEX_TYPE, false))
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("index \"%s\" is not a btree", index_name),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /* Must get indclass the hard way */
        indclassDatum = SysCacheGetAttrNotNull(INDEXRELID,
                                               index_rel->rd_indextuple,
                                               Anum_pg_index_indclass);
        indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
        for (i = 0; i < index_form->indnatts; i++)
        {
            int16       attnum = index_form->indkey.values[i];
            const FormData_pg_attribute *attform;
            char       *attname;
            Oid         defopclass;
 
            /*
             * We shouldn't see attnum == 0 here, since we already rejected
             * expression indexes.  If we do, SystemAttributeDefinition will
             * throw an error.
             */
            if (attnum > 0)
            {
                Assert(attnum <= heap_rel->rd_att->natts);
                attform = TupleDescAttr(heap_rel->rd_att, attnum - 1);
            }
            else
                attform = SystemAttributeDefinition(attnum);
            attname = pstrdup(NameStr(attform->attname));
 
            if (i < index_form->indnkeyatts)
            {
                /*
                 * Insist on default opclass, collation, and sort options.
                 * While the index would still work as a constraint with
                 * non-default settings, it might not provide exactly the same
                 * uniqueness semantics as you'd get from a normally-created
                 * constraint; and there's also the dump/reload problem
                 * mentioned above.
                 */
                Datum       attoptions =
                    get_attoptions(RelationGetRelid(index_rel), i + 1);
 
                defopclass = GetDefaultOpClass(attform->atttypid,
                                               index_rel->rd_rel->relam);
                if (indclass->values[i] != defopclass ||
                    attform->attcollation != index_rel->rd_indcollation[i] ||
                    attoptions != (Datum) 0 ||
                    index_rel->rd_indoption[i] != 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("index \"%s\" column number %d does not have default sorting behavior", index_name, i + 1),
                             errdetail("Cannot create a primary key or unique constraint using such an index."),
                             parser_errposition(cxt->pstate, constraint->location)));
 
                /* If a PK, ensure the columns get not null constraints */
                if (constraint->contype == CONSTR_PRIMARY)
                    cxt->nnconstraints =
                        lappend(cxt->nnconstraints,
                                makeNotNullConstraint(makeString(attname)));
 
                constraint->keys = lappend(constraint->keys, makeString(attname));
            }
            else
                constraint->including = lappend(constraint->including, makeString(attname));
        }
 
        /* Close the index relation but keep the lock */
        index_close(index_rel, NoLock);
 
        index->indexOid = index_oid;
    }
 
    /*
     * If it's an EXCLUDE constraint, the grammar returns a list of pairs of
     * IndexElems and operator names.  We have to break that apart into
     * separate lists.
     */
    if (constraint->contype == CONSTR_EXCLUSION)
    {
        foreach(lc, constraint->exclusions)
        {
            List       *pair = (List *) lfirst(lc);
            IndexElem  *elem;
            List       *opname;
 
            Assert(list_length(pair) == 2);
            elem = linitial_node(IndexElem, pair);
            opname = lsecond_node(List, pair);
 
            index->indexParams = lappend(index->indexParams, elem);
            index->excludeOpNames = lappend(index->excludeOpNames, opname);
        }
    }
 
    /*
     * For UNIQUE and PRIMARY KEY, we just have a list of column names.
     *
     * Make sure referenced keys exist.  If we are making a PRIMARY KEY index,
     * also make sure they are not-null.  For WITHOUT OVERLAPS constraints, we
     * make sure the last part is a range or multirange.
     */
    else
    {
        foreach(lc, constraint->keys)
        {
            char       *key = strVal(lfirst(lc));
            bool        found = false;
            ColumnDef  *column = NULL;
            ListCell   *columns;
            IndexElem  *iparam;
            Oid         typid = InvalidOid;
 
            /* Make sure referenced column exists. */
            foreach(columns, cxt->columns)
            {
                column = lfirst_node(ColumnDef, columns);
                if (strcmp(column->colname, key) == 0)
                {
                    found = true;
                    break;
                }
            }
            if (!found)
                column = NULL;
 
            if (found)
            {
                /*
                 * column is defined in the new table.  For CREATE TABLE with
                 * a PRIMARY KEY, we can apply the not-null constraint cheaply
                 * here.  If the not-null constraint already exists, we can
                 * (albeit not so cheaply) verify that it's not a NO INHERIT
                 * constraint.
                 *
                 * Note that ALTER TABLE never needs either check, because
                 * those constraints have already been added by
                 * ATPrepAddPrimaryKey.
                 */
                if (constraint->contype == CONSTR_PRIMARY &&
                    !cxt->isalter)
                {
                    if (column->is_not_null)
                    {
                        foreach_node(Constraint, nn, cxt->nnconstraints)
                        {
                            if (strcmp(strVal(linitial(nn->keys)), key) == 0)
                            {
                                if (nn->is_no_inherit)
                                    ereport(ERROR,
                                            errcode(ERRCODE_SYNTAX_ERROR),
                                            errmsg("conflicting NO INHERIT declaration for not-null constraint on column \"%s\"",
                                                   key));
                                break;
                            }
                        }
                    }
                    else
                    {
                        column->is_not_null = true;
                        cxt->nnconstraints =
                            lappend(cxt->nnconstraints,
                                    makeNotNullConstraint(makeString(key)));
                    }
                }
                else if (constraint->contype == CONSTR_PRIMARY)
                    Assert(column->is_not_null);
            }
            else if (SystemAttributeByName(key) != NULL)
            {
                /*
                 * column will be a system column in the new table, so accept
                 * it. System columns can't ever be null, so no need to worry
                 * about PRIMARY/NOT NULL constraint.
                 */
                found = true;
            }
            else if (cxt->inhRelations)
            {
                /* try inherited tables */
                ListCell   *inher;
 
                foreach(inher, cxt->inhRelations)
                {
                    RangeVar   *inh = lfirst_node(RangeVar, inher);
                    Relation    rel;
                    int         count;
 
                    rel = table_openrv(inh, AccessShareLock);
                    /* check user requested inheritance from valid relkind */
                    if (rel->rd_rel->relkind != RELKIND_RELATION &&
                        rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
                        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
                        ereport(ERROR,
                                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                                 errmsg("inherited relation \"%s\" is not a table or foreign table",
                                        inh->relname)));
                    for (count = 0; count < rel->rd_att->natts; count++)
                    {
                        Form_pg_attribute inhattr = TupleDescAttr(rel->rd_att,
                                                                  count);
                        char       *inhname = NameStr(inhattr->attname);
 
                        if (inhattr->attisdropped)
                            continue;
                        if (strcmp(key, inhname) == 0)
                        {
                            found = true;
                            typid = inhattr->atttypid;
 
                            if (constraint->contype == CONSTR_PRIMARY)
                                cxt->nnconstraints =
                                    lappend(cxt->nnconstraints,
                                            makeNotNullConstraint(makeString(pstrdup(inhname))));
                            break;
                        }
                    }
                    table_close(rel, NoLock);
                    if (found)
                        break;
                }
            }
 
            /*
             * In the ALTER TABLE case, don't complain about index keys not
             * created in the command; they may well exist already.
             * DefineIndex will complain about them if not.
             */
            if (!found && !cxt->isalter)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" named in key does not exist", key),
                         parser_errposition(cxt->pstate, constraint->location)));
 
            /* Check for PRIMARY KEY(foo, foo) */
            foreach(columns, index->indexParams)
            {
                iparam = (IndexElem *) lfirst(columns);
                if (iparam->name && strcmp(key, iparam->name) == 0)
                {
                    if (index->primary)
                        ereport(ERROR,
                                (errcode(ERRCODE_DUPLICATE_COLUMN),
                                 errmsg("column \"%s\" appears twice in primary key constraint",
                                        key),
                                 parser_errposition(cxt->pstate, constraint->location)));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DUPLICATE_COLUMN),
                                 errmsg("column \"%s\" appears twice in unique constraint",
                                        key),
                                 parser_errposition(cxt->pstate, constraint->location)));
                }
            }
 
            /*
             * The WITHOUT OVERLAPS part (if any) must be a range or
             * multirange type.
             */
            if (constraint->without_overlaps && lc == list_last_cell(constraint->keys))
            {
                if (!found && cxt->isalter)
                {
                    /*
                     * Look up the column type on existing table. If we can't
                     * find it, let things fail in DefineIndex.
                     */
                    Relation    rel = cxt->rel;
 
                    for (int i = 0; i < rel->rd_att->natts; i++)
                    {
                        Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);
                        const char *attname;
 
                        if (attr->attisdropped)
                            break;
 
                        attname = NameStr(attr->attname);
                        if (strcmp(attname, key) == 0)
                        {
                            found = true;
                            typid = attr->atttypid;
                            break;
                        }
                    }
                }
                if (found)
                {
                    if (!OidIsValid(typid) && column)
                        typid = typenameTypeId(NULL, column->typeName);
 
                    if (!OidIsValid(typid) || !(type_is_range(typid) || type_is_multirange(typid)))
                        ereport(ERROR,
                                (errcode(ERRCODE_DATATYPE_MISMATCH),
                                 errmsg("column \"%s\" in WITHOUT OVERLAPS is not a range or multirange type", key),
                                 parser_errposition(cxt->pstate, constraint->location)));
                }
            }
 
            /* OK, add it to the index definition */
            iparam = makeNode(IndexElem);
            iparam->name = pstrdup(key);
            iparam->expr = NULL;
            iparam->indexcolname = NULL;
            iparam->collation = NIL;
            iparam->opclass = NIL;
            iparam->opclassopts = NIL;
            iparam->ordering = SORTBY_DEFAULT;
            iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
            iparam->location = -1;
            index->indexParams = lappend(index->indexParams, iparam);
        }
 
        if (constraint->without_overlaps)
        {
            /*
             * This enforces that there is at least one equality column
             * besides the WITHOUT OVERLAPS columns.  This is per SQL
             * standard.  XXX Do we need this?
             */
            if (list_length(constraint->keys) < 2)
                ereport(ERROR,
                        errcode(ERRCODE_SYNTAX_ERROR),
                        errmsg("constraint using WITHOUT OVERLAPS needs at least two columns"));
 
            /* WITHOUT OVERLAPS requires a GiST index */
            index->accessMethod = "gist";
        }
 
    }
 
    /*
     * Add included columns to index definition.  This is much like the
     * simple-column-name-list code above, except that we don't worry about
     * NOT NULL marking; included columns in a primary key should not be
     * forced NOT NULL.  We don't complain about duplicate columns, either,
     * though maybe we should?
     */
    foreach(lc, constraint->including)
    {
        char       *key = strVal(lfirst(lc));
        bool        found = false;
        ColumnDef  *column = NULL;
        ListCell   *columns;
        IndexElem  *iparam;
 
        foreach(columns, cxt->columns)
        {
            column = lfirst_node(ColumnDef, columns);
            if (strcmp(column->colname, key) == 0)
            {
                found = true;
                break;
            }
        }
 
        if (!found)
        {
            if (SystemAttributeByName(key) != NULL)
            {
                /*
                 * column will be a system column in the new table, so accept
                 * it.
                 */
                found = true;
            }
            else if (cxt->inhRelations)
            {
                /* try inherited tables */
                ListCell   *inher;
 
                foreach(inher, cxt->inhRelations)
                {
                    RangeVar   *inh = lfirst_node(RangeVar, inher);
                    Relation    rel;
                    int         count;
 
                    rel = table_openrv(inh, AccessShareLock);
                    /* check user requested inheritance from valid relkind */
                    if (rel->rd_rel->relkind != RELKIND_RELATION &&
                        rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
                        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
                        ereport(ERROR,
                                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                                 errmsg("inherited relation \"%s\" is not a table or foreign table",
                                        inh->relname)));
                    for (count = 0; count < rel->rd_att->natts; count++)
                    {
                        Form_pg_attribute inhattr = TupleDescAttr(rel->rd_att,
                                                                  count);
                        char       *inhname = NameStr(inhattr->attname);
 
                        if (inhattr->attisdropped)
                            continue;
                        if (strcmp(key, inhname) == 0)
                        {
                            found = true;
                            break;
                        }
                    }
                    table_close(rel, NoLock);
                    if (found)
                        break;
                }
            }
        }
 
        /*
         * In the ALTER TABLE case, don't complain about index keys not
         * created in the command; they may well exist already. DefineIndex
         * will complain about them if not.
         */
        if (!found && !cxt->isalter)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" named in key does not exist", key),
                     parser_errposition(cxt->pstate, constraint->location)));
 
        /* OK, add it to the index definition */
        iparam = makeNode(IndexElem);
        iparam->name = pstrdup(key);
        iparam->expr = NULL;
        iparam->indexcolname = NULL;
        iparam->collation = NIL;
        iparam->opclass = NIL;
        iparam->opclassopts = NIL;
        iparam->location = -1;
        index->indexIncludingParams = lappend(index->indexIncludingParams, iparam);
    }
 
    return index;
}

References Constraint::access_method, AccessShareLock, Assert, attname, attnum, CreateStmtContext::columns, Constraint::conname, CONSTR_EXCLUSION, CONSTR_PRIMARY, CONSTR_UNIQUE, Constraint::contype, DatumGetPointer(), DEFAULT_INDEX_TYPE, Constraint::deferrable, ereport, errcode(), errdetail(), errmsg(), ERROR, Constraint::exclusions, fb(), foreach_node, FormData_pg_attribute, get_attoptions(), get_index_am_oid(), get_index_constraint(), get_relname_relid(), GetDefaultOpClass(), i, Constraint::including, index_close(), index_open(), Constraint::indexname, Constraint::indexspace, CreateStmtContext::inhRelations, Constraint::initdeferred, InvalidOid, InvalidRelFileNumber, InvalidSubTransactionId, CreateStmtContext::isalter, Constraint::keys, lappend(), lfirst, lfirst_node, linitial, linitial_node, list_last_cell(), list_length(), Constraint::location, lsecond_node, makeNode, makeNotNullConstraint(), makeString(), NameStr, TupleDescData::natts, NIL, CreateStmtContext::nnconstraints, NoLock, Constraint::nulls_not_distinct, OidIsValid, Constraint::options, parser_errposition(), CreateStmtContext::pkey, CreateStmtContext::pstate, pstrdup(), RelationData::rd_att, RelationData::rd_rel, CreateStmtContext::rel, CreateStmtContext::relation, RelationGetIndexExpressions(), RelationGetIndexPredicate(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RangeVar::relname, Constraint::reset_default_tblspc, SORTBY_DEFAULT, SORTBY_NULLS_DEFAULT, strVal, SysCacheGetAttrNotNull(), SystemAttributeByName(), SystemAttributeDefinition(), table_close(), table_openrv(), TupleDescAttr(), type_is_multirange(), type_is_range(), typenameTypeId(), Constraint::where_clause, and Constraint::without_overlaps.

Referenced by transformIndexConstraints().

◆ transformIndexConstraints()

static void transformIndexConstraints ( CreateStmtContext * cxt )

static

Definition at line 2246 of file parse_utilcmd.c.

{
    IndexStmt  *index;
    List       *indexlist = NIL;
    List       *finalindexlist = NIL;
    ListCell   *lc;
 
    /*
     * Run through the constraints that need to generate an index, and do so.
     *
     * For PRIMARY KEY, this queues not-null constraints for each column, if
     * needed.
     */
    foreach(lc, cxt->ixconstraints)
    {
        Constraint *constraint = lfirst_node(Constraint, lc);
 
        Assert(constraint->contype == CONSTR_PRIMARY ||
               constraint->contype == CONSTR_UNIQUE ||
               constraint->contype == CONSTR_EXCLUSION);
 
        index = transformIndexConstraint(constraint, cxt);
 
        indexlist = lappend(indexlist, index);
    }
 
    /*
     * Scan the index list and remove any redundant index specifications. This
     * can happen if, for instance, the user writes UNIQUE PRIMARY KEY. A
     * strict reading of SQL would suggest raising an error instead, but that
     * strikes me as too anal-retentive. - tgl 2001-02-14
     *
     * XXX in ALTER TABLE case, it'd be nice to look for duplicate
     * pre-existing indexes, too.
     */
    if (cxt->pkey != NULL)
    {
        /* Make sure we keep the PKEY index in preference to others... */
        finalindexlist = list_make1(cxt->pkey);
    }
 
    foreach(lc, indexlist)
    {
        bool        keep = true;
        ListCell   *k;
 
        index = lfirst(lc);
 
        /* if it's pkey, it's already in finalindexlist */
        if (index == cxt->pkey)
            continue;
 
        foreach(k, finalindexlist)
        {
            IndexStmt  *priorindex = lfirst(k);
 
            if (equal(index->indexParams, priorindex->indexParams) &&
                equal(index->indexIncludingParams, priorindex->indexIncludingParams) &&
                equal(index->whereClause, priorindex->whereClause) &&
                equal(index->excludeOpNames, priorindex->excludeOpNames) &&
                strcmp(index->accessMethod, priorindex->accessMethod) == 0 &&
                index->nulls_not_distinct == priorindex->nulls_not_distinct &&
                index->deferrable == priorindex->deferrable &&
                index->initdeferred == priorindex->initdeferred)
            {
                priorindex->unique |= index->unique;
 
                /*
                 * If the prior index is as yet unnamed, and this one is
                 * named, then transfer the name to the prior index. This
                 * ensures that if we have named and unnamed constraints,
                 * we'll use (at least one of) the names for the index.
                 */
                if (priorindex->idxname == NULL)
                    priorindex->idxname = index->idxname;
                keep = false;
                break;
            }
        }
 
        if (keep)
            finalindexlist = lappend(finalindexlist, index);
    }
 
    /*
     * Now append all the IndexStmts to cxt->alist.
     */
    cxt->alist = list_concat(cxt->alist, finalindexlist);
}

References CreateStmtContext::alist, Assert, CONSTR_EXCLUSION, CONSTR_PRIMARY, CONSTR_UNIQUE, Constraint::contype, equal(), fb(), CreateStmtContext::ixconstraints, lappend(), lfirst, lfirst_node, list_concat(), list_make1, NIL, CreateStmtContext::pkey, and transformIndexConstraint().

Referenced by transformAlterTableStmt(), and transformCreateStmt().

◆ transformIndexStmt()

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

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

◆ transformOfType()

static void transformOfType	(	CreateStmtContext *	cxt,
		TypeName *	ofTypename
	)

static

Definition at line 1642 of file parse_utilcmd.c.

{
    HeapTuple   tuple;
    TupleDesc   tupdesc;
    int         i;
    Oid         ofTypeId;
 
    Assert(ofTypename);
 
    tuple = typenameType(cxt->pstate, ofTypename, NULL);
    check_of_type(tuple);
    ofTypeId = ((Form_pg_type) GETSTRUCT(tuple))->oid;
    ofTypename->typeOid = ofTypeId; /* cached for later */
 
    tupdesc = lookup_rowtype_tupdesc(ofTypeId, -1);
    for (i = 0; i < tupdesc->natts; i++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
        ColumnDef  *n;
 
        if (attr->attisdropped)
            continue;
 
        n = makeColumnDef(NameStr(attr->attname), attr->atttypid,
                          attr->atttypmod, attr->attcollation);
        n->is_from_type = true;
 
        cxt->columns = lappend(cxt->columns, n);
    }
    ReleaseTupleDesc(tupdesc);
 
    ReleaseSysCache(tuple);
}

References Assert, check_of_type(), CreateStmtContext::columns, fb(), GETSTRUCT(), i, ColumnDef::is_from_type, lappend(), lookup_rowtype_tupdesc(), makeColumnDef(), NameStr, TupleDescData::natts, CreateStmtContext::pstate, ReleaseSysCache(), ReleaseTupleDesc, TupleDescAttr(), typenameType(), and TypeName::typeOid.

Referenced by transformCreateStmt().

◆ transformPartitionBound()

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

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

◆ transformPartitionBoundValue()

static Const * transformPartitionBoundValue	(	ParseState *	pstate,
		Node *	val,
		const char *	colName,
		Oid	colType,
		int32	colTypmod,
		Oid	partCollation
	)

static

Definition at line 4908 of file parse_utilcmd.c.

{
    Node       *value;
 
    /* Transform raw parsetree */
    value = transformExpr(pstate, val, EXPR_KIND_PARTITION_BOUND);
 
    /*
     * transformExpr() should have already rejected column references,
     * subqueries, aggregates, window functions, and SRFs, based on the
     * EXPR_KIND_ of a partition bound expression.
     */
    Assert(!contain_var_clause(value));
 
    /*
     * Coerce to the correct type.  This might cause an explicit coercion step
     * to be added on top of the expression, which must be evaluated before
     * returning the result to the caller.
     */
    value = coerce_to_target_type(pstate,
                                  value, exprType(value),
                                  colType,
                                  colTypmod,
                                  COERCION_ASSIGNMENT,
                                  COERCE_IMPLICIT_CAST,
                                  -1);
 
    if (value == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("specified value cannot be cast to type %s for column \"%s\"",
                        format_type_be(colType), colName),
                 parser_errposition(pstate, exprLocation(val))));
 
    /*
     * Evaluate the expression, if needed, assigning the partition key's data
     * type and collation to the resulting Const node.
     */
    if (!IsA(value, Const))
    {
        assign_expr_collations(pstate, value);
        value = (Node *) expression_planner((Expr *) value);
        value = (Node *) evaluate_expr((Expr *) value, colType, colTypmod,
                                       partCollation);
        if (!IsA(value, Const))
            elog(ERROR, "could not evaluate partition bound expression");
    }
    else
    {
        /*
         * If the expression is already a Const, as is often the case, we can
         * skip the rather expensive steps above.  But we still have to insert
         * the right collation, since coerce_to_target_type doesn't handle
         * that.
         */
        ((Const *) value)->constcollid = partCollation;
    }
 
    /*
     * Attach original expression's parse location to the Const, so that
     * that's what will be reported for any later errors related to this
     * partition bound.
     */
    ((Const *) value)->location = exprLocation(val);
 
    return (Const *) value;
}

References Assert, assign_expr_collations(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, contain_var_clause(), elog, ereport, errcode(), errmsg(), ERROR, evaluate_expr(), EXPR_KIND_PARTITION_BOUND, expression_planner(), exprLocation(), exprType(), fb(), format_type_be(), IsA, parser_errposition(), transformExpr(), val, and value.

Referenced by transformPartitionBound(), and transformPartitionRangeBounds().

◆ transformPartitionCmd()

static void transformPartitionCmd	(	CreateStmtContext *	cxt,
		PartitionBoundSpec *	bound
	)

static

Definition at line 4544 of file parse_utilcmd.c.

{
    Relation    parentRel = cxt->rel;
 
    switch (parentRel->rd_rel->relkind)
    {
        case RELKIND_PARTITIONED_TABLE:
            /* transform the partition bound, if any */
            Assert(RelationGetPartitionKey(parentRel) != NULL);
            if (bound != NULL)
                cxt->partbound = transformPartitionBound(cxt->pstate, parentRel,
                                                         bound);
            break;
        case RELKIND_PARTITIONED_INDEX:
 
            /*
             * A partitioned index cannot have a partition bound set.  ALTER
             * INDEX prevents that with its grammar, but not ALTER TABLE.
             */
            if (bound != NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("\"%s\" is not a partitioned table",
                                RelationGetRelationName(parentRel))));
            break;
        case RELKIND_RELATION:
            /* the table must be partitioned */
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("table \"%s\" is not partitioned",
                            RelationGetRelationName(parentRel))));
            break;
        case RELKIND_INDEX:
            /* the index must be partitioned */
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("index \"%s\" is not partitioned",
                            RelationGetRelationName(parentRel))));
            break;
        default:
            /* parser shouldn't let this case through */
            elog(ERROR, "\"%s\" is not a partitioned table or index",
                 RelationGetRelationName(parentRel));
            break;
    }
}

References Assert, elog, ereport, errcode(), errmsg(), ERROR, fb(), CreateStmtContext::partbound, CreateStmtContext::pstate, CreateStmtContext::rel, RelationGetPartitionKey(), RelationGetRelationName, and transformPartitionBound().

Referenced by transformAlterTableStmt(), and transformPartitionCmdForSplit().

◆ transformPartitionCmdForMerge()

static void transformPartitionCmdForMerge	(	CreateStmtContext *	cxt,
		PartitionCmd *	partcmd
	)

static

Definition at line 3716 of file parse_utilcmd.c.

{
    Oid         defaultPartOid;
    Oid         partOid;
    Relation    parent = cxt->rel;
    PartitionKey key;
    char        strategy;
    ListCell   *listptr,
               *listptr2;
    bool        isDefaultPart = false;
    List       *partOids = NIL;
 
    key = RelationGetPartitionKey(parent);
    strategy = get_partition_strategy(key);
 
    if (strategy == PARTITION_STRATEGY_HASH)
        ereport(ERROR,
                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                errmsg("partition of hash-partitioned table cannot be merged"));
 
    /* Does the partitioned table (parent) have a default partition? */
    defaultPartOid = get_default_oid_from_partdesc(RelationGetPartitionDesc(parent, true));
 
    foreach(listptr, partcmd->partlist)
    {
        RangeVar   *name = (RangeVar *) lfirst(listptr);
 
        /* Partitions in the list should have different names. */
        for_each_cell(listptr2, partcmd->partlist, lnext(partcmd->partlist, listptr))
        {
            RangeVar   *name2 = (RangeVar *) lfirst(listptr2);
 
            if (equal(name, name2))
                ereport(ERROR,
                        errcode(ERRCODE_DUPLICATE_TABLE),
                        errmsg("partition with name \"%s\" is already used", name->relname),
                        parser_errposition(cxt->pstate, name2->location));
        }
 
        /*
         * Search the DEFAULT partition in the list. Open and lock partitions
         * before calculating the boundary for resulting partition, we also
         * check for ownership along the way.  We need to use
         * AccessExclusiveLock here, because these merged partitions will be
         * detached and then dropped in ATExecMergePartitions.
         */
        partOid = RangeVarGetRelidExtended(name, AccessExclusiveLock, 0,
                                           RangeVarCallbackOwnsRelation,
                                           NULL);
        /* Is the current partition a DEFAULT partition? */
        if (partOid == defaultPartOid)
            isDefaultPart = true;
 
        /*
         * Extended check because the same partition can have different names
         * (for example, "part_name" and "public.part_name").
         */
        foreach(listptr2, partOids)
        {
            Oid         curOid = lfirst_oid(listptr2);
 
            if (curOid == partOid)
                ereport(ERROR,
                        errcode(ERRCODE_DUPLICATE_TABLE),
                        errmsg("partition with name \"%s\" is already used", name->relname),
                        parser_errposition(cxt->pstate, name->location));
        }
 
        checkPartition(parent, partOid, true);
 
        partOids = lappend_oid(partOids, partOid);
    }
 
    /* Allocate the bound of the resulting partition. */
    Assert(partcmd->bound == NULL);
    partcmd->bound = makeNode(PartitionBoundSpec);
 
    /* Fill the partition bound. */
    partcmd->bound->strategy = strategy;
    partcmd->bound->location = -1;
    partcmd->bound->is_default = isDefaultPart;
    if (!isDefaultPart)
        calculate_partition_bound_for_merge(parent, partcmd->partlist,
                                            partOids, partcmd->bound,
                                            cxt->pstate);
}

References AccessExclusiveLock, Assert, calculate_partition_bound_for_merge(), checkPartition(), equal(), ereport, errcode(), errmsg(), ERROR, fb(), for_each_cell, get_default_oid_from_partdesc(), get_partition_strategy(), lappend_oid(), lfirst, lfirst_oid, lnext(), makeNode, name, NIL, parser_errposition(), PARTITION_STRATEGY_HASH, CreateStmtContext::pstate, RangeVarCallbackOwnsRelation(), RangeVarGetRelidExtended(), CreateStmtContext::rel, RelationGetPartitionDesc(), and RelationGetPartitionKey().

Referenced by transformAlterTableStmt().

◆ transformPartitionCmdForSplit()

static void transformPartitionCmdForSplit	(	CreateStmtContext *	cxt,
		PartitionCmd *	partcmd
	)

static

Definition at line 3571 of file parse_utilcmd.c.

{
    Relation    parent = cxt->rel;
    PartitionKey key;
    char        strategy;
    Oid         splitPartOid;
    Oid         defaultPartOid;
    int         default_index = -1;
    bool        isSplitPartDefault;
    ListCell   *listptr,
               *listptr2;
    List       *splitlist;
 
    splitlist = partcmd->partlist;
    key = RelationGetPartitionKey(parent);
    strategy = get_partition_strategy(key);
    defaultPartOid = get_default_oid_from_partdesc(RelationGetPartitionDesc(parent, true));
 
    /* Transform partition bounds for all partitions in the list: */
    foreach_node(SinglePartitionSpec, sps, splitlist)
    {
        cxt->partbound = NULL;
        transformPartitionCmd(cxt, sps->bound);
        /* Assign the transformed value of the partition bound. */
        sps->bound = cxt->partbound;
    }
 
    /*
     * Open and lock the partition, check ownership along the way. We need to
     * use AccessExclusiveLock here because this split partition will be
     * detached, then dropped in ATExecSplitPartition.
     */
    splitPartOid = RangeVarGetRelidExtended(partcmd->name, AccessExclusiveLock,
                                            0, RangeVarCallbackOwnsRelation,
                                            NULL);
 
    checkPartition(parent, splitPartOid, false);
 
    switch (strategy)
    {
        case PARTITION_STRATEGY_LIST:
        case PARTITION_STRATEGY_RANGE:
            {
                foreach_node(SinglePartitionSpec, sps, splitlist)
                {
                    if (sps->bound->is_default)
                    {
                        if (default_index != -1)
                            ereport(ERROR,
                                    errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                    errmsg("DEFAULT partition should be one"),
                                    parser_errposition(cxt->pstate, sps->name->location));
 
                        default_index = foreach_current_index(sps);
                    }
                }
            }
            break;
 
        case PARTITION_STRATEGY_HASH:
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("partition of hash-partitioned table cannot be split"));
            break;
 
        default:
            elog(ERROR, "unexpected partition strategy: %d",
                 (int) key->strategy);
            break;
    }
 
    /* isSplitPartDefault: is the being split partition a DEFAULT partition? */
    isSplitPartDefault = (defaultPartOid == splitPartOid);
 
    if (isSplitPartDefault && default_index == -1)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                errmsg("can not split DEFAULT partition \"%s\"",
                       get_rel_name(splitPartOid)),
                errhint("To split DEFAULT partition one of the new partition msut be DEFAULT"),
                parser_errposition(cxt->pstate, ((SinglePartitionSpec *) linitial(splitlist))->name->location));
 
    /*
     * If the partition being split is not the DEFAULT partition, but the
     * DEFAULT partition exists, then none of the resulting split partitions
     * can be the DEFAULT.
     */
    if (!isSplitPartDefault && (default_index != -1) && OidIsValid(defaultPartOid))
    {
        SinglePartitionSpec *spsDef =
            (SinglePartitionSpec *) list_nth(splitlist, default_index);
 
        ereport(ERROR,
                errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                errmsg("can not split non-DEFAULT partition \"%s\"",
                       get_rel_name(splitPartOid)),
                errmsg("new partition cannot be DEFAULT because DEFAULT partition \"%s\" already exists",
                       get_rel_name(defaultPartOid)),
                parser_errposition(cxt->pstate, spsDef->name->location));
    }
 
    foreach(listptr, splitlist)
    {
        Oid         nspid;
        SinglePartitionSpec *sps = (SinglePartitionSpec *) lfirst(listptr);
        RangeVar   *name = sps->name;
 
        nspid = RangeVarGetCreationNamespace(sps->name);
 
        /* Partitions in the list should have different names. */
        for_each_cell(listptr2, splitlist, lnext(splitlist, listptr))
        {
            Oid         nspid2;
            SinglePartitionSpec *sps2 = (SinglePartitionSpec *) lfirst(listptr2);
            RangeVar   *name2 = sps2->name;
 
            if (equal(name, name2))
                ereport(ERROR,
                        errcode(ERRCODE_DUPLICATE_TABLE),
                        errmsg("partition with name \"%s\" is already used", name->relname),
                        parser_errposition(cxt->pstate, name2->location));
 
            nspid2 = RangeVarGetCreationNamespace(sps2->name);
 
            if (nspid2 == nspid && strcmp(name->relname, name2->relname) == 0)
                ereport(ERROR,
                        errcode(ERRCODE_DUPLICATE_TABLE),
                        errmsg("partition with name \"%s\" is already used", name->relname),
                        parser_errposition(cxt->pstate, name2->location));
        }
    }
 
    /* Then we should check partitions with transformed bounds. */
    check_partitions_for_split(parent, splitPartOid, splitlist, cxt->pstate);
}

References AccessExclusiveLock, check_partitions_for_split(), checkPartition(), elog, equal(), ereport, errcode(), errhint(), errmsg(), ERROR, fb(), for_each_cell, foreach_current_index, foreach_node, get_default_oid_from_partdesc(), get_partition_strategy(), get_rel_name(), lfirst, linitial, list_nth(), lnext(), name, nspid, OidIsValid, parser_errposition(), CreateStmtContext::partbound, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, CreateStmtContext::pstate, RangeVarCallbackOwnsRelation(), RangeVarGetCreationNamespace(), RangeVarGetRelidExtended(), CreateStmtContext::rel, RelationGetPartitionDesc(), RelationGetPartitionKey(), and transformPartitionCmd().

Referenced by transformAlterTableStmt().

◆ transformPartitionRangeBounds()

static List * transformPartitionRangeBounds	(	ParseState *	pstate,
		List *	blist,
		Relation	parent
	)

static

Definition at line 4751 of file parse_utilcmd.c.

{
    List       *result = NIL;
    PartitionKey key = RelationGetPartitionKey(parent);
    List       *partexprs = get_partition_exprs(key);
    ListCell   *lc;
    int         i,
                j;
 
    j = 0;
    foreach(lc, blist)
    {
        Node       *expr = lfirst(lc);
        PartitionRangeDatum *prd = NULL;
 
        i = foreach_current_index(lc);
 
        /*
         * Infinite range bounds -- "minvalue" and "maxvalue" -- get passed in
         * as ColumnRefs.
         */
        if (IsA(expr, ColumnRef))
        {
            ColumnRef  *cref = (ColumnRef *) expr;
            char       *cname = NULL;
 
            /*
             * There should be a single field named either "minvalue" or
             * "maxvalue".
             */
            if (list_length(cref->fields) == 1 &&
                IsA(linitial(cref->fields), String))
                cname = strVal(linitial(cref->fields));
 
            if (cname == NULL)
            {
                /*
                 * ColumnRef is not in the desired single-field-name form. For
                 * consistency between all partition strategies, let the
                 * expression transformation report any errors rather than
                 * doing it ourselves.
                 */
            }
            else if (strcmp("minvalue", cname) == 0)
            {
                prd = makeNode(PartitionRangeDatum);
                prd->kind = PARTITION_RANGE_DATUM_MINVALUE;
                prd->value = NULL;
            }
            else if (strcmp("maxvalue", cname) == 0)
            {
                prd = makeNode(PartitionRangeDatum);
                prd->kind = PARTITION_RANGE_DATUM_MAXVALUE;
                prd->value = NULL;
            }
        }
 
        if (prd == NULL)
        {
            char       *colname;
            Oid         coltype;
            int32       coltypmod;
            Oid         partcollation;
            Const      *value;
 
            /* Get the column's name in case we need to output an error */
            if (key->partattrs[i] != 0)
                colname = get_attname(RelationGetRelid(parent),
                                      key->partattrs[i], false);
            else
            {
                colname = deparse_expression((Node *) list_nth(partexprs, j),
                                             deparse_context_for(RelationGetRelationName(parent),
                                                                 RelationGetRelid(parent)),
                                             false, false);
                ++j;
            }
 
            /* Need its type data too */
            coltype = get_partition_col_typid(key, i);
            coltypmod = get_partition_col_typmod(key, i);
            partcollation = get_partition_col_collation(key, i);
 
            value = transformPartitionBoundValue(pstate, expr,
                                                 colname,
                                                 coltype, coltypmod,
                                                 partcollation);
            if (value->constisnull)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("cannot specify NULL in range bound")));
            prd = makeNode(PartitionRangeDatum);
            prd->kind = PARTITION_RANGE_DATUM_VALUE;
            prd->value = (Node *) value;
        }
 
        prd->location = exprLocation(expr);
 
        result = lappend(result, prd);
    }
 
    /*
     * Once we see MINVALUE or MAXVALUE for one column, the remaining columns
     * must be the same.
     */
    validateInfiniteBounds(pstate, result);
 
    return result;
}

References deparse_context_for(), deparse_expression(), ereport, errcode(), errmsg(), ERROR, exprLocation(), fb(), foreach_current_index, get_attname(), get_partition_col_collation(), get_partition_col_typid(), get_partition_col_typmod(), get_partition_exprs(), i, IsA, j, lappend(), lfirst, linitial, list_length(), list_nth(), makeNode, NIL, PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, PARTITION_RANGE_DATUM_VALUE, RelationGetPartitionKey(), RelationGetRelationName, RelationGetRelid, strVal, transformPartitionBoundValue(), validateInfiniteBounds(), and value.

Referenced by transformPartitionBound().

◆ transformRuleStmt()

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

Definition at line 3228 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
	)

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

◆ transformTableConstraint()

static void transformTableConstraint	(	CreateStmtContext *	cxt,
		Constraint *	constraint
	)

static

Definition at line 1038 of file parse_utilcmd.c.

{
    switch (constraint->contype)
    {
        case CONSTR_PRIMARY:
            if (cxt->isforeign)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("primary key constraints are not supported on foreign tables"),
                         parser_errposition(cxt->pstate,
                                            constraint->location)));
            cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
            break;
 
        case CONSTR_UNIQUE:
            if (cxt->isforeign)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("unique constraints are not supported on foreign tables"),
                         parser_errposition(cxt->pstate,
                                            constraint->location)));
            cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
            break;
 
        case CONSTR_EXCLUSION:
            if (cxt->isforeign)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("exclusion constraints are not supported on foreign tables"),
                         parser_errposition(cxt->pstate,
                                            constraint->location)));
            cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
            break;
 
        case CONSTR_CHECK:
            cxt->ckconstraints = lappend(cxt->ckconstraints, constraint);
            break;
 
        case CONSTR_NOTNULL:
            if (cxt->ispartitioned && constraint->is_no_inherit)
                ereport(ERROR,
                        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                        errmsg("not-null constraints on partitioned tables cannot be NO INHERIT"));
 
            cxt->nnconstraints = lappend(cxt->nnconstraints, constraint);
            break;
 
        case CONSTR_FOREIGN:
            if (cxt->isforeign)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("foreign key constraints are not supported on foreign tables"),
                         parser_errposition(cxt->pstate,
                                            constraint->location)));
            cxt->fkconstraints = lappend(cxt->fkconstraints, constraint);
            break;
 
        case CONSTR_NULL:
        case CONSTR_DEFAULT:
        case CONSTR_ATTR_DEFERRABLE:
        case CONSTR_ATTR_NOT_DEFERRABLE:
        case CONSTR_ATTR_DEFERRED:
        case CONSTR_ATTR_IMMEDIATE:
        case CONSTR_ATTR_ENFORCED:
        case CONSTR_ATTR_NOT_ENFORCED:
            elog(ERROR, "invalid context for constraint type %d",
                 constraint->contype);
            break;
 
        default:
            elog(ERROR, "unrecognized constraint type: %d",
                 constraint->contype);
            break;
    }
}

References CreateStmtContext::ckconstraints, CONSTR_ATTR_DEFERRABLE, CONSTR_ATTR_DEFERRED, CONSTR_ATTR_ENFORCED, CONSTR_ATTR_IMMEDIATE, CONSTR_ATTR_NOT_DEFERRABLE, CONSTR_ATTR_NOT_ENFORCED, CONSTR_CHECK, CONSTR_DEFAULT, CONSTR_EXCLUSION, CONSTR_FOREIGN, CONSTR_NOTNULL, CONSTR_NULL, CONSTR_PRIMARY, CONSTR_UNIQUE, Constraint::contype, elog, ereport, errcode(), errmsg(), ERROR, fb(), CreateStmtContext::fkconstraints, Constraint::is_no_inherit, CreateStmtContext::isforeign, CreateStmtContext::ispartitioned, CreateStmtContext::ixconstraints, lappend(), Constraint::location, CreateStmtContext::nnconstraints, parser_errposition(), and CreateStmtContext::pstate.

Referenced by transformAlterTableStmt(), and transformCreateStmt().

◆ transformTableLikeClause()

static void transformTableLikeClause	(	CreateStmtContext *	cxt,
		TableLikeClause *	table_like_clause
	)

static

Definition at line 1129 of file parse_utilcmd.c.

{
    AttrNumber  parent_attno;
    Relation    relation;
    TupleDesc   tupleDesc;
    AclResult   aclresult;
    char       *comment;
    ParseCallbackState pcbstate;
 
    setup_parser_errposition_callback(&pcbstate, cxt->pstate,
                                      table_like_clause->relation->location);
 
    /* Open the relation referenced by the LIKE clause */
    relation = relation_openrv(table_like_clause->relation, AccessShareLock);
 
    if (relation->rd_rel->relkind != RELKIND_RELATION &&
        relation->rd_rel->relkind != RELKIND_VIEW &&
        relation->rd_rel->relkind != RELKIND_MATVIEW &&
        relation->rd_rel->relkind != RELKIND_COMPOSITE_TYPE &&
        relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
        relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("relation \"%s\" is invalid in LIKE clause",
                        RelationGetRelationName(relation)),
                 errdetail_relkind_not_supported(relation->rd_rel->relkind)));
 
    cancel_parser_errposition_callback(&pcbstate);
 
    /*
     * Check for privileges
     */
    if (relation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
    {
        aclresult = object_aclcheck(TypeRelationId, relation->rd_rel->reltype, GetUserId(),
                                    ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TYPE,
                           RelationGetRelationName(relation));
    }
    else
    {
        aclresult = pg_class_aclcheck(RelationGetRelid(relation), GetUserId(),
                                      ACL_SELECT);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, get_relkind_objtype(relation->rd_rel->relkind),
                           RelationGetRelationName(relation));
    }
 
    tupleDesc = RelationGetDescr(relation);
 
    /*
     * Insert the copied attributes into the cxt for the new table definition.
     * We must do this now so that they appear in the table in the relative
     * position where the LIKE clause is, as required by SQL99.
     */
    for (parent_attno = 1; parent_attno <= tupleDesc->natts;
         parent_attno++)
    {
        Form_pg_attribute attribute = TupleDescAttr(tupleDesc,
                                                    parent_attno - 1);
        ColumnDef  *def;
 
        /*
         * Ignore dropped columns in the parent.
         */
        if (attribute->attisdropped)
            continue;
 
        /*
         * Create a new column definition
         */
        def = makeColumnDef(NameStr(attribute->attname), attribute->atttypid,
                            attribute->atttypmod, attribute->attcollation);
 
        /*
         * Add to column list
         */
        cxt->columns = lappend(cxt->columns, def);
 
        /*
         * Although we don't transfer the column's default/generation
         * expression now, we need to mark it GENERATED if appropriate.
         */
        if (attribute->atthasdef && attribute->attgenerated &&
            (table_like_clause->options & CREATE_TABLE_LIKE_GENERATED))
            def->generated = attribute->attgenerated;
 
        /*
         * Copy identity if requested
         */
        if (attribute->attidentity &&
            (table_like_clause->options & CREATE_TABLE_LIKE_IDENTITY) &&
            !cxt->isforeign)
        {
            Oid         seq_relid;
            List       *seq_options;
 
            /*
             * find sequence owned by old column; extract sequence parameters;
             * build new create sequence command
             */
            seq_relid = getIdentitySequence(relation, attribute->attnum, false);
            seq_options = sequence_options(seq_relid);
            generateSerialExtraStmts(cxt, def,
                                     InvalidOid, seq_options,
                                     true, false,
                                     NULL, NULL);
            def->identity = attribute->attidentity;
        }
 
        /* Likewise, copy storage if requested */
        if ((table_like_clause->options & CREATE_TABLE_LIKE_STORAGE) &&
            !cxt->isforeign)
            def->storage = attribute->attstorage;
        else
            def->storage = 0;
 
        /* Likewise, copy compression if requested */
        if ((table_like_clause->options & CREATE_TABLE_LIKE_COMPRESSION) != 0 &&
            CompressionMethodIsValid(attribute->attcompression) &&
            !cxt->isforeign)
            def->compression =
                pstrdup(GetCompressionMethodName(attribute->attcompression));
        else
            def->compression = NULL;
 
        /* Likewise, copy comment if requested */
        if ((table_like_clause->options & CREATE_TABLE_LIKE_COMMENTS) &&
            (comment = GetComment(attribute->attrelid,
                                  RelationRelationId,
                                  attribute->attnum)) != NULL)
        {
            CommentStmt *stmt = makeNode(CommentStmt);
 
            stmt->objtype = OBJECT_COLUMN;
            stmt->object = (Node *) list_make3(makeString(cxt->relation->schemaname),
                                               makeString(cxt->relation->relname),
                                               makeString(def->colname));
            stmt->comment = comment;
 
            cxt->alist = lappend(cxt->alist, stmt);
        }
    }
 
    /*
     * Reproduce not-null constraints, if any, by copying them.  We do this
     * regardless of options given.
     */
    if (tupleDesc->constr && tupleDesc->constr->has_not_null)
    {
        List       *lst;
 
        lst = RelationGetNotNullConstraints(RelationGetRelid(relation), false,
                                            true);
        cxt->nnconstraints = list_concat(cxt->nnconstraints, lst);
 
        /* Copy comments on not-null constraints */
        if (table_like_clause->options & CREATE_TABLE_LIKE_COMMENTS)
        {
            foreach_node(Constraint, nnconstr, lst)
            {
                if ((comment = GetComment(get_relation_constraint_oid(RelationGetRelid(relation),
                                                                      nnconstr->conname, false),
                                          ConstraintRelationId,
                                          0)) != NULL)
                {
                    CommentStmt *stmt = makeNode(CommentStmt);
 
                    stmt->objtype = OBJECT_TABCONSTRAINT;
                    stmt->object = (Node *) list_make3(makeString(cxt->relation->schemaname),
                                                       makeString(cxt->relation->relname),
                                                       makeString(nnconstr->conname));
                    stmt->comment = comment;
                    cxt->alist = lappend(cxt->alist, stmt);
                }
            }
        }
    }
 
    /*
     * We cannot yet deal with defaults, CHECK constraints, indexes, or
     * statistics, since we don't yet know what column numbers the copied
     * columns will have in the finished table.  If any of those options are
     * specified, add the LIKE clause to cxt->likeclauses so that
     * expandTableLikeClause will be called after we do know that.
     *
     * In order for this to work, we remember the relation OID so that
     * expandTableLikeClause is certain to open the same table.
     */
    if (table_like_clause->options &
        (CREATE_TABLE_LIKE_DEFAULTS |
         CREATE_TABLE_LIKE_GENERATED |
         CREATE_TABLE_LIKE_CONSTRAINTS |
         CREATE_TABLE_LIKE_INDEXES |
         CREATE_TABLE_LIKE_STATISTICS))
    {
        table_like_clause->relationOid = RelationGetRelid(relation);
        cxt->likeclauses = lappend(cxt->likeclauses, table_like_clause);
    }
 
    /*
     * 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 we can run expandTableLikeClause.
     */
    table_close(relation, NoLock);
}

References AccessShareLock, ACL_SELECT, ACL_USAGE, aclcheck_error(), ACLCHECK_OK, CreateStmtContext::alist, cancel_parser_errposition_callback(), ColumnDef::colname, CreateStmtContext::columns, comment, ColumnDef::compression, CompressionMethodIsValid, CREATE_TABLE_LIKE_COMMENTS, CREATE_TABLE_LIKE_COMPRESSION, CREATE_TABLE_LIKE_CONSTRAINTS, CREATE_TABLE_LIKE_DEFAULTS, CREATE_TABLE_LIKE_GENERATED, CREATE_TABLE_LIKE_IDENTITY, CREATE_TABLE_LIKE_INDEXES, CREATE_TABLE_LIKE_STATISTICS, CREATE_TABLE_LIKE_STORAGE, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, fb(), foreach_node, ColumnDef::generated, generateSerialExtraStmts(), get_relation_constraint_oid(), get_relkind_objtype(), GetComment(), GetCompressionMethodName(), getIdentitySequence(), GetUserId(), ColumnDef::identity, InvalidOid, CreateStmtContext::isforeign, lappend(), CreateStmtContext::likeclauses, list_concat(), list_make3, makeColumnDef(), makeNode, makeString(), NameStr, CreateStmtContext::nnconstraints, NoLock, object_aclcheck(), OBJECT_COLUMN, OBJECT_TABCONSTRAINT, OBJECT_TYPE, pg_class_aclcheck(), CreateStmtContext::pstate, pstrdup(), RelationData::rd_rel, CreateStmtContext::relation, relation_openrv(), RelationGetDescr, RelationGetNotNullConstraints(), RelationGetRelationName, RelationGetRelid, RangeVar::relname, RangeVar::schemaname, sequence_options(), setup_parser_errposition_callback(), stmt, ColumnDef::storage, table_close(), and TupleDescAttr().

Referenced by transformCreateStmt().

◆ validateInfiniteBounds()

static void validateInfiniteBounds	(	ParseState *	pstate,
		List *	blist
	)

static

Definition at line 4869 of file parse_utilcmd.c.

{
    ListCell   *lc;
    PartitionRangeDatumKind kind = PARTITION_RANGE_DATUM_VALUE;
 
    foreach(lc, blist)
    {
        PartitionRangeDatum *prd = lfirst_node(PartitionRangeDatum, lc);
 
        if (kind == prd->kind)
            continue;
 
        switch (kind)
        {
            case PARTITION_RANGE_DATUM_VALUE:
                kind = prd->kind;
                break;
 
            case PARTITION_RANGE_DATUM_MAXVALUE:
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("every bound following MAXVALUE must also be MAXVALUE"),
                         parser_errposition(pstate, exprLocation((Node *) prd))));
                break;
 
            case PARTITION_RANGE_DATUM_MINVALUE:
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("every bound following MINVALUE must also be MINVALUE"),
                         parser_errposition(pstate, exprLocation((Node *) prd))));
                break;
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, exprLocation(), fb(), lfirst_node, parser_errposition(), PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, and PARTITION_RANGE_DATUM_VALUE.

Referenced by transformPartitionRangeBounds().

Data Structures

Macros

Functions

Macro Definition Documentation

◆ SUPPORTS_ATTRS

Function Documentation

◆ checkPartition()

◆ expandTableLikeClause()

◆ generateClonedExtStatsStmt()

◆ generateClonedIndexStmt()

◆ generateSerialExtraStmts()

◆ get_collation()

◆ get_opclass()

◆ setSchemaName()

◆ transformAlterTableStmt()

◆ transformCheckConstraints()

◆ transformColumnDefinition()

◆ transformColumnType()

◆ transformConstraintAttrs()

◆ transformCreateSchemaStmtElements()

◆ transformCreateStmt()

◆ transformFKConstraints()

◆ transformIndexConstraint()

◆ transformIndexConstraints()

◆ transformIndexStmt()

◆ transformOfType()

◆ transformPartitionBound()

◆ transformPartitionBoundValue()

◆ transformPartitionCmd()

◆ transformPartitionCmdForMerge()

◆ transformPartitionCmdForSplit()

◆ transformPartitionRangeBounds()

◆ transformRuleStmt()

◆ transformStatsStmt()

◆ transformTableConstraint()

◆ transformTableLikeClause()

◆ validateInfiniteBounds()