/*-------------------------------------------------------------------------

 *

 * parse_utilcmd.c

 *    Perform parse analysis work for various utility commands

 *

 * Formerly we did this work during parse_analyze_*() in analyze.c.  However

 * that is fairly unsafe in the presence of querytree caching, since any

 * database state that we depend on in making the transformations might be

 * obsolete by the time the utility command is executed; and utility commands

 * have no infrastructure for holding locks or rechecking plan validity.

 * Hence these functions are now called at the start of execution of their

 * respective utility commands.

 *

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *  src/backend/parser/parse_utilcmd.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/amapi.h"

#include "access/attmap.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/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 "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"

/* State shared by transformCreateStmt and its subroutines */

typedef struct

{

  ParseState *pstate;     /* overall parser state */

  const char *stmtType;   /* "CREATE [FOREIGN] TABLE" or "ALTER TABLE" */

  RangeVar   *relation;   /* relation to create */

  Relation  rel;      /* opened/locked rel, if ALTER */

  List     *inhRelations; /* relations to inherit from */

  bool    isforeign;    /* true if CREATE/ALTER FOREIGN TABLE */

  bool    isalter;    /* true if altering existing table */

  List     *columns;    /* ColumnDef items */

  List     *ckconstraints;  /* CHECK constraints */

  List     *nnconstraints;  /* NOT NULL constraints */

  List     *fkconstraints;  /* FOREIGN KEY constraints */

  List     *ixconstraints;  /* index-creating constraints */

  List     *likeclauses;  /* LIKE clauses that need post-processing */

  List     *blist;      /* "before list" of things to do before

                 * creating the table */

  List     *alist;      /* "after list" of things to do after creating

                 * the table */

  IndexStmt  *pkey;     /* PRIMARY KEY index, if any */

  bool    ispartitioned;  /* true if table is partitioned */

  PartitionBoundSpec *partbound;  /* transformed FOR VALUES */

  bool    ofType;     /* true if statement contains OF typename */

} CreateStmtContext;

/* State shared by transformCreateSchemaStmtElements and its subroutines */

typedef struct

{

  ParseState *pstate;     /* overall parse state */

  const char *schemaname;   /* name of schema */

  List     *sequences;    /* CREATE SEQUENCE items */

  List     *tables;     /* CREATE TABLE items */

  List     *views;      /* CREATE VIEW items */

  List     *indexes;    /* CREATE INDEX items */

  List     *triggers;   /* CREATE TRIGGER items */

  List     *grants;     /* GRANT items */

  List     *foreign_keys; /* generated ALTER ADD FOREIGN KEY items */

} CreateSchemaStmtContext;

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(ParseState *pstate,

                   List *constraintList);

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

static void checkSchemaNameRV(CreateSchemaStmtContext *cxt, RangeVar *relation);

static CreateStmt *transformCreateSchemaCreateTable(ParseState *pstate,

                          CreateStmt *stmt,

                          List **fk_elements);

static void transformPartitionCmd(CreateStmtContext *cxt, PartitionCmd *cmd);

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

/*

 * transformCreateStmt -

 *    parse analysis for CREATE TABLE

 *

 * Returns a List of utility commands to be done in sequence.  One of these

 * will be the transformed CreateStmt, but there may be additional actions

 * to be done before and after the actual DefineRelation() call.

 * In addition to normal utility commands such as AlterTableStmt and

 * IndexStmt, the result list may contain TableLikeClause(s), representing

 * the need to perform additional parse analysis after DefineRelation().

 *

 * SQL allows constraints to be scattered all over, so thumb through

 * the columns and collect all constraints into one place.

 * If there are any implied indices (e.g. UNIQUE or PRIMARY KEY)

 * then expand those into multiple IndexStmt blocks.

 *    - thomas 1997-12-02

 */

List *

transformCreateStmt(CreateStmt *stmt, const char *queryString)

{

  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;

}

/*

 * generateSerialExtraStmts

 *    Generate CREATE SEQUENCE and ALTER SEQUENCE ... OWNED BY statements

 *    to create the sequence for a serial or identity column.

 *

 * This includes determining the name the sequence will have.  The caller

 * can ask to get back the name components by passing non-null pointers

 * for snamespace_p and sname_p.

 */

static void

generateSerialExtraStmts(CreateStmtContext *cxt, ColumnDef *column,

             Oid seqtypid, List *seqoptions,

             bool for_identity, bool col_exists,

             char **snamespace_p, char **sname_p)

{

  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;

}

/*

 * transformColumnDefinition -

 *    transform a single ColumnDef within CREATE TABLE

 *    Also used in ALTER TABLE ADD COLUMN

 */

static void

transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column)

{

  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->pstate, 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)

            ereport(ERROR,

                errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

                errmsg("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)));

        pg_fallthrough;

      case CONSTR_UNIQUE:

        if (cxt->isforeign)

          ereport(ERROR,

              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

               errmsg("unique constraints are not supported on foreign tables"),