src/backend/parser/parse_utilcmd.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * parse_utilcmd.c
   4  *        Perform parse analysis work for various utility commands
   5  *
   6  * Formerly we did this work during parse_analyze() in analyze.c.  However
   7  * that is fairly unsafe in the presence of querytree caching, since any
   8  * database state that we depend on in making the transformations might be
   9  * obsolete by the time the utility command is executed; and utility commands
  10  * have no infrastructure for holding locks or rechecking plan validity.
  11  * Hence these functions are now called at the start of execution of their
  12  * respective utility commands.
  13  *
  14  * NOTE: in general we must avoid scribbling on the passed-in raw parse
  15  * tree, since it might be in a plan cache.  The simplest solution is
  16  * a quick copyObject() call before manipulating the query tree.
  17  *
  18  *
  19  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
  20  * Portions Copyright (c) 1994, Regents of the University of California
  21  *
  22  *      src/backend/parser/parse_utilcmd.c
  23  *
  24  *-------------------------------------------------------------------------
  25  */
  26
  27 #include "postgres.h"
  28
  29 #include "access/genam.h"
  30 #include "access/heapam.h"
  31 #include "access/reloptions.h"
  32 #include "catalog/dependency.h"
  33 #include "catalog/heap.h"
  34 #include "catalog/index.h"
  35 #include "catalog/namespace.h"
  36 #include "catalog/pg_collation.h"
  37 #include "catalog/pg_constraint.h"
  38 #include "catalog/pg_opclass.h"
  39 #include "catalog/pg_operator.h"
  40 #include "catalog/pg_type.h"
  41 #include "commands/comment.h"
  42 #include "commands/defrem.h"
  43 #include "commands/tablecmds.h"
  44 #include "commands/tablespace.h"
  45 #include "miscadmin.h"
  46 #include "nodes/makefuncs.h"
  47 #include "nodes/nodeFuncs.h"
  48 #include "parser/analyze.h"
  49 #include "parser/parse_clause.h"
  50 #include "parser/parse_collate.h"
  51 #include "parser/parse_expr.h"
  52 #include "parser/parse_relation.h"
  53 #include "parser/parse_target.h"
  54 #include "parser/parse_type.h"
  55 #include "parser/parse_utilcmd.h"
  56 #include "parser/parser.h"
  57 #include "rewrite/rewriteManip.h"
  58 #include "storage/lock.h"
  59 #include "utils/acl.h"
  60 #include "utils/builtins.h"
  61 #include "utils/lsyscache.h"
  62 #include "utils/relcache.h"
  63 #include "utils/syscache.h"
  64 #include "utils/typcache.h"
  65
  66
  67 /* State shared by transformCreateStmt and its subroutines */
  68 typedef struct
  69 {
  70         ParseState *pstate;                     /* overall parser state */
  71         const char *stmtType;           /* "CREATE [FOREIGN] TABLE" or "ALTER TABLE" */
  72         RangeVar   *relation;           /* relation to create */
  73         Relation        rel;                    /* opened/locked rel, if ALTER */
  74         List       *inhRelations;       /* relations to inherit from */
  75         bool            isalter;                /* true if altering existing table */
  76         bool            hasoids;                /* does relation have an OID column? */
  77         List       *columns;            /* ColumnDef items */
  78         List       *ckconstraints;      /* CHECK constraints */
  79         List       *fkconstraints;      /* FOREIGN KEY constraints */
  80         List       *ixconstraints;      /* index-creating constraints */
  81         List       *inh_indexes;        /* cloned indexes from INCLUDING INDEXES */
  82         List       *blist;                      /* "before list" of things to do before
  83                                                                  * creating the table */
  84         List       *alist;                      /* "after list" of things to do after creating
  85                                                                  * the table */
  86         IndexStmt  *pkey;                       /* PRIMARY KEY index, if any */
  87 } CreateStmtContext;
  88
  89 /* State shared by transformCreateSchemaStmt and its subroutines */
  90 typedef struct
  91 {
  92         const char *stmtType;           /* "CREATE SCHEMA" or "ALTER SCHEMA" */
  93         char       *schemaname;         /* name of schema */
  94         char       *authid;                     /* owner of schema */
  95         List       *sequences;          /* CREATE SEQUENCE items */
  96         List       *tables;                     /* CREATE TABLE items */
  97         List       *views;                      /* CREATE VIEW items */
  98         List       *indexes;            /* CREATE INDEX items */
  99         List       *triggers;           /* CREATE TRIGGER items */
 100         List       *grants;                     /* GRANT items */
 101 } CreateSchemaStmtContext;
 102
 103
 104 static void transformColumnDefinition(CreateStmtContext *cxt,
 105                                                   ColumnDef *column);
 106 static void transformTableConstraint(CreateStmtContext *cxt,
 107                                                  Constraint *constraint);
 108 static void transformInhRelation(CreateStmtContext *cxt,
 109                                          InhRelation *inhrelation);
 110 static void transformOfType(CreateStmtContext *cxt,
 111                                 TypeName *ofTypename);
 112 static char *chooseIndexName(const RangeVar *relation, IndexStmt *index_stmt);
 113 static IndexStmt *generateClonedIndexStmt(CreateStmtContext *cxt,
 114                                                 Relation parent_index, AttrNumber *attmap);
 115 static List *get_collation(Oid collation, Oid actual_datatype);
 116 static List *get_opclass(Oid opclass, Oid actual_datatype);
 117 static void transformIndexConstraints(CreateStmtContext *cxt);
 118 static IndexStmt *transformIndexConstraint(Constraint *constraint,
 119                                                  CreateStmtContext *cxt);
 120 static void transformFKConstraints(CreateStmtContext *cxt,
 121                                            bool skipValidation,
 122                                            bool isAddConstraint);
 123 static void transformConstraintAttrs(CreateStmtContext *cxt,
 124                                                  List *constraintList);
 125 static void transformColumnType(CreateStmtContext *cxt, ColumnDef *column);
 126 static void setSchemaName(char *context_schema, char **stmt_schema_name);
 127
 128
 129 /*
 130  * transformCreateStmt -
 131  *        parse analysis for CREATE TABLE
 132  *
 133  * Returns a List of utility commands to be done in sequence.  One of these
 134  * will be the transformed CreateStmt, but there may be additional actions
 135  * to be done before and after the actual DefineRelation() call.
 136  *
 137  * SQL92 allows constraints to be scattered all over, so thumb through
 138  * the columns and collect all constraints into one place.
 139  * If there are any implied indices (e.g. UNIQUE or PRIMARY KEY)
 140  * then expand those into multiple IndexStmt blocks.
 141  *        - thomas 1997-12-02
 142  */
 143 List *
 144 transformCreateStmt(CreateStmt *stmt, const char *queryString)
 145 {
 146         ParseState *pstate;
 147         CreateStmtContext cxt;
 148         List       *result;
 149         List       *save_alist;
 150         ListCell   *elements;
 151
 152         /*
 153          * We must not scribble on the passed-in CreateStmt, so copy it.  (This is
 154          * overkill, but easy.)
 155          */
 156         stmt = (CreateStmt *) copyObject(stmt);
 157
 158         /*
 159          * If the target relation name isn't schema-qualified, make it so.  This
 160          * prevents some corner cases in which added-on rewritten commands might
 161          * think they should apply to other relations that have the same name and
 162          * are earlier in the search path.      But a local temp table is effectively
 163          * specified to be in pg_temp, so no need for anything extra in that case.
 164          */
 165         if (stmt->relation->schemaname == NULL
 166                 && stmt->relation->relpersistence != RELPERSISTENCE_TEMP)
 167         {
 168                 Oid                     namespaceid = RangeVarGetCreationNamespace(stmt->relation);
 169
 170                 stmt->relation->schemaname = get_namespace_name(namespaceid);
 171         }
 172
 173         /* Set up pstate and CreateStmtContext */
 174         pstate = make_parsestate(NULL);
 175         pstate->p_sourcetext = queryString;
 176
 177         cxt.pstate = pstate;
 178         if (IsA(stmt, CreateForeignTableStmt))
 179                 cxt.stmtType = "CREATE FOREIGN TABLE";
 180         else
 181                 cxt.stmtType = "CREATE TABLE";
 182         cxt.relation = stmt->relation;
 183         cxt.rel = NULL;
 184         cxt.inhRelations = stmt->inhRelations;
 185         cxt.isalter = false;
 186         cxt.columns = NIL;
 187         cxt.ckconstraints = NIL;
 188         cxt.fkconstraints = NIL;
 189         cxt.ixconstraints = NIL;
 190         cxt.inh_indexes = NIL;
 191         cxt.blist = NIL;
 192         cxt.alist = NIL;
 193         cxt.pkey = NULL;
 194         cxt.hasoids = interpretOidsOption(stmt->options);
 195
 196         Assert(!stmt->ofTypename || !stmt->inhRelations);       /* grammar enforces */
 197
 198         if (stmt->ofTypename)
 199                 transformOfType(&cxt, stmt->ofTypename);
 200
 201         /*
 202          * Run through each primary element in the table creation clause. Separate
 203          * column defs from constraints, and do preliminary analysis.
 204          */
 205         foreach(elements, stmt->tableElts)
 206         {
 207                 Node       *element = lfirst(elements);
 208
 209                 switch (nodeTag(element))
 210                 {
 211                         case T_ColumnDef:
 212                                 transformColumnDefinition(&cxt, (ColumnDef *) element);
 213                                 break;
 214
 215                         case T_Constraint:
 216                                 transformTableConstraint(&cxt, (Constraint *) element);
 217                                 break;
 218
 219                         case T_InhRelation:
 220                                 transformInhRelation(&cxt, (InhRelation *) element);
 221                                 break;
 222
 223                         default:
 224                                 elog(ERROR, "unrecognized node type: %d",
 225                                          (int) nodeTag(element));
 226                                 break;
 227                 }
 228         }
 229
 230         /*
 231          * transformIndexConstraints wants cxt.alist to contain only index
 232          * statements, so transfer anything we already have into save_alist.
 233          */
 234         save_alist = cxt.alist;
 235         cxt.alist = NIL;
 236
 237         Assert(stmt->constraints == NIL);
 238
 239         /*
 240          * Postprocess constraints that give rise to index definitions.
 241          */
 242         transformIndexConstraints(&cxt);
 243
 244         /*
 245          * Postprocess foreign-key constraints.
 246          */
 247         transformFKConstraints(&cxt, true, false);
 248
 249         /*
 250          * Output results.
 251          */
 252         stmt->tableElts = cxt.columns;
 253         stmt->constraints = cxt.ckconstraints;
 254
 255         result = lappend(cxt.blist, stmt);
 256         result = list_concat(result, cxt.alist);
 257         result = list_concat(result, save_alist);
 258
 259         return result;
 260 }
 261
 262 /*
 263  * transformColumnDefinition -
 264  *              transform a single ColumnDef within CREATE TABLE
 265  *              Also used in ALTER TABLE ADD COLUMN
 266  */
 267 static void
 268 transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column)
 269 {
 270         bool            is_serial;
 271         bool            saw_nullable;
 272         bool            saw_default;
 273         Constraint *constraint;
 274         ListCell   *clist;
 275
 276         cxt->columns = lappend(cxt->columns, column);
 277
 278         /* Check for SERIAL pseudo-types */
 279         is_serial = false;
 280         if (column->typeName
 281                 && list_length(column->typeName->names) == 1
 282                 && !column->typeName->pct_type)
 283         {
 284                 char       *typname = strVal(linitial(column->typeName->names));
 285
 286                 if (strcmp(typname, "serial") == 0 ||
 287                         strcmp(typname, "serial4") == 0)
 288                 {
 289                         is_serial = true;
 290                         column->typeName->names = NIL;
 291                         column->typeName->typeOid = INT4OID;
 292                 }
 293                 else if (strcmp(typname, "bigserial") == 0 ||
 294                                  strcmp(typname, "serial8") == 0)
 295                 {
 296                         is_serial = true;
 297                         column->typeName->names = NIL;
 298                         column->typeName->typeOid = INT8OID;
 299                 }
 300
 301                 /*
 302                  * We have to reject "serial[]" explicitly, because once we've set
 303                  * typeid, LookupTypeName won't notice arrayBounds.  We don't need any
 304                  * special coding for serial(typmod) though.
 305                  */
 306                 if (is_serial && column->typeName->arrayBounds != NIL)
 307                         ereport(ERROR,
 308                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 309                                          errmsg("array of serial is not implemented"),
 310                                          parser_errposition(cxt->pstate,
 311                                                                                 column->typeName->location)));
 312         }
 313
 314         /* Do necessary work on the column type declaration */
 315         if (column->typeName)
 316                 transformColumnType(cxt, column);
 317
 318         /* Special actions for SERIAL pseudo-types */
 319         if (is_serial)
 320         {
 321                 Oid                     snamespaceid;
 322                 char       *snamespace;
 323                 char       *sname;
 324                 char       *qstring;
 325                 A_Const    *snamenode;
 326                 TypeCast   *castnode;
 327                 FuncCall   *funccallnode;
 328                 CreateSeqStmt *seqstmt;
 329                 AlterSeqStmt *altseqstmt;
 330                 List       *attnamelist;
 331
 332                 /*
 333                  * Determine namespace and name to use for the sequence.
 334                  *
 335                  * Although we use ChooseRelationName, it's not guaranteed that the
 336                  * selected sequence name won't conflict; given sufficiently long
 337                  * field names, two different serial columns in the same table could
 338                  * be assigned the same sequence name, and we'd not notice since we
 339                  * aren't creating the sequence quite yet.  In practice this seems
 340                  * quite unlikely to be a problem, especially since few people would
 341                  * need two serial columns in one table.
 342                  */
 343                 if (cxt->rel)
 344                         snamespaceid = RelationGetNamespace(cxt->rel);
 345                 else
 346                         snamespaceid = RangeVarGetCreationNamespace(cxt->relation);
 347                 snamespace = get_namespace_name(snamespaceid);
 348                 sname = ChooseRelationName(cxt->relation->relname,
 349                                                                    column->colname,
 350                                                                    "seq",
 351                                                                    snamespaceid);
 352
 353                 ereport(NOTICE,
 354                                 (errmsg("%s will create implicit sequence \"%s\" for serial column \"%s.%s\"",
 355                                                 cxt->stmtType, sname,
 356                                                 cxt->relation->relname, column->colname)));
 357
 358                 /*
 359                  * Build a CREATE SEQUENCE command to create the sequence object, and
 360                  * add it to the list of things to be done before this CREATE/ALTER
 361                  * TABLE.
 362                  */
 363                 seqstmt = makeNode(CreateSeqStmt);
 364                 seqstmt->sequence = makeRangeVar(snamespace, sname, -1);
 365                 seqstmt->options = NIL;
 366
 367                 /*
 368                  * If this is ALTER ADD COLUMN, make sure the sequence will be owned
 369                  * by the table's owner.  The current user might be someone else
 370                  * (perhaps a superuser, or someone who's only a member of the owning
 371                  * role), but the SEQUENCE OWNED BY mechanisms will bleat unless table
 372                  * and sequence have exactly the same owning role.
 373                  */
 374                 if (cxt->rel)
 375                         seqstmt->ownerId = cxt->rel->rd_rel->relowner;
 376                 else
 377                         seqstmt->ownerId = InvalidOid;
 378
 379                 cxt->blist = lappend(cxt->blist, seqstmt);
 380
 381                 /*
 382                  * Build an ALTER SEQUENCE ... OWNED BY command to mark the sequence
 383                  * as owned by this column, and add it to the list of things to be
 384                  * done after this CREATE/ALTER TABLE.
 385                  */
 386                 altseqstmt = makeNode(AlterSeqStmt);
 387                 altseqstmt->sequence = makeRangeVar(snamespace, sname, -1);
 388                 attnamelist = list_make3(makeString(snamespace),
 389                                                                  makeString(cxt->relation->relname),
 390                                                                  makeString(column->colname));
 391                 altseqstmt->options = list_make1(makeDefElem("owned_by",
 392                                                                                                          (Node *) attnamelist));
 393
 394                 cxt->alist = lappend(cxt->alist, altseqstmt);
 395
 396                 /*
 397                  * Create appropriate constraints for SERIAL.  We do this in full,
 398                  * rather than shortcutting, so that we will detect any conflicting
 399                  * constraints the user wrote (like a different DEFAULT).
 400                  *
 401                  * Create an expression tree representing the function call
 402                  * nextval('sequencename').  We cannot reduce the raw tree to cooked
 403                  * form until after the sequence is created, but there's no need to do
 404                  * so.
 405                  */
 406                 qstring = quote_qualified_identifier(snamespace, sname);
 407                 snamenode = makeNode(A_Const);
 408                 snamenode->val.type = T_String;
 409                 snamenode->val.val.str = qstring;
 410                 snamenode->location = -1;
 411                 castnode = makeNode(TypeCast);
 412                 castnode->typeName = SystemTypeName("regclass");
 413                 castnode->arg = (Node *) snamenode;
 414                 castnode->location = -1;
 415                 funccallnode = makeNode(FuncCall);
 416                 funccallnode->funcname = SystemFuncName("nextval");
 417                 funccallnode->args = list_make1(castnode);
 418                 funccallnode->agg_order = NIL;
 419                 funccallnode->agg_star = false;
 420                 funccallnode->agg_distinct = false;
 421                 funccallnode->func_variadic = false;
 422                 funccallnode->over = NULL;
 423                 funccallnode->location = -1;
 424
 425                 constraint = makeNode(Constraint);
 426                 constraint->contype = CONSTR_DEFAULT;
 427                 constraint->location = -1;
 428                 constraint->raw_expr = (Node *) funccallnode;
 429                 constraint->cooked_expr = NULL;
 430                 column->constraints = lappend(column->constraints, constraint);
 431
 432                 constraint = makeNode(Constraint);
 433                 constraint->contype = CONSTR_NOTNULL;
 434                 constraint->location = -1;
 435                 column->constraints = lappend(column->constraints, constraint);
 436         }
 437
 438         /* Process column constraints, if any... */
 439         transformConstraintAttrs(cxt, column->constraints);
 440
 441         saw_nullable = false;
 442         saw_default = false;
 443
 444         foreach(clist, column->constraints)
 445         {
 446                 constraint = lfirst(clist);
 447                 Assert(IsA(constraint, Constraint));
 448
 449                 switch (constraint->contype)
 450                 {
 451                         case CONSTR_NULL:
 452                                 if (saw_nullable && column->is_not_null)
 453                                         ereport(ERROR,
 454                                                         (errcode(ERRCODE_SYNTAX_ERROR),
 455                                                          errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
 456                                                                         column->colname, cxt->relation->relname),
 457                                                          parser_errposition(cxt->pstate,
 458                                                                                                 constraint->location)));
 459                                 column->is_not_null = FALSE;
 460                                 saw_nullable = true;
 461                                 break;
 462
 463                         case CONSTR_NOTNULL:
 464                                 if (saw_nullable && !column->is_not_null)
 465                                         ereport(ERROR,
 466                                                         (errcode(ERRCODE_SYNTAX_ERROR),
 467                                                          errmsg("conflicting NULL/NOT NULL declarations for column \"%s\" of table \"%s\"",
 468                                                                         column->colname, cxt->relation->relname),
 469                                                          parser_errposition(cxt->pstate,
 470                                                                                                 constraint->location)));
 471                                 column->is_not_null = TRUE;
 472                                 saw_nullable = true;
 473                                 break;
 474
 475                         case CONSTR_DEFAULT:
 476                                 if (saw_default)
 477                                         ereport(ERROR,
 478                                                         (errcode(ERRCODE_SYNTAX_ERROR),
 479                                                          errmsg("multiple default values specified for column \"%s\" of table \"%s\"",
 480                                                                         column->colname, cxt->relation->relname),
 481                                                          parser_errposition(cxt->pstate,
 482                                                                                                 constraint->location)));
 483                                 column->raw_default = constraint->raw_expr;
 484                                 Assert(constraint->cooked_expr == NULL);
 485                                 saw_default = true;
 486                                 break;
 487
 488                         case CONSTR_CHECK:
 489                                 cxt->ckconstraints = lappend(cxt->ckconstraints, constraint);
 490                                 break;
 491
 492                         case CONSTR_PRIMARY:
 493                         case CONSTR_UNIQUE:
 494                                 if (constraint->keys == NIL)
 495                                         constraint->keys = list_make1(makeString(column->colname));
 496                                 cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
 497                                 break;
 498
 499                         case CONSTR_EXCLUSION:
 500                                 /* grammar does not allow EXCLUDE as a column constraint */
 501                                 elog(ERROR, "column exclusion constraints are not supported");
 502                                 break;
 503
 504                         case CONSTR_FOREIGN:
 505
 506                                 /*
 507                                  * Fill in the current attribute's name and throw it into the
 508                                  * list of FK constraints to be processed later.
 509                                  */
 510                                 constraint->fk_attrs = list_make1(makeString(column->colname));
 511                                 cxt->fkconstraints = lappend(cxt->fkconstraints, constraint);
 512                                 break;
 513
 514                         case CONSTR_ATTR_DEFERRABLE:
 515                         case CONSTR_ATTR_NOT_DEFERRABLE:
 516                         case CONSTR_ATTR_DEFERRED:
 517                         case CONSTR_ATTR_IMMEDIATE:
 518                                 /* transformConstraintAttrs took care of these */
 519                                 break;
 520
 521                         default:
 522                                 elog(ERROR, "unrecognized constraint type: %d",
 523                                          constraint->contype);
 524                                 break;
 525                 }
 526         }
 527 }
 528
 529 /*
 530  * transformTableConstraint
 531  *              transform a Constraint node within CREATE TABLE or ALTER TABLE
 532  */
 533 static void
 534 transformTableConstraint(CreateStmtContext *cxt, Constraint *constraint)
 535 {
 536         switch (constraint->contype)
 537         {
 538                 case CONSTR_PRIMARY:
 539                 case CONSTR_UNIQUE:
 540                 case CONSTR_EXCLUSION:
 541                         cxt->ixconstraints = lappend(cxt->ixconstraints, constraint);
 542                         break;
 543
 544                 case CONSTR_CHECK:
 545                         cxt->ckconstraints = lappend(cxt->ckconstraints, constraint);
 546                         break;
 547
 548                 case CONSTR_FOREIGN:
 549                         cxt->fkconstraints = lappend(cxt->fkconstraints, constraint);
 550                         break;
 551
 552                 case CONSTR_NULL:
 553                 case CONSTR_NOTNULL:
 554                 case CONSTR_DEFAULT:
 555                 case CONSTR_ATTR_DEFERRABLE:
 556                 case CONSTR_ATTR_NOT_DEFERRABLE:
 557                 case CONSTR_ATTR_DEFERRED:
 558                 case CONSTR_ATTR_IMMEDIATE:
 559                         elog(ERROR, "invalid context for constraint type %d",
 560                                  constraint->contype);
 561                         break;
 562
 563                 default:
 564                         elog(ERROR, "unrecognized constraint type: %d",
 565                                  constraint->contype);
 566                         break;
 567         }
 568 }
 569
 570 /*
 571  * transformInhRelation
 572  *
 573  * Change the LIKE <subtable> portion of a CREATE TABLE statement into
 574  * column definitions which recreate the user defined column portions of
 575  * <subtable>.
 576  */
 577 static void
 578 transformInhRelation(CreateStmtContext *cxt, InhRelation *inhRelation)
 579 {
 580         AttrNumber      parent_attno;
 581         Relation        relation;
 582         TupleDesc       tupleDesc;
 583         TupleConstr *constr;
 584         AclResult       aclresult;
 585         char       *comment;
 586
 587         relation = parserOpenTable(cxt->pstate, inhRelation->relation,
 588                                                            AccessShareLock);
 589
 590         if (relation->rd_rel->relkind != RELKIND_RELATION)
 591                 ereport(ERROR,
 592                                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 593                                  errmsg("inherited relation \"%s\" is not a table",
 594                                                 inhRelation->relation->relname)));
 595
 596         /*
 597          * Check for SELECT privilages
 598          */
 599         aclresult = pg_class_aclcheck(RelationGetRelid(relation), GetUserId(),
 600                                                                   ACL_SELECT);
 601         if (aclresult != ACLCHECK_OK)
 602                 aclcheck_error(aclresult, ACL_KIND_CLASS,
 603                                            RelationGetRelationName(relation));
 604
 605         tupleDesc = RelationGetDescr(relation);
 606         constr = tupleDesc->constr;
 607
 608         /*
 609          * Insert the copied attributes into the cxt for the new table definition.
 610          */
 611         for (parent_attno = 1; parent_attno <= tupleDesc->natts;
 612                  parent_attno++)
 613         {
 614                 Form_pg_attribute attribute = tupleDesc->attrs[parent_attno - 1];
 615                 char       *attributeName = NameStr(attribute->attname);
 616                 ColumnDef  *def;
 617
 618                 /*
 619                  * Ignore dropped columns in the parent.
 620                  */
 621                 if (attribute->attisdropped)
 622                         continue;
 623
 624                 /*
 625                  * Create a new column, which is marked as NOT inherited.
 626                  *
 627                  * For constraints, ONLY the NOT NULL constraint is inherited by the
 628                  * new column definition per SQL99.
 629                  */
 630                 def = makeNode(ColumnDef);
 631                 def->colname = pstrdup(attributeName);
 632                 def->typeName = makeTypeNameFromOid(attribute->atttypid,
 633                                                                                         attribute->atttypmod);
 634                 def->inhcount = 0;
 635                 def->is_local = true;
 636                 def->is_not_null = attribute->attnotnull;
 637                 def->is_from_type = false;
 638                 def->storage = 0;
 639                 def->raw_default = NULL;
 640                 def->cooked_default = NULL;
 641                 def->collClause = NULL;
 642                 def->collOid = attribute->attcollation;
 643                 def->constraints = NIL;
 644
 645                 /*
 646                  * Add to column list
 647                  */
 648                 cxt->columns = lappend(cxt->columns, def);
 649
 650                 /*
 651                  * Copy default, if present and the default has been requested
 652                  */
 653                 if (attribute->atthasdef &&
 654                         (inhRelation->options & CREATE_TABLE_LIKE_DEFAULTS))
 655                 {
 656                         Node       *this_default = NULL;
 657                         AttrDefault *attrdef;
 658                         int                     i;
 659
 660                         /* Find default in constraint structure */
 661                         Assert(constr != NULL);
 662                         attrdef = constr->defval;
 663                         for (i = 0; i < constr->num_defval; i++)
 664                         {
 665                                 if (attrdef[i].adnum == parent_attno)
 666                                 {
 667                                         this_default = stringToNode(attrdef[i].adbin);
 668                                         break;
 669                                 }
 670                         }
 671                         Assert(this_default != NULL);
 672
 673                         /*
 674                          * If default expr could contain any vars, we'd need to fix 'em,
 675                          * but it can't; so default is ready to apply to child.
 676                          */
 677
 678                         def->cooked_default = this_default;
 679                 }
 680
 681                 /* Likewise, copy storage if requested */
 682                 if (inhRelation->options & CREATE_TABLE_LIKE_STORAGE)
 683                         def->storage = attribute->attstorage;
 684                 else
 685                         def->storage = 0;
 686
 687                 /* Likewise, copy comment if requested */
 688                 if ((inhRelation->options & CREATE_TABLE_LIKE_COMMENTS) &&
 689                         (comment = GetComment(attribute->attrelid,
 690                                                                   RelationRelationId,
 691                                                                   attribute->attnum)) != NULL)
 692                 {
 693                         CommentStmt *stmt = makeNode(CommentStmt);
 694
 695                         stmt->objtype = OBJECT_COLUMN;
 696                         stmt->objname = list_make3(makeString(cxt->relation->schemaname),
 697                                                                            makeString(cxt->relation->relname),
 698                                                                            makeString(def->colname));
 699                         stmt->objargs = NIL;
 700                         stmt->comment = comment;
 701
 702                         cxt->alist = lappend(cxt->alist, stmt);
 703                 }
 704         }
 705
 706         /*
 707          * Copy CHECK constraints if requested, being careful to adjust attribute
 708          * numbers
 709          */
 710         if ((inhRelation->options & CREATE_TABLE_LIKE_CONSTRAINTS) &&
 711                 tupleDesc->constr)
 712         {
 713                 AttrNumber *attmap = varattnos_map_schema(tupleDesc, cxt->columns);
 714                 int                     ccnum;
 715
 716                 for (ccnum = 0; ccnum < tupleDesc->constr->num_check; ccnum++)
 717                 {
 718                         char       *ccname = tupleDesc->constr->check[ccnum].ccname;
 719                         char       *ccbin = tupleDesc->constr->check[ccnum].ccbin;
 720                         Node       *ccbin_node = stringToNode(ccbin);
 721                         Constraint *n = makeNode(Constraint);
 722
 723                         change_varattnos_of_a_node(ccbin_node, attmap);
 724
 725                         n->contype = CONSTR_CHECK;
 726                         n->location = -1;
 727                         n->conname = pstrdup(ccname);
 728                         n->raw_expr = NULL;
 729                         n->cooked_expr = nodeToString(ccbin_node);
 730                         cxt->ckconstraints = lappend(cxt->ckconstraints, n);
 731
 732                         /* Copy comment on constraint */
 733                         if ((inhRelation->options & CREATE_TABLE_LIKE_COMMENTS) &&
 734                                 (comment = GetComment(get_constraint_oid(RelationGetRelid(relation),
 735                                                                                                                  n->conname, false),
 736                                                                           ConstraintRelationId,
 737                                                                           0)) != NULL)
 738                         {
 739                                 CommentStmt *stmt = makeNode(CommentStmt);
 740
 741                                 stmt->objtype = OBJECT_CONSTRAINT;
 742                                 stmt->objname = list_make3(makeString(cxt->relation->schemaname),
 743                                                                                    makeString(cxt->relation->relname),
 744                                                                                    makeString(n->conname));
 745                                 stmt->objargs = NIL;
 746                                 stmt->comment = comment;
 747
 748                                 cxt->alist = lappend(cxt->alist, stmt);
 749                         }
 750                 }
 751         }
 752
 753         /*
 754          * Likewise, copy indexes if requested
 755          */
 756         if ((inhRelation->options & CREATE_TABLE_LIKE_INDEXES) &&
 757                 relation->rd_rel->relhasindex)
 758         {
 759                 AttrNumber *attmap = varattnos_map_schema(tupleDesc, cxt->columns);
 760                 List       *parent_indexes;
 761                 ListCell   *l;
 762
 763                 parent_indexes = RelationGetIndexList(relation);
 764
 765                 foreach(l, parent_indexes)
 766                 {
 767                         Oid                     parent_index_oid = lfirst_oid(l);
 768                         Relation        parent_index;
 769                         IndexStmt  *index_stmt;
 770
 771                         parent_index = index_open(parent_index_oid, AccessShareLock);
 772
 773                         /* Build CREATE INDEX statement to recreate the parent_index */
 774                         index_stmt = generateClonedIndexStmt(cxt, parent_index, attmap);
 775
 776                         /* Copy comment on index */
 777                         if (inhRelation->options & CREATE_TABLE_LIKE_COMMENTS)
 778                         {
 779                                 comment = GetComment(parent_index_oid, RelationRelationId, 0);
 780
 781                                 if (comment != NULL)
 782                                 {
 783                                         CommentStmt *stmt;
 784
 785                                         /*
 786                                          * We have to assign the index a name now, so that we can
 787                                          * reference it in CommentStmt.
 788                                          */
 789                                         if (index_stmt->idxname == NULL)
 790                                                 index_stmt->idxname = chooseIndexName(cxt->relation,
 791                                                                                                                           index_stmt);
 792
 793                                         stmt = makeNode(CommentStmt);
 794                                         stmt->objtype = OBJECT_INDEX;
 795                                         stmt->objname =
 796                                                 list_make2(makeString(cxt->relation->schemaname),
 797                                                                    makeString(index_stmt->idxname));
 798                                         stmt->objargs = NIL;
 799                                         stmt->comment = comment;
 800
 801                                         cxt->alist = lappend(cxt->alist, stmt);
 802                                 }
 803                         }
 804
 805                         /* Save it in the inh_indexes list for the time being */
 806                         cxt->inh_indexes = lappend(cxt->inh_indexes, index_stmt);
 807
 808                         index_close(parent_index, AccessShareLock);
 809                 }
 810         }
 811
 812         /*
 813          * Close the parent rel, but keep our AccessShareLock on it until xact
 814          * commit.      That will prevent someone else from deleting or ALTERing the
 815          * parent before the child is committed.
 816          */
 817         heap_close(relation, NoLock);
 818 }
 819
 820 static void
 821 transformOfType(CreateStmtContext *cxt, TypeName *ofTypename)
 822 {
 823         HeapTuple       tuple;
 824         Form_pg_type typ;
 825         TupleDesc       tupdesc;
 826         int                     i;
 827         Oid                     ofTypeId;
 828
 829         AssertArg(ofTypename);
 830
 831         tuple = typenameType(NULL, ofTypename, NULL);
 832         typ = (Form_pg_type) GETSTRUCT(tuple);
 833         ofTypeId = HeapTupleGetOid(tuple);
 834         ofTypename->typeOid = ofTypeId;         /* cached for later */
 835
 836         if (typ->typtype != TYPTYPE_COMPOSITE)
 837                 ereport(ERROR,
 838                                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 839                                  errmsg("type %s is not a composite type",
 840                                                 format_type_be(ofTypeId))));
 841
 842         tupdesc = lookup_rowtype_tupdesc(ofTypeId, -1);
 843         for (i = 0; i < tupdesc->natts; i++)
 844         {
 845                 Form_pg_attribute attr = tupdesc->attrs[i];
 846                 ColumnDef  *n;
 847
 848                 if (attr->attisdropped)
 849                         continue;
 850
 851                 n = makeNode(ColumnDef);
 852                 n->colname = pstrdup(NameStr(attr->attname));
 853                 n->typeName = makeTypeNameFromOid(attr->atttypid, attr->atttypmod);
 854                 n->inhcount = 0;
 855                 n->is_local = true;
 856                 n->is_not_null = false;
 857                 n->is_from_type = true;
 858                 n->storage = 0;
 859                 n->raw_default = NULL;
 860                 n->cooked_default = NULL;
 861                 n->collClause = NULL;
 862                 n->collOid = attr->attcollation;
 863                 n->constraints = NIL;
 864                 cxt->columns = lappend(cxt->columns, n);
 865         }
 866         DecrTupleDescRefCount(tupdesc);
 867
 868         ReleaseSysCache(tuple);
 869 }
 870
 871 /*
 872  * chooseIndexName
 873  *
 874  * Compute name for an index.  This must match code in indexcmds.c.
 875  *
 876  * XXX this is inherently broken because the indexes aren't created
 877  * immediately, so we fail to resolve conflicts when the same name is
 878  * derived for multiple indexes.  However, that's a reasonably uncommon
 879  * situation, so we'll live with it for now.
 880  */
 881 static char *
 882 chooseIndexName(const RangeVar *relation, IndexStmt *index_stmt)
 883 {
 884         Oid                     namespaceId;
 885         List       *colnames;
 886
 887         namespaceId = RangeVarGetCreationNamespace(relation);
 888         colnames = ChooseIndexColumnNames(index_stmt->indexParams);
 889         return ChooseIndexName(relation->relname, namespaceId,
 890                                                    colnames, index_stmt->excludeOpNames,
 891                                                    index_stmt->primary, index_stmt->isconstraint);
 892 }
 893
 894 /*
 895  * Generate an IndexStmt node using information from an already existing index
 896  * "source_idx".  Attribute numbers should be adjusted according to attmap.
 897  */
 898 static IndexStmt *
 899 generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
 900                                                 AttrNumber *attmap)
 901 {
 902         Oid                     source_relid = RelationGetRelid(source_idx);
 903         Form_pg_attribute *attrs = RelationGetDescr(source_idx)->attrs;
 904         HeapTuple       ht_idxrel;
 905         HeapTuple       ht_idx;
 906         Form_pg_class idxrelrec;
 907         Form_pg_index idxrec;
 908         Form_pg_am      amrec;
 909         oidvector  *indcollation;
 910         oidvector  *indclass;
 911         IndexStmt  *index;
 912         List       *indexprs;
 913         ListCell   *indexpr_item;
 914         Oid                     indrelid;
 915         int                     keyno;
 916         Oid                     keycoltype;
 917         Datum           datum;
 918         bool            isnull;
 919
 920         /*
 921          * Fetch pg_class tuple of source index.  We can't use the copy in the
 922          * relcache entry because it doesn't include optional fields.
 923          */
 924         ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(source_relid));
 925         if (!HeapTupleIsValid(ht_idxrel))
 926                 elog(ERROR, "cache lookup failed for relation %u", source_relid);
 927         idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
 928
 929         /* Fetch pg_index tuple for source index from relcache entry */
 930         ht_idx = source_idx->rd_indextuple;
 931         idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
 932         indrelid = idxrec->indrelid;
 933
 934         /* Fetch pg_am tuple for source index from relcache entry */
 935         amrec = source_idx->rd_am;
 936
 937         /* Extract indcollation from the pg_index tuple */
 938         datum = SysCacheGetAttr(INDEXRELID, ht_idx,
 939                                                         Anum_pg_index_indcollation, &isnull);
 940         Assert(!isnull);
 941         indcollation = (oidvector *) DatumGetPointer(datum);
 942
 943         /* Extract indclass from the pg_index tuple */
 944         datum = SysCacheGetAttr(INDEXRELID, ht_idx,
 945                                                         Anum_pg_index_indclass, &isnull);
 946         Assert(!isnull);
 947         indclass = (oidvector *) DatumGetPointer(datum);
 948
 949         /* Begin building the IndexStmt */
 950         index = makeNode(IndexStmt);
 951         index->relation = cxt->relation;
 952         index->accessMethod = pstrdup(NameStr(amrec->amname));
 953         if (OidIsValid(idxrelrec->reltablespace))
 954                 index->tableSpace = get_tablespace_name(idxrelrec->reltablespace);
 955         else
 956                 index->tableSpace = NULL;
 957         index->indexOid = InvalidOid;
 958         index->unique = idxrec->indisunique;
 959         index->primary = idxrec->indisprimary;
 960         index->concurrent = false;
 961
 962         /*
 963          * We don't try to preserve the name of the source index; instead, just
 964          * let DefineIndex() choose a reasonable name.
 965          */
 966         index->idxname = NULL;
 967
 968         /*
 969          * If the index is marked PRIMARY or has an exclusion condition, it's
 970          * certainly from a constraint; else, if it's not marked UNIQUE, it
 971          * certainly isn't.  If it is or might be from a constraint, we have to
 972          * fetch the pg_constraint record.
 973          */
 974         if (index->primary || index->unique || idxrec->indisexclusion)
 975         {
 976                 Oid                     constraintId = get_index_constraint(source_relid);
 977
 978                 if (OidIsValid(constraintId))
 979                 {
 980                         HeapTuple       ht_constr;
 981                         Form_pg_constraint conrec;
 982
 983                         ht_constr = SearchSysCache1(CONSTROID,
 984                                                                                 ObjectIdGetDatum(constraintId));
 985                         if (!HeapTupleIsValid(ht_constr))
 986                                 elog(ERROR, "cache lookup failed for constraint %u",
 987                                          constraintId);
 988                         conrec = (Form_pg_constraint) GETSTRUCT(ht_constr);
 989
 990                         index->isconstraint = true;
 991                         index->deferrable = conrec->condeferrable;
 992                         index->initdeferred = conrec->condeferred;
 993
 994                         /* If it's an exclusion constraint, we need the operator names */
 995                         if (idxrec->indisexclusion)
 996                         {
 997                                 Datum      *elems;
 998                                 int                     nElems;
 999                                 int                     i;
1000
1001                                 Assert(conrec->contype == CONSTRAINT_EXCLUSION);
1002                                 /* Extract operator OIDs from the pg_constraint tuple */
1003                                 datum = SysCacheGetAttr(CONSTROID, ht_constr,
1004                                                                                 Anum_pg_constraint_conexclop,
1005                                                                                 &isnull);
1006                                 if (isnull)
1007                                         elog(ERROR, "null conexclop for constraint %u",
1008                                                  constraintId);
1009
1010                                 deconstruct_array(DatumGetArrayTypeP(datum),
1011                                                                   OIDOID, sizeof(Oid), true, 'i',
1012                                                                   &elems, NULL, &nElems);
1013
1014                                 for (i = 0; i < nElems; i++)
1015                                 {
1016                                         Oid                     operid = DatumGetObjectId(elems[i]);
1017                                         HeapTuple       opertup;
1018                                         Form_pg_operator operform;
1019                                         char       *oprname;
1020                                         char       *nspname;
1021                                         List       *namelist;
1022
1023                                         opertup = SearchSysCache1(OPEROID,
1024                                                                                           ObjectIdGetDatum(operid));
1025                                         if (!HeapTupleIsValid(opertup))
1026                                                 elog(ERROR, "cache lookup failed for operator %u",
1027                                                          operid);
1028                                         operform = (Form_pg_operator) GETSTRUCT(opertup);
1029                                         oprname = pstrdup(NameStr(operform->oprname));
1030                                         /* For simplicity we always schema-qualify the op name */
1031                                         nspname = get_namespace_name(operform->oprnamespace);
1032                                         namelist = list_make2(makeString(nspname),
1033                                                                                   makeString(oprname));
1034                                         index->excludeOpNames = lappend(index->excludeOpNames,
1035                                                                                                         namelist);
1036                                         ReleaseSysCache(opertup);
1037                                 }
1038                         }
1039
1040                         ReleaseSysCache(ht_constr);
1041                 }
1042                 else
1043                         index->isconstraint = false;
1044         }
1045         else
1046                 index->isconstraint = false;
1047
1048         /* Get the index expressions, if any */
1049         datum = SysCacheGetAttr(INDEXRELID, ht_idx,
1050                                                         Anum_pg_index_indexprs, &isnull);
1051         if (!isnull)
1052         {
1053                 char       *exprsString;
1054
1055                 exprsString = TextDatumGetCString(datum);
1056                 indexprs = (List *) stringToNode(exprsString);
1057         }
1058         else
1059                 indexprs = NIL;
1060
1061         /* Build the list of IndexElem */
1062         index->indexParams = NIL;
1063
1064         indexpr_item = list_head(indexprs);
1065         for (keyno = 0; keyno < idxrec->indnatts; keyno++)
1066         {
1067                 IndexElem  *iparam;
1068                 AttrNumber      attnum = idxrec->indkey.values[keyno];
1069                 int16           opt = source_idx->rd_indoption[keyno];
1070
1071                 iparam = makeNode(IndexElem);
1072
1073                 if (AttributeNumberIsValid(attnum))
1074                 {
1075                         /* Simple index column */
1076                         char       *attname;
1077
1078                         attname = get_relid_attribute_name(indrelid, attnum);
1079                         keycoltype = get_atttype(indrelid, attnum);
1080
1081                         iparam->name = attname;
1082                         iparam->expr = NULL;
1083                 }
1084                 else
1085                 {
1086                         /* Expressional index */
1087                         Node       *indexkey;
1088
1089                         if (indexpr_item == NULL)
1090                                 elog(ERROR, "too few entries in indexprs list");
1091                         indexkey = (Node *) lfirst(indexpr_item);
1092                         indexpr_item = lnext(indexpr_item);
1093
1094                         /* OK to modify indexkey since we are working on a private copy */
1095                         change_varattnos_of_a_node(indexkey, attmap);
1096
1097                         iparam->name = NULL;
1098                         iparam->expr = indexkey;
1099
1100                         keycoltype = exprType(indexkey);
1101                 }
1102
1103                 /* Copy the original index column name */
1104                 iparam->indexcolname = pstrdup(NameStr(attrs[keyno]->attname));
1105
1106                 /* Add the collation name, if non-default */
1107                 iparam->collation = get_collation(indcollation->values[keyno], keycoltype);
1108
1109                 /* Add the operator class name, if non-default */
1110                 iparam->opclass = get_opclass(indclass->values[keyno], keycoltype);
1111
1112                 iparam->ordering = SORTBY_DEFAULT;
1113                 iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
1114
1115                 /* Adjust options if necessary */
1116                 if (amrec->amcanorder)
1117                 {
1118                         /*
1119                          * If it supports sort ordering, copy DESC and NULLS opts. Don't
1120                          * set non-default settings unnecessarily, though, so as to
1121                          * improve the chance of recognizing equivalence to constraint
1122                          * indexes.
1123                          */
1124                         if (opt & INDOPTION_DESC)
1125                         {
1126                                 iparam->ordering = SORTBY_DESC;
1127                                 if ((opt & INDOPTION_NULLS_FIRST) == 0)
1128                                         iparam->nulls_ordering = SORTBY_NULLS_LAST;
1129                         }
1130                         else
1131                         {
1132                                 if (opt & INDOPTION_NULLS_FIRST)
1133                                         iparam->nulls_ordering = SORTBY_NULLS_FIRST;
1134                         }
1135                 }
1136
1137                 index->indexParams = lappend(index->indexParams, iparam);
1138         }
1139
1140         /* Copy reloptions if any */
1141         datum = SysCacheGetAttr(RELOID, ht_idxrel,
1142                                                         Anum_pg_class_reloptions, &isnull);
1143         if (!isnull)
1144                 index->options = untransformRelOptions(datum);
1145
1146         /* If it's a partial index, decompile and append the predicate */
1147         datum = SysCacheGetAttr(INDEXRELID, ht_idx,
1148                                                         Anum_pg_index_indpred, &isnull);
1149         if (!isnull)
1150         {
1151                 char       *pred_str;
1152
1153                 /* Convert text string to node tree */
1154                 pred_str = TextDatumGetCString(datum);
1155                 index->whereClause = (Node *) stringToNode(pred_str);
1156                 /* Adjust attribute numbers */
1157                 change_varattnos_of_a_node(index->whereClause, attmap);
1158         }
1159
1160         /* Clean up */
1161         ReleaseSysCache(ht_idxrel);
1162
1163         return index;
1164 }
1165
1166 /*
1167  * get_collation                - fetch qualified name of a collation
1168  *
1169  * If collation is InvalidOid or is the default for the given actual_datatype,
1170  * then the return value is NIL.
1171  */
1172 static List *
1173 get_collation(Oid collation, Oid actual_datatype)
1174 {
1175         List       *result;
1176         HeapTuple       ht_coll;
1177         Form_pg_collation coll_rec;
1178         char       *nsp_name;
1179         char       *coll_name;
1180
1181         if (!OidIsValid(collation))
1182                 return NIL;                             /* easy case */
1183         if (collation == get_typcollation(actual_datatype))
1184                 return NIL;                             /* just let it default */
1185
1186         ht_coll = SearchSysCache1(COLLOID, ObjectIdGetDatum(collation));
1187         if (!HeapTupleIsValid(ht_coll))
1188                 elog(ERROR, "cache lookup failed for collation %u", collation);
1189         coll_rec = (Form_pg_collation) GETSTRUCT(ht_coll);
1190
1191         /* For simplicity, we always schema-qualify the name */
1192         nsp_name = get_namespace_name(coll_rec->collnamespace);
1193         coll_name = pstrdup(NameStr(coll_rec->collname));
1194         result = list_make2(makeString(nsp_name), makeString(coll_name));
1195
1196         ReleaseSysCache(ht_coll);
1197         return result;
1198 }
1199
1200 /*
1201  * get_opclass                  - fetch qualified name of an index operator class
1202  *
1203  * If the opclass is the default for the given actual_datatype, then
1204  * the return value is NIL.
1205  */
1206 static List *
1207 get_opclass(Oid opclass, Oid actual_datatype)
1208 {
1209         List       *result = NIL;
1210         HeapTuple       ht_opc;
1211         Form_pg_opclass opc_rec;
1212
1213         ht_opc = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
1214         if (!HeapTupleIsValid(ht_opc))
1215                 elog(ERROR, "cache lookup failed for opclass %u", opclass);
1216         opc_rec = (Form_pg_opclass) GETSTRUCT(ht_opc);
1217
1218         if (GetDefaultOpClass(actual_datatype, opc_rec->opcmethod) != opclass)
1219         {
1220                 /* For simplicity, we always schema-qualify the name */
1221                 char       *nsp_name = get_namespace_name(opc_rec->opcnamespace);
1222                 char       *opc_name = pstrdup(NameStr(opc_rec->opcname));
1223
1224                 result = list_make2(makeString(nsp_name), makeString(opc_name));
1225         }
1226
1227         ReleaseSysCache(ht_opc);
1228         return result;
1229 }
1230
1231
1232 /*
1233  * transformIndexConstraints
1234  *              Handle UNIQUE, PRIMARY KEY, EXCLUDE constraints, which create indexes.
1235  *              We also merge in any index definitions arising from
1236  *              LIKE ... INCLUDING INDEXES.
1237  */
1238 static void
1239 transformIndexConstraints(CreateStmtContext *cxt)
1240 {
1241         IndexStmt  *index;
1242         List       *indexlist = NIL;
1243         ListCell   *lc;
1244
1245         /*
1246          * Run through the constraints that need to generate an index. For PRIMARY
1247          * KEY, mark each column as NOT NULL and create an index. For UNIQUE or
1248          * EXCLUDE, create an index as for PRIMARY KEY, but do not insist on NOT
1249          * NULL.
1250          */
1251         foreach(lc, cxt->ixconstraints)
1252         {
1253                 Constraint *constraint = (Constraint *) lfirst(lc);
1254
1255                 Assert(IsA(constraint, Constraint));
1256                 Assert(constraint->contype == CONSTR_PRIMARY ||
1257                            constraint->contype == CONSTR_UNIQUE ||
1258                            constraint->contype == CONSTR_EXCLUSION);
1259
1260                 index = transformIndexConstraint(constraint, cxt);
1261
1262                 indexlist = lappend(indexlist, index);
1263         }
1264
1265         /* Add in any indexes defined by LIKE ... INCLUDING INDEXES */
1266         foreach(lc, cxt->inh_indexes)
1267         {
1268                 index = (IndexStmt *) lfirst(lc);
1269
1270                 if (index->primary)
1271                 {
1272                         if (cxt->pkey != NULL)
1273                                 ereport(ERROR,
1274                                                 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
1275                                                  errmsg("multiple primary keys for table \"%s\" are not allowed",
1276                                                                 cxt->relation->relname)));
1277                         cxt->pkey = index;
1278                 }
1279
1280                 indexlist = lappend(indexlist, index);
1281         }
1282
1283         /*
1284          * Scan the index list and remove any redundant index specifications. This
1285          * can happen if, for instance, the user writes UNIQUE PRIMARY KEY. A
1286          * strict reading of SQL92 would suggest raising an error instead, but
1287          * that strikes me as too anal-retentive. - tgl 2001-02-14
1288          *
1289          * XXX in ALTER TABLE case, it'd be nice to look for duplicate
1290          * pre-existing indexes, too.
1291          */
1292         Assert(cxt->alist == NIL);
1293         if (cxt->pkey != NULL)
1294         {
1295                 /* Make sure we keep the PKEY index in preference to others... */
1296                 cxt->alist = list_make1(cxt->pkey);
1297         }
1298
1299         foreach(lc, indexlist)
1300         {
1301                 bool            keep = true;
1302                 ListCell   *k;
1303
1304                 index = lfirst(lc);
1305
1306                 /* if it's pkey, it's already in cxt->alist */
1307                 if (index == cxt->pkey)
1308                         continue;
1309
1310                 foreach(k, cxt->alist)
1311                 {
1312                         IndexStmt  *priorindex = lfirst(k);
1313
1314                         if (equal(index->indexParams, priorindex->indexParams) &&
1315                                 equal(index->whereClause, priorindex->whereClause) &&
1316                                 equal(index->excludeOpNames, priorindex->excludeOpNames) &&
1317                                 strcmp(index->accessMethod, priorindex->accessMethod) == 0 &&
1318                                 index->deferrable == priorindex->deferrable &&
1319                                 index->initdeferred == priorindex->initdeferred)
1320                         {
1321                                 priorindex->unique |= index->unique;
1322
1323                                 /*
1324                                  * If the prior index is as yet unnamed, and this one is
1325                                  * named, then transfer the name to the prior index. This
1326                                  * ensures that if we have named and unnamed constraints,
1327                                  * we'll use (at least one of) the names for the index.
1328                                  */
1329                                 if (priorindex->idxname == NULL)
1330                                         priorindex->idxname = index->idxname;
1331                                 keep = false;
1332                                 break;
1333                         }
1334                 }
1335
1336                 if (keep)
1337                         cxt->alist = lappend(cxt->alist, index);
1338         }
1339 }
1340
1341 /*
1342  * transformIndexConstraint
1343  *              Transform one UNIQUE, PRIMARY KEY, or EXCLUDE constraint for
1344  *              transformIndexConstraints.
1345  */
1346 static IndexStmt *
1347 transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt)
1348 {
1349         IndexStmt  *index;
1350         ListCell   *lc;
1351
1352         index = makeNode(IndexStmt);
1353
1354         index->unique = (constraint->contype != CONSTR_EXCLUSION);
1355         index->primary = (constraint->contype == CONSTR_PRIMARY);
1356         if (index->primary)
1357         {
1358                 if (cxt->pkey != NULL)
1359                         ereport(ERROR,
1360                                         (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
1361                          errmsg("multiple primary keys for table \"%s\" are not allowed",
1362                                         cxt->relation->relname),
1363                                          parser_errposition(cxt->pstate, constraint->location)));
1364                 cxt->pkey = index;
1365
1366                 /*
1367                  * In ALTER TABLE case, a primary index might already exist, but
1368                  * DefineIndex will check for it.
1369                  */
1370         }
1371         index->isconstraint = true;
1372         index->deferrable = constraint->deferrable;
1373         index->initdeferred = constraint->initdeferred;
1374
1375         if (constraint->conname != NULL)
1376                 index->idxname = pstrdup(constraint->conname);
1377         else
1378                 index->idxname = NULL;  /* DefineIndex will choose name */
1379
1380         index->relation = cxt->relation;
1381         index->accessMethod = constraint->access_method ? constraint->access_method : DEFAULT_INDEX_TYPE;
1382         index->options = constraint->options;
1383         index->tableSpace = constraint->indexspace;
1384         index->whereClause = constraint->where_clause;
1385         index->indexParams = NIL;
1386         index->excludeOpNames = NIL;
1387         index->indexOid = InvalidOid;
1388         index->concurrent = false;
1389
1390         /*
1391          * If it's ALTER TABLE ADD CONSTRAINT USING INDEX, look up the index and
1392          * verify it's usable, then extract the implied column name list.  (We
1393          * will not actually need the column name list at runtime, but we need it
1394          * now to check for duplicate column entries below.)
1395          */
1396         if (constraint->indexname != NULL)
1397         {
1398                 char       *index_name = constraint->indexname;
1399                 Relation        heap_rel = cxt->rel;
1400                 Oid                     index_oid;
1401                 Relation        index_rel;
1402                 Form_pg_index index_form;
1403                 oidvector  *indclass;
1404                 Datum           indclassDatum;
1405                 bool            isnull;
1406                 int                     i;
1407
1408                 /* Grammar should not allow this with explicit column list */
1409                 Assert(constraint->keys == NIL);
1410
1411                 /* Grammar should only allow PRIMARY and UNIQUE constraints */
1412                 Assert(constraint->contype == CONSTR_PRIMARY ||
1413                            constraint->contype == CONSTR_UNIQUE);
1414
1415                 /* Must be ALTER, not CREATE, but grammar doesn't enforce that */
1416                 if (!cxt->isalter)
1417                         ereport(ERROR,
1418                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1419                                          errmsg("cannot use an existing index in CREATE TABLE"),
1420                                          parser_errposition(cxt->pstate, constraint->location)));
1421
1422                 /* Look for the index in the same schema as the table */
1423                 index_oid = get_relname_relid(index_name, RelationGetNamespace(heap_rel));
1424
1425                 if (!OidIsValid(index_oid))
1426                         ereport(ERROR,
1427                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
1428                                          errmsg("index \"%s\" does not exist", index_name),
1429                                          parser_errposition(cxt->pstate, constraint->location)));
1430
1431                 /* Open the index (this will throw an error if it is not an index) */
1432                 index_rel = index_open(index_oid, AccessShareLock);
1433                 index_form = index_rel->rd_index;
1434
1435                 /* Check that it does not have an associated constraint already */
1436                 if (OidIsValid(get_index_constraint(index_oid)))
1437                         ereport(ERROR,
1438                                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1439                            errmsg("index \"%s\" is already associated with a constraint",
1440                                           index_name),
1441                                          parser_errposition(cxt->pstate, constraint->location)));
1442
1443                 /* Perform validity checks on the index */
1444                 if (index_form->indrelid != RelationGetRelid(heap_rel))
1445                         ereport(ERROR,
1446                                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1447                                          errmsg("index \"%s\" does not belong to table \"%s\"",
1448                                                         index_name, RelationGetRelationName(heap_rel)),
1449                                          parser_errposition(cxt->pstate, constraint->location)));
1450
1451                 if (!index_form->indisvalid)
1452                         ereport(ERROR,
1453                                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1454                                          errmsg("index \"%s\" is not valid", index_name),
1455                                          parser_errposition(cxt->pstate, constraint->location)));
1456
1457                 if (!index_form->indisready)
1458                         ereport(ERROR,
1459                                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1460                                          errmsg("index \"%s\" is not ready", index_name),
1461                                          parser_errposition(cxt->pstate, constraint->location)));
1462
1463                 if (!index_form->indisunique)
1464                         ereport(ERROR,
1465                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1466                                          errmsg("\"%s\" is not a unique index", index_name),
1467                                          errdetail("Cannot create a PRIMARY KEY or UNIQUE constraint using such an index."),
1468                                          parser_errposition(cxt->pstate, constraint->location)));
1469
1470                 if (RelationGetIndexExpressions(index_rel) != NIL)
1471                         ereport(ERROR,
1472                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1473                                          errmsg("index \"%s\" contains expressions", index_name),
1474                                          errdetail("Cannot create a PRIMARY KEY or UNIQUE constraint using such an index."),
1475                                          parser_errposition(cxt->pstate, constraint->location)));
1476
1477                 if (RelationGetIndexPredicate(index_rel) != NIL)
1478                         ereport(ERROR,
1479                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1480                                          errmsg("\"%s\" is a partial index", index_name),
1481                                          errdetail("Cannot create a PRIMARY KEY or UNIQUE constraint using such an index."),
1482                                          parser_errposition(cxt->pstate, constraint->location)));
1483
1484                 /*
1485                  * It's probably unsafe to change a deferred index to non-deferred. (A
1486                  * non-constraint index couldn't be deferred anyway, so this case
1487                  * should never occur; no need to sweat, but let's check it.)
1488                  */
1489                 if (!index_form->indimmediate && !constraint->deferrable)
1490                         ereport(ERROR,
1491                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1492                                          errmsg("\"%s\" is a deferrable index", index_name),
1493                                          errdetail("Cannot create a non-deferrable constraint using a deferrable index."),
1494                                          parser_errposition(cxt->pstate, constraint->location)));
1495
1496                 /*
1497                  * Insist on it being a btree.  That's the only kind that supports
1498                  * uniqueness at the moment anyway; but we must have an index that
1499                  * exactly matches what you'd get from plain ADD CONSTRAINT syntax,
1500                  * else dump and reload will produce a different index (breaking
1501                  * pg_upgrade in particular).
1502                  */
1503                 if (index_rel->rd_rel->relam != get_am_oid(DEFAULT_INDEX_TYPE, false))
1504                         ereport(ERROR,
1505                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1506                                          errmsg("index \"%s\" is not a b-tree", index_name),
1507                                          parser_errposition(cxt->pstate, constraint->location)));
1508
1509                 /* Must get indclass the hard way */
1510                 indclassDatum = SysCacheGetAttr(INDEXRELID, index_rel->rd_indextuple,
1511                                                                                 Anum_pg_index_indclass, &isnull);
1512                 Assert(!isnull);
1513                 indclass = (oidvector *) DatumGetPointer(indclassDatum);
1514
1515                 for (i = 0; i < index_form->indnatts; i++)
1516                 {
1517                         int2            attnum = index_form->indkey.values[i];
1518                         Form_pg_attribute attform;
1519                         char       *attname;
1520                         Oid                     defopclass;
1521
1522                         /*
1523                          * We shouldn't see attnum == 0 here, since we already rejected
1524                          * expression indexes.  If we do, SystemAttributeDefinition will
1525                          * throw an error.
1526                          */
1527                         if (attnum > 0)
1528                         {
1529                                 Assert(attnum <= heap_rel->rd_att->natts);
1530                                 attform = heap_rel->rd_att->attrs[attnum - 1];
1531                         }
1532                         else
1533                                 attform = SystemAttributeDefinition(attnum,
1534                                                                                            heap_rel->rd_rel->relhasoids);
1535                         attname = pstrdup(NameStr(attform->attname));
1536
1537                         /*
1538                          * Insist on default opclass and sort options.  While the index
1539                          * would still work as a constraint with non-default settings, it
1540                          * might not provide exactly the same uniqueness semantics as
1541                          * you'd get from a normally-created constraint; and there's also
1542                          * the dump/reload problem mentioned above.
1543                          */
1544                         defopclass = GetDefaultOpClass(attform->atttypid,
1545                                                                                    index_rel->rd_rel->relam);
1546                         if (indclass->values[i] != defopclass ||
1547                                 index_rel->rd_indoption[i] != 0)
1548                                 ereport(ERROR,
1549                                                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1550                                                  errmsg("index \"%s\" does not have default sorting behavior", index_name),
1551                                                  errdetail("Cannot create a PRIMARY KEY or UNIQUE constraint using such an index."),
1552                                          parser_errposition(cxt->pstate, constraint->location)));
1553
1554                         constraint->keys = lappend(constraint->keys, makeString(attname));
1555                 }
1556
1557                 /* Close the index relation but keep the lock */
1558                 relation_close(index_rel, NoLock);
1559
1560                 index->indexOid = index_oid;
1561         }
1562
1563         /*
1564          * If it's an EXCLUDE constraint, the grammar returns a list of pairs of
1565          * IndexElems and operator names.  We have to break that apart into
1566          * separate lists.
1567          */
1568         if (constraint->contype == CONSTR_EXCLUSION)
1569         {
1570                 foreach(lc, constraint->exclusions)
1571                 {
1572                         List       *pair = (List *) lfirst(lc);
1573                         IndexElem  *elem;
1574                         List       *opname;
1575
1576                         Assert(list_length(pair) == 2);
1577                         elem = (IndexElem *) linitial(pair);
1578                         Assert(IsA(elem, IndexElem));
1579                         opname = (List *) lsecond(pair);
1580                         Assert(IsA(opname, List));
1581
1582                         index->indexParams = lappend(index->indexParams, elem);
1583                         index->excludeOpNames = lappend(index->excludeOpNames, opname);
1584                 }
1585
1586                 return index;
1587         }
1588
1589         /*
1590          * For UNIQUE and PRIMARY KEY, we just have a list of column names.
1591          *
1592          * Make sure referenced keys exist.  If we are making a PRIMARY KEY index,
1593          * also make sure they are NOT NULL, if possible. (Although we could leave
1594          * it to DefineIndex to mark the columns NOT NULL, it's more efficient to
1595          * get it right the first time.)
1596          */
1597         foreach(lc, constraint->keys)
1598         {
1599                 char       *key = strVal(lfirst(lc));
1600                 bool            found = false;
1601                 ColumnDef  *column = NULL;
1602                 ListCell   *columns;
1603                 IndexElem  *iparam;
1604
1605                 foreach(columns, cxt->columns)
1606                 {
1607                         column = (ColumnDef *) lfirst(columns);
1608                         Assert(IsA(column, ColumnDef));
1609                         if (strcmp(column->colname, key) == 0)
1610                         {
1611                                 found = true;
1612                                 break;
1613                         }
1614                 }
1615                 if (found)
1616                 {
1617                         /* found column in the new table; force it to be NOT NULL */
1618                         if (constraint->contype == CONSTR_PRIMARY)
1619                                 column->is_not_null = TRUE;
1620                 }
1621                 else if (SystemAttributeByName(key, cxt->hasoids) != NULL)
1622                 {
1623                         /*
1624                          * column will be a system column in the new table, so accept it.
1625                          * System columns can't ever be null, so no need to worry about
1626                          * PRIMARY/NOT NULL constraint.
1627                          */
1628                         found = true;
1629                 }
1630                 else if (cxt->inhRelations)
1631                 {
1632                         /* try inherited tables */
1633                         ListCell   *inher;
1634
1635                         foreach(inher, cxt->inhRelations)
1636                         {
1637                                 RangeVar   *inh = (RangeVar *) lfirst(inher);
1638                                 Relation        rel;
1639                                 int                     count;
1640
1641                                 Assert(IsA(inh, RangeVar));
1642                                 rel = heap_openrv(inh, AccessShareLock);
1643                                 if (rel->rd_rel->relkind != RELKIND_RELATION)
1644                                         ereport(ERROR,
1645                                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1646                                                    errmsg("inherited relation \"%s\" is not a table",
1647                                                                   inh->relname)));
1648                                 for (count = 0; count < rel->rd_att->natts; count++)
1649                                 {
1650                                         Form_pg_attribute inhattr = rel->rd_att->attrs[count];
1651                                         char       *inhname = NameStr(inhattr->attname);
1652
1653                                         if (inhattr->attisdropped)
1654                                                 continue;
1655                                         if (strcmp(key, inhname) == 0)
1656                                         {
1657                                                 found = true;
1658
1659                                                 /*
1660                                                  * We currently have no easy way to force an inherited
1661                                                  * column to be NOT NULL at creation, if its parent
1662                                                  * wasn't so already. We leave it to DefineIndex to
1663                                                  * fix things up in this case.
1664                                                  */
1665                                                 break;
1666                                         }
1667                                 }
1668                                 heap_close(rel, NoLock);
1669                                 if (found)
1670                                         break;
1671                         }
1672                 }
1673
1674                 /*
1675                  * In the ALTER TABLE case, don't complain about index keys not
1676                  * created in the command; they may well exist already. DefineIndex
1677                  * will complain about them if not, and will also take care of marking
1678                  * them NOT NULL.
1679                  */
1680                 if (!found && !cxt->isalter)
1681                         ereport(ERROR,
1682                                         (errcode(ERRCODE_UNDEFINED_COLUMN),
1683                                          errmsg("column \"%s\" named in key does not exist", key),
1684                                          parser_errposition(cxt->pstate, constraint->location)));
1685
1686                 /* Check for PRIMARY KEY(foo, foo) */
1687                 foreach(columns, index->indexParams)
1688                 {
1689                         iparam = (IndexElem *) lfirst(columns);
1690                         if (iparam->name && strcmp(key, iparam->name) == 0)
1691                         {
1692                                 if (index->primary)
1693                                         ereport(ERROR,
1694                                                         (errcode(ERRCODE_DUPLICATE_COLUMN),
1695                                                          errmsg("column \"%s\" appears twice in primary key constraint",
1696                                                                         key),
1697                                          parser_errposition(cxt->pstate, constraint->location)));
1698                                 else
1699                                         ereport(ERROR,
1700                                                         (errcode(ERRCODE_DUPLICATE_COLUMN),
1701                                         errmsg("column \"%s\" appears twice in unique constraint",
1702                                                    key),
1703                                          parser_errposition(cxt->pstate, constraint->location)));
1704                         }
1705                 }
1706
1707                 /* OK, add it to the index definition */
1708                 iparam = makeNode(IndexElem);
1709                 iparam->name = pstrdup(key);
1710                 iparam->expr = NULL;
1711                 iparam->indexcolname = NULL;
1712                 iparam->collation = NIL;
1713                 iparam->opclass = NIL;
1714                 iparam->ordering = SORTBY_DEFAULT;
1715                 iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
1716                 index->indexParams = lappend(index->indexParams, iparam);
1717         }
1718
1719         return index;
1720 }
1721
1722 /*
1723  * transformFKConstraints
1724  *              handle FOREIGN KEY constraints
1725  */
1726 static void
1727 transformFKConstraints(CreateStmtContext *cxt,
1728                                            bool skipValidation, bool isAddConstraint)
1729 {
1730         ListCell   *fkclist;
1731
1732         if (cxt->fkconstraints == NIL)
1733                 return;
1734
1735         /*
1736          * If CREATE TABLE or adding a column with NULL default, we can safely
1737          * skip validation of the constraint.
1738          */
1739         if (skipValidation)
1740         {
1741                 foreach(fkclist, cxt->fkconstraints)
1742                 {
1743                         Constraint *constraint = (Constraint *) lfirst(fkclist);
1744
1745                         constraint->skip_validation = true;
1746                         constraint->initially_valid = true;
1747                 }
1748         }
1749
1750         /*
1751          * For CREATE TABLE or ALTER TABLE ADD COLUMN, gin up an ALTER TABLE ADD
1752          * CONSTRAINT command to execute after the basic command is complete. (If
1753          * called from ADD CONSTRAINT, that routine will add the FK constraints to
1754          * its own subcommand list.)
1755          *
1756          * Note: the ADD CONSTRAINT command must also execute after any index
1757          * creation commands.  Thus, this should run after
1758          * transformIndexConstraints, so that the CREATE INDEX commands are
1759          * already in cxt->alist.
1760          */
1761         if (!isAddConstraint)
1762         {
1763                 AlterTableStmt *alterstmt = makeNode(AlterTableStmt);
1764
1765                 alterstmt->relation = cxt->relation;
1766                 alterstmt->cmds = NIL;
1767                 alterstmt->relkind = OBJECT_TABLE;
1768
1769                 foreach(fkclist, cxt->fkconstraints)
1770                 {
1771                         Constraint *constraint = (Constraint *) lfirst(fkclist);
1772                         AlterTableCmd *altercmd = makeNode(AlterTableCmd);
1773
1774                         altercmd->subtype = AT_ProcessedConstraint;
1775                         altercmd->name = NULL;
1776                         altercmd->def = (Node *) constraint;
1777                         alterstmt->cmds = lappend(alterstmt->cmds, altercmd);
1778                 }
1779
1780                 cxt->alist = lappend(cxt->alist, alterstmt);
1781         }
1782 }
1783
1784 /*
1785  * transformIndexStmt - parse analysis for CREATE INDEX and ALTER TABLE
1786  *
1787  * Note: this is a no-op for an index not using either index expressions or
1788  * a predicate expression.      There are several code paths that create indexes
1789  * without bothering to call this, because they know they don't have any
1790  * such expressions to deal with.
1791  */
1792 IndexStmt *
1793 transformIndexStmt(IndexStmt *stmt, const char *queryString)
1794 {
1795         Relation        rel;
1796         ParseState *pstate;
1797         RangeTblEntry *rte;
1798         ListCell   *l;
1799
1800         /*
1801          * We must not scribble on the passed-in IndexStmt, so copy it.  (This is
1802          * overkill, but easy.)
1803          */
1804         stmt = (IndexStmt *) copyObject(stmt);
1805
1806         /*
1807          * Open the parent table with appropriate locking.      We must do this
1808          * because addRangeTableEntry() would acquire only AccessShareLock,
1809          * leaving DefineIndex() needing to do a lock upgrade with consequent risk
1810          * of deadlock.  Make sure this stays in sync with the type of lock
1811          * DefineIndex() wants. If we are being called by ALTER TABLE, we will
1812          * already hold a higher lock.
1813          */
1814         rel = heap_openrv(stmt->relation,
1815                                   (stmt->concurrent ? ShareUpdateExclusiveLock : ShareLock));
1816
1817         /* Set up pstate */
1818         pstate = make_parsestate(NULL);
1819         pstate->p_sourcetext = queryString;
1820
1821         /*
1822          * Put the parent table into the rtable so that the expressions can refer
1823          * to its fields without qualification.
1824          */
1825         rte = addRangeTableEntry(pstate, stmt->relation, NULL, false, true);
1826
1827         /* no to join list, yes to namespaces */
1828         addRTEtoQuery(pstate, rte, false, true, true);
1829
1830         /* take care of the where clause */
1831         if (stmt->whereClause)
1832         {
1833                 stmt->whereClause = transformWhereClause(pstate,
1834                                                                                                  stmt->whereClause,
1835                                                                                                  "WHERE");
1836                 /* we have to fix its collations too */
1837                 assign_expr_collations(pstate, stmt->whereClause);
1838         }
1839
1840         /* take care of any index expressions */
1841         foreach(l, stmt->indexParams)
1842         {
1843                 IndexElem  *ielem = (IndexElem *) lfirst(l);
1844
1845                 if (ielem->expr)
1846                 {
1847                         /* Extract preliminary index col name before transforming expr */
1848                         if (ielem->indexcolname == NULL)
1849                                 ielem->indexcolname = FigureIndexColname(ielem->expr);
1850
1851                         /* Now do parse transformation of the expression */
1852                         ielem->expr = transformExpr(pstate, ielem->expr);
1853
1854                         /* We have to fix its collations too */
1855                         assign_expr_collations(pstate, ielem->expr);
1856
1857                         /*
1858                          * We check only that the result type is legitimate; this is for
1859                          * consistency with what transformWhereClause() checks for the
1860                          * predicate.  DefineIndex() will make more checks.
1861                          */
1862                         if (expression_returns_set(ielem->expr))
1863                                 ereport(ERROR,
1864                                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
1865                                                  errmsg("index expression cannot return a set")));
1866                 }
1867         }
1868
1869         /*
1870          * Check that only the base rel is mentioned.
1871          */
1872         if (list_length(pstate->p_rtable) != 1)
1873                 ereport(ERROR,
1874                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1875                                  errmsg("index expressions and predicates can refer only to the table being indexed")));
1876
1877         free_parsestate(pstate);
1878
1879         /* Close relation, but keep the lock */
1880         heap_close(rel, NoLock);
1881
1882         return stmt;
1883 }
1884
1885
1886 /*
1887  * transformRuleStmt -
1888  *        transform a CREATE RULE Statement. The action is a list of parse
1889  *        trees which is transformed into a list of query trees, and we also
1890  *        transform the WHERE clause if any.
1891  *
1892  * actions and whereClause are output parameters that receive the
1893  * transformed results.
1894  *
1895  * Note that we must not scribble on the passed-in RuleStmt, so we do
1896  * copyObject() on the actions and WHERE clause.
1897  */
1898 void
1899 transformRuleStmt(RuleStmt *stmt, const char *queryString,
1900                                   List **actions, Node **whereClause)
1901 {
1902         Relation        rel;
1903         ParseState *pstate;
1904         RangeTblEntry *oldrte;
1905         RangeTblEntry *newrte;
1906
1907         /*
1908          * To avoid deadlock, make sure the first thing we do is grab
1909          * AccessExclusiveLock on the target relation.  This will be needed by
1910          * DefineQueryRewrite(), and we don't want to grab a lesser lock
1911          * beforehand.
1912          */
1913         rel = heap_openrv(stmt->relation, AccessExclusiveLock);
1914
1915         /* Set up pstate */
1916         pstate = make_parsestate(NULL);
1917         pstate->p_sourcetext = queryString;
1918
1919         /*
1920          * NOTE: 'OLD' must always have a varno equal to 1 and 'NEW' equal to 2.
1921          * Set up their RTEs in the main pstate for use in parsing the rule
1922          * qualification.
1923          */
1924         oldrte = addRangeTableEntryForRelation(pstate, rel,
1925                                                                                    makeAlias("old", NIL),
1926                                                                                    false, false);
1927         newrte = addRangeTableEntryForRelation(pstate, rel,
1928                                                                                    makeAlias("new", NIL),
1929                                                                                    false, false);
1930         /* Must override addRangeTableEntry's default access-check flags */
1931         oldrte->requiredPerms = 0;
1932         newrte->requiredPerms = 0;
1933
1934         /*
1935          * They must be in the namespace too for lookup purposes, but only add the
1936          * one(s) that are relevant for the current kind of rule.  In an UPDATE
1937          * rule, quals must refer to OLD.field or NEW.field to be unambiguous, but
1938          * there's no need to be so picky for INSERT & DELETE.  We do not add them
1939          * to the joinlist.
1940          */
1941         switch (stmt->event)
1942         {
1943                 case CMD_SELECT:
1944                         addRTEtoQuery(pstate, oldrte, false, true, true);
1945                         break;
1946                 case CMD_UPDATE:
1947                         addRTEtoQuery(pstate, oldrte, false, true, true);
1948                         addRTEtoQuery(pstate, newrte, false, true, true);
1949                         break;
1950                 case CMD_INSERT:
1951                         addRTEtoQuery(pstate, newrte, false, true, true);
1952                         break;
1953                 case CMD_DELETE:
1954                         addRTEtoQuery(pstate, oldrte, false, true, true);
1955                         break;
1956                 default:
1957                         elog(ERROR, "unrecognized event type: %d",
1958                                  (int) stmt->event);
1959                         break;
1960         }
1961
1962         /* take care of the where clause */
1963         *whereClause = transformWhereClause(pstate,
1964                                                                           (Node *) copyObject(stmt->whereClause),
1965                                                                                 "WHERE");
1966         /* we have to fix its collations too */
1967         assign_expr_collations(pstate, *whereClause);
1968
1969         if (list_length(pstate->p_rtable) != 2)         /* naughty, naughty... */
1970                 ereport(ERROR,
1971                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1972                                  errmsg("rule WHERE condition cannot contain references to other relations")));
1973
1974         /* aggregates not allowed (but subselects are okay) */
1975         if (pstate->p_hasAggs)
1976                 ereport(ERROR,
1977                                 (errcode(ERRCODE_GROUPING_ERROR),
1978                    errmsg("cannot use aggregate function in rule WHERE condition")));
1979         if (pstate->p_hasWindowFuncs)
1980                 ereport(ERROR,
1981                                 (errcode(ERRCODE_WINDOWING_ERROR),
1982                           errmsg("cannot use window function in rule WHERE condition")));
1983
1984         /*
1985          * 'instead nothing' rules with a qualification need a query rangetable so
1986          * the rewrite handler can add the negated rule qualification to the
1987          * original query. We create a query with the new command type CMD_NOTHING
1988          * here that is treated specially by the rewrite system.
1989          */
1990         if (stmt->actions == NIL)
1991         {
1992                 Query      *nothing_qry = makeNode(Query);
1993
1994                 nothing_qry->commandType = CMD_NOTHING;
1995                 nothing_qry->rtable = pstate->p_rtable;
1996                 nothing_qry->jointree = makeFromExpr(NIL, NULL);                /* no join wanted */
1997
1998                 *actions = list_make1(nothing_qry);
1999         }
2000         else
2001         {
2002                 ListCell   *l;
2003                 List       *newactions = NIL;
2004
2005                 /*
2006                  * transform each statement, like parse_sub_analyze()
2007                  */
2008                 foreach(l, stmt->actions)
2009                 {
2010                         Node       *action = (Node *) lfirst(l);
2011                         ParseState *sub_pstate = make_parsestate(NULL);
2012                         Query      *sub_qry,
2013                                            *top_subqry;
2014                         bool            has_old,
2015                                                 has_new;
2016
2017                         /*
2018                          * Since outer ParseState isn't parent of inner, have to pass down
2019                          * the query text by hand.
2020                          */
2021                         sub_pstate->p_sourcetext = queryString;
2022
2023                         /*
2024                          * Set up OLD/NEW in the rtable for this statement.  The entries
2025                          * are added only to relnamespace, not varnamespace, because we
2026                          * don't want them to be referred to by unqualified field names
2027                          * nor "*" in the rule actions.  We decide later whether to put
2028                          * them in the joinlist.
2029                          */
2030                         oldrte = addRangeTableEntryForRelation(sub_pstate, rel,
2031                                                                                                    makeAlias("old", NIL),
2032                                                                                                    false, false);
2033                         newrte = addRangeTableEntryForRelation(sub_pstate, rel,
2034                                                                                                    makeAlias("new", NIL),
2035                                                                                                    false, false);
2036                         oldrte->requiredPerms = 0;
2037                         newrte->requiredPerms = 0;
2038                         addRTEtoQuery(sub_pstate, oldrte, false, true, false);
2039                         addRTEtoQuery(sub_pstate, newrte, false, true, false);
2040
2041                         /* Transform the rule action statement */
2042                         top_subqry = transformStmt(sub_pstate,
2043                                                                            (Node *) copyObject(action));
2044
2045                         /*
2046                          * We cannot support utility-statement actions (eg NOTIFY) with
2047                          * nonempty rule WHERE conditions, because there's no way to make
2048                          * the utility action execute conditionally.
2049                          */
2050                         if (top_subqry->commandType == CMD_UTILITY &&
2051                                 *whereClause != NULL)
2052                                 ereport(ERROR,
2053                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2054                                                  errmsg("rules with WHERE conditions can only have SELECT, INSERT, UPDATE, or DELETE actions")));
2055
2056                         /*
2057                          * If the action is INSERT...SELECT, OLD/NEW have been pushed down
2058                          * into the SELECT, and that's what we need to look at. (Ugly
2059                          * kluge ... try to fix this when we redesign querytrees.)
2060                          */
2061                         sub_qry = getInsertSelectQuery(top_subqry, NULL);
2062
2063                         /*
2064                          * If the sub_qry is a setop, we cannot attach any qualifications
2065                          * to it, because the planner won't notice them.  This could
2066                          * perhaps be relaxed someday, but for now, we may as well reject
2067                          * such a rule immediately.
2068                          */
2069                         if (sub_qry->setOperations != NULL && *whereClause != NULL)
2070                                 ereport(ERROR,
2071                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2072                                                  errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
2073
2074                         /*
2075                          * Validate action's use of OLD/NEW, qual too
2076                          */
2077                         has_old =
2078                                 rangeTableEntry_used((Node *) sub_qry, PRS2_OLD_VARNO, 0) ||
2079                                 rangeTableEntry_used(*whereClause, PRS2_OLD_VARNO, 0);
2080                         has_new =
2081                                 rangeTableEntry_used((Node *) sub_qry, PRS2_NEW_VARNO, 0) ||
2082                                 rangeTableEntry_used(*whereClause, PRS2_NEW_VARNO, 0);
2083
2084                         switch (stmt->event)
2085                         {
2086                                 case CMD_SELECT:
2087                                         if (has_old)
2088                                                 ereport(ERROR,
2089                                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2090                                                                  errmsg("ON SELECT rule cannot use OLD")));
2091                                         if (has_new)
2092                                                 ereport(ERROR,
2093                                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2094                                                                  errmsg("ON SELECT rule cannot use NEW")));
2095                                         break;
2096                                 case CMD_UPDATE:
2097                                         /* both are OK */
2098                                         break;
2099                                 case CMD_INSERT:
2100                                         if (has_old)
2101                                                 ereport(ERROR,
2102                                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2103                                                                  errmsg("ON INSERT rule cannot use OLD")));
2104                                         break;
2105                                 case CMD_DELETE:
2106                                         if (has_new)
2107                                                 ereport(ERROR,
2108                                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2109                                                                  errmsg("ON DELETE rule cannot use NEW")));
2110                                         break;
2111                                 default:
2112                                         elog(ERROR, "unrecognized event type: %d",
2113                                                  (int) stmt->event);
2114                                         break;
2115                         }
2116
2117                         /*
2118                          * OLD/NEW are not allowed in WITH queries, because they would
2119                          * amount to outer references for the WITH, which we disallow.
2120                          * However, they were already in the outer rangetable when we
2121                          * analyzed the query, so we have to check.
2122                          *
2123                          * Note that in the INSERT...SELECT case, we need to examine the
2124                          * CTE lists of both top_subqry and sub_qry.
2125                          *
2126                          * Note that we aren't digging into the body of the query looking
2127                          * for WITHs in nested sub-SELECTs.  A WITH down there can
2128                          * legitimately refer to OLD/NEW, because it'd be an
2129                          * indirect-correlated outer reference.
2130                          */
2131                         if (rangeTableEntry_used((Node *) top_subqry->cteList,
2132                                                                          PRS2_OLD_VARNO, 0) ||
2133                                 rangeTableEntry_used((Node *) sub_qry->cteList,
2134                                                                          PRS2_OLD_VARNO, 0))
2135                                 ereport(ERROR,
2136                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2137                                                  errmsg("cannot refer to OLD within WITH query")));
2138                         if (rangeTableEntry_used((Node *) top_subqry->cteList,
2139                                                                          PRS2_NEW_VARNO, 0) ||
2140                                 rangeTableEntry_used((Node *) sub_qry->cteList,
2141                                                                          PRS2_NEW_VARNO, 0))
2142                                 ereport(ERROR,
2143                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2144                                                  errmsg("cannot refer to NEW within WITH query")));
2145
2146                         /*
2147                          * For efficiency's sake, add OLD to the rule action's jointree
2148                          * only if it was actually referenced in the statement or qual.
2149                          *
2150                          * For INSERT, NEW is not really a relation (only a reference to
2151                          * the to-be-inserted tuple) and should never be added to the
2152                          * jointree.
2153                          *
2154                          * For UPDATE, we treat NEW as being another kind of reference to
2155                          * OLD, because it represents references to *transformed* tuples
2156                          * of the existing relation.  It would be wrong to enter NEW
2157                          * separately in the jointree, since that would cause a double
2158                          * join of the updated relation.  It's also wrong to fail to make
2159                          * a jointree entry if only NEW and not OLD is mentioned.
2160                          */
2161                         if (has_old || (has_new && stmt->event == CMD_UPDATE))
2162                         {
2163                                 /*
2164                                  * If sub_qry is a setop, manipulating its jointree will do no
2165                                  * good at all, because the jointree is dummy. (This should be
2166                                  * a can't-happen case because of prior tests.)
2167                                  */
2168                                 if (sub_qry->setOperations != NULL)
2169                                         ereport(ERROR,
2170                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2171                                                          errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
2172                                 /* hack so we can use addRTEtoQuery() */
2173                                 sub_pstate->p_rtable = sub_qry->rtable;
2174                                 sub_pstate->p_joinlist = sub_qry->jointree->fromlist;
2175                                 addRTEtoQuery(sub_pstate, oldrte, true, false, false);
2176                                 sub_qry->jointree->fromlist = sub_pstate->p_joinlist;
2177                         }
2178
2179                         newactions = lappend(newactions, top_subqry);
2180
2181                         free_parsestate(sub_pstate);
2182                 }
2183
2184                 *actions = newactions;
2185         }
2186
2187         free_parsestate(pstate);
2188
2189         /* Close relation, but keep the exclusive lock */
2190         heap_close(rel, NoLock);
2191 }
2192
2193
2194 /*
2195  * transformAlterTableStmt -
2196  *              parse analysis for ALTER TABLE
2197  *
2198  * Returns a List of utility commands to be done in sequence.  One of these
2199  * will be the transformed AlterTableStmt, but there may be additional actions
2200  * to be done before and after the actual AlterTable() call.
2201  */
2202 List *
2203 transformAlterTableStmt(AlterTableStmt *stmt, const char *queryString)
2204 {
2205         Relation        rel;
2206         ParseState *pstate;
2207         CreateStmtContext cxt;
2208         List       *result;
2209         List       *save_alist;
2210         ListCell   *lcmd,
2211                            *l;
2212         List       *newcmds = NIL;
2213         bool            skipValidation = true;
2214         AlterTableCmd *newcmd;
2215         LOCKMODE        lockmode;
2216
2217         /*
2218          * We must not scribble on the passed-in AlterTableStmt, so copy it. (This
2219          * is overkill, but easy.)
2220          */
2221         stmt = (AlterTableStmt *) copyObject(stmt);
2222
2223         /*
2224          * Determine the appropriate lock level for this list of subcommands.
2225          */
2226         lockmode = AlterTableGetLockLevel(stmt->cmds);
2227
2228         /*
2229          * Acquire appropriate lock on the target relation, which will be held
2230          * until end of transaction.  This ensures any decisions we make here
2231          * based on the state of the relation will still be good at execution. We
2232          * must get lock now because execution will later require it; taking a
2233          * lower grade lock now and trying to upgrade later risks deadlock.  Any
2234          * new commands we add after this must not upgrade the lock level
2235          * requested here.
2236          */
2237         rel = relation_openrv(stmt->relation, lockmode);
2238
2239         /* Set up pstate and CreateStmtContext */
2240         pstate = make_parsestate(NULL);
2241         pstate->p_sourcetext = queryString;
2242
2243         cxt.pstate = pstate;
2244         cxt.stmtType = "ALTER TABLE";
2245         cxt.relation = stmt->relation;
2246         cxt.rel = rel;
2247         cxt.inhRelations = NIL;
2248         cxt.isalter = true;
2249         cxt.hasoids = false;            /* need not be right */
2250         cxt.columns = NIL;
2251         cxt.ckconstraints = NIL;
2252         cxt.fkconstraints = NIL;
2253         cxt.ixconstraints = NIL;
2254         cxt.inh_indexes = NIL;
2255         cxt.blist = NIL;
2256         cxt.alist = NIL;
2257         cxt.pkey = NULL;
2258
2259         /*
2260          * The only subtypes that currently require parse transformation handling
2261          * are ADD COLUMN and ADD CONSTRAINT.  These largely re-use code from
2262          * CREATE TABLE.
2263          */
2264         foreach(lcmd, stmt->cmds)
2265         {
2266                 AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
2267
2268                 switch (cmd->subtype)
2269                 {
2270                         case AT_AddColumn:
2271                         case AT_AddColumnToView:
2272                                 {
2273                                         ColumnDef  *def = (ColumnDef *) cmd->def;
2274
2275                                         Assert(IsA(def, ColumnDef));
2276                                         transformColumnDefinition(&cxt, def);
2277
2278                                         /*
2279                                          * If the column has a non-null default, we can't skip
2280                                          * validation of foreign keys.
2281                                          */
2282                                         if (def->raw_default != NULL)
2283                                                 skipValidation = false;
2284
2285                                         /*
2286                                          * All constraints are processed in other ways. Remove the
2287                                          * original list
2288                                          */
2289                                         def->constraints = NIL;
2290
2291                                         newcmds = lappend(newcmds, cmd);
2292                                         break;
2293                                 }
2294                         case AT_AddConstraint:
2295
2296                                 /*
2297                                  * The original AddConstraint cmd node doesn't go to newcmds
2298                                  */
2299                                 if (IsA(cmd->def, Constraint))
2300                                 {
2301                                         transformTableConstraint(&cxt, (Constraint *) cmd->def);
2302                                         if (((Constraint *) cmd->def)->contype == CONSTR_FOREIGN)
2303                                                 skipValidation = false;
2304                                 }
2305                                 else
2306                                         elog(ERROR, "unrecognized node type: %d",
2307                                                  (int) nodeTag(cmd->def));
2308                                 break;
2309
2310                         case AT_ProcessedConstraint:
2311
2312                                 /*
2313                                  * Already-transformed ADD CONSTRAINT, so just make it look
2314                                  * like the standard case.
2315                                  */
2316                                 cmd->subtype = AT_AddConstraint;
2317                                 newcmds = lappend(newcmds, cmd);
2318                                 break;
2319
2320                         default:
2321                                 newcmds = lappend(newcmds, cmd);
2322                                 break;
2323                 }
2324         }
2325
2326         /*
2327          * transformIndexConstraints wants cxt.alist to contain only index
2328          * statements, so transfer anything we already have into save_alist
2329          * immediately.
2330          */
2331         save_alist = cxt.alist;
2332         cxt.alist = NIL;
2333
2334         /* Postprocess index and FK constraints */
2335         transformIndexConstraints(&cxt);
2336
2337         transformFKConstraints(&cxt, skipValidation, true);
2338
2339         /*
2340          * Push any index-creation commands into the ALTER, so that they can be
2341          * scheduled nicely by tablecmds.c.  Note that tablecmds.c assumes that
2342          * the IndexStmt attached to an AT_AddIndex or AT_AddIndexConstraint
2343          * subcommand has already been through transformIndexStmt.
2344          */
2345         foreach(l, cxt.alist)
2346         {
2347                 IndexStmt  *idxstmt = (IndexStmt *) lfirst(l);
2348
2349                 Assert(IsA(idxstmt, IndexStmt));
2350                 idxstmt = transformIndexStmt(idxstmt, queryString);
2351                 newcmd = makeNode(AlterTableCmd);
2352                 newcmd->subtype = OidIsValid(idxstmt->indexOid) ? AT_AddIndexConstraint : AT_AddIndex;
2353                 newcmd->def = (Node *) idxstmt;
2354                 newcmds = lappend(newcmds, newcmd);
2355         }
2356         cxt.alist = NIL;
2357
2358         /* Append any CHECK or FK constraints to the commands list */
2359         foreach(l, cxt.ckconstraints)
2360         {
2361                 newcmd = makeNode(AlterTableCmd);
2362                 newcmd->subtype = AT_AddConstraint;
2363                 newcmd->def = (Node *) lfirst(l);
2364                 newcmds = lappend(newcmds, newcmd);
2365         }
2366         foreach(l, cxt.fkconstraints)
2367         {
2368                 newcmd = makeNode(AlterTableCmd);
2369                 newcmd->subtype = AT_AddConstraint;
2370                 newcmd->def = (Node *) lfirst(l);
2371                 newcmds = lappend(newcmds, newcmd);
2372         }
2373
2374         /* Close rel but keep lock */
2375         relation_close(rel, NoLock);
2376
2377         /*
2378          * Output results.
2379          */
2380         stmt->cmds = newcmds;
2381
2382         result = lappend(cxt.blist, stmt);
2383         result = list_concat(result, cxt.alist);
2384         result = list_concat(result, save_alist);
2385
2386         return result;
2387 }
2388
2389
2390 /*
2391  * Preprocess a list of column constraint clauses
2392  * to attach constraint attributes to their primary constraint nodes
2393  * and detect inconsistent/misplaced constraint attributes.
2394  *
2395  * NOTE: currently, attributes are only supported for FOREIGN KEY, UNIQUE,
2396  * and PRIMARY KEY constraints, but someday they ought to be supported
2397  * for other constraint types.
2398  */
2399 static void
2400 transformConstraintAttrs(CreateStmtContext *cxt, List *constraintList)
2401 {
2402         Constraint *lastprimarycon = NULL;
2403         bool            saw_deferrability = false;
2404         bool            saw_initially = false;
2405         ListCell   *clist;
2406
2407 #define SUPPORTS_ATTRS(node)                            \
2408         ((node) != NULL &&                                              \
2409          ((node)->contype == CONSTR_PRIMARY ||  \
2410           (node)->contype == CONSTR_UNIQUE ||   \
2411           (node)->contype == CONSTR_EXCLUSION || \
2412           (node)->contype == CONSTR_FOREIGN))
2413
2414         foreach(clist, constraintList)
2415         {
2416                 Constraint *con = (Constraint *) lfirst(clist);
2417
2418                 if (!IsA(con, Constraint))
2419                         elog(ERROR, "unrecognized node type: %d",
2420                                  (int) nodeTag(con));
2421                 switch (con->contype)
2422                 {
2423                         case CONSTR_ATTR_DEFERRABLE:
2424                                 if (!SUPPORTS_ATTRS(lastprimarycon))
2425                                         ereport(ERROR,
2426                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2427                                                          errmsg("misplaced DEFERRABLE clause"),
2428                                                          parser_errposition(cxt->pstate, con->location)));
2429                                 if (saw_deferrability)
2430                                         ereport(ERROR,
2431                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2432                                                          errmsg("multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed"),
2433                                                          parser_errposition(cxt->pstate, con->location)));
2434                                 saw_deferrability = true;
2435                                 lastprimarycon->deferrable = true;
2436                                 break;
2437
2438                         case CONSTR_ATTR_NOT_DEFERRABLE:
2439                                 if (!SUPPORTS_ATTRS(lastprimarycon))
2440                                         ereport(ERROR,
2441                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2442                                                          errmsg("misplaced NOT DEFERRABLE clause"),
2443                                                          parser_errposition(cxt->pstate, con->location)));
2444                                 if (saw_deferrability)
2445                                         ereport(ERROR,
2446                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2447                                                          errmsg("multiple DEFERRABLE/NOT DEFERRABLE clauses not allowed"),
2448                                                          parser_errposition(cxt->pstate, con->location)));
2449                                 saw_deferrability = true;
2450                                 lastprimarycon->deferrable = false;
2451                                 if (saw_initially &&
2452                                         lastprimarycon->initdeferred)
2453                                         ereport(ERROR,
2454                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2455                                                          errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
2456                                                          parser_errposition(cxt->pstate, con->location)));
2457                                 break;
2458
2459                         case CONSTR_ATTR_DEFERRED:
2460                                 if (!SUPPORTS_ATTRS(lastprimarycon))
2461                                         ereport(ERROR,
2462                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2463                                                          errmsg("misplaced INITIALLY DEFERRED clause"),
2464                                                          parser_errposition(cxt->pstate, con->location)));
2465                                 if (saw_initially)
2466                                         ereport(ERROR,
2467                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2468                                                          errmsg("multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed"),
2469                                                          parser_errposition(cxt->pstate, con->location)));
2470                                 saw_initially = true;
2471                                 lastprimarycon->initdeferred = true;
2472
2473                                 /*
2474                                  * If only INITIALLY DEFERRED appears, assume DEFERRABLE
2475                                  */
2476                                 if (!saw_deferrability)
2477                                         lastprimarycon->deferrable = true;
2478                                 else if (!lastprimarycon->deferrable)
2479                                         ereport(ERROR,
2480                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2481                                                          errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE"),
2482                                                          parser_errposition(cxt->pstate, con->location)));
2483                                 break;
2484
2485                         case CONSTR_ATTR_IMMEDIATE:
2486                                 if (!SUPPORTS_ATTRS(lastprimarycon))
2487                                         ereport(ERROR,
2488                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2489                                                          errmsg("misplaced INITIALLY IMMEDIATE clause"),
2490                                                          parser_errposition(cxt->pstate, con->location)));
2491                                 if (saw_initially)
2492                                         ereport(ERROR,
2493                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2494                                                          errmsg("multiple INITIALLY IMMEDIATE/DEFERRED clauses not allowed"),
2495                                                          parser_errposition(cxt->pstate, con->location)));
2496                                 saw_initially = true;
2497                                 lastprimarycon->initdeferred = false;
2498                                 break;
2499
2500                         default:
2501                                 /* Otherwise it's not an attribute */
2502                                 lastprimarycon = con;
2503                                 /* reset flags for new primary node */
2504                                 saw_deferrability = false;
2505                                 saw_initially = false;
2506                                 break;
2507                 }
2508         }
2509 }
2510
2511 /*
2512  * Special handling of type definition for a column
2513  */
2514 static void
2515 transformColumnType(CreateStmtContext *cxt, ColumnDef *column)
2516 {
2517         /*
2518          * All we really need to do here is verify that the type is valid,
2519          * including any collation spec that might be present.
2520          */
2521         Type            ctype = typenameType(cxt->pstate, column->typeName, NULL);
2522
2523         if (column->collClause)
2524         {
2525                 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(ctype);
2526                 Oid                     collOid;
2527
2528                 collOid = LookupCollation(cxt->pstate,
2529                                                                   column->collClause->collname,
2530                                                                   column->collClause->location);
2531                 /* Complain if COLLATE is applied to an uncollatable type */
2532                 if (!OidIsValid(typtup->typcollation))
2533                         ereport(ERROR,
2534                                         (errcode(ERRCODE_DATATYPE_MISMATCH),
2535                                          errmsg("collations are not supported by type %s",
2536                                                         format_type_be(HeapTupleGetOid(ctype))),
2537                                          parser_errposition(cxt->pstate,
2538                                                                                 column->collClause->location)));
2539         }
2540
2541         ReleaseSysCache(ctype);
2542 }
2543
2544
2545 /*
2546  * transformCreateSchemaStmt -
2547  *        analyzes the CREATE SCHEMA statement
2548  *
2549  * Split the schema element list into individual commands and place
2550  * them in the result list in an order such that there are no forward
2551  * references (e.g. GRANT to a table created later in the list). Note
2552  * that the logic we use for determining forward references is
2553  * presently quite incomplete.
2554  *
2555  * SQL92 also allows constraints to make forward references, so thumb through
2556  * the table columns and move forward references to a posterior alter-table
2557  * command.
2558  *
2559  * The result is a list of parse nodes that still need to be analyzed ---
2560  * but we can't analyze the later commands until we've executed the earlier
2561  * ones, because of possible inter-object references.
2562  *
2563  * Note: this breaks the rules a little bit by modifying schema-name fields
2564  * within passed-in structs.  However, the transformation would be the same
2565  * if done over, so it should be all right to scribble on the input to this
2566  * extent.
2567  */
2568 List *
2569 transformCreateSchemaStmt(CreateSchemaStmt *stmt)
2570 {
2571         CreateSchemaStmtContext cxt;
2572         List       *result;
2573         ListCell   *elements;
2574
2575         cxt.stmtType = "CREATE SCHEMA";
2576         cxt.schemaname = stmt->schemaname;
2577         cxt.authid = stmt->authid;
2578         cxt.sequences = NIL;
2579         cxt.tables = NIL;
2580         cxt.views = NIL;
2581         cxt.indexes = NIL;
2582         cxt.triggers = NIL;
2583         cxt.grants = NIL;
2584
2585         /*
2586          * Run through each schema element in the schema element list. Separate
2587          * statements by type, and do preliminary analysis.
2588          */
2589         foreach(elements, stmt->schemaElts)
2590         {
2591                 Node       *element = lfirst(elements);
2592
2593                 switch (nodeTag(element))
2594                 {
2595                         case T_CreateSeqStmt:
2596                                 {
2597                                         CreateSeqStmt *elp = (CreateSeqStmt *) element;
2598
2599                                         setSchemaName(cxt.schemaname, &elp->sequence->schemaname);
2600                                         cxt.sequences = lappend(cxt.sequences, element);
2601                                 }
2602                                 break;
2603
2604                         case T_CreateStmt:
2605                                 {
2606                                         CreateStmt *elp = (CreateStmt *) element;
2607
2608                                         setSchemaName(cxt.schemaname, &elp->relation->schemaname);
2609
2610                                         /*
2611                                          * XXX todo: deal with constraints
2612                                          */
2613                                         cxt.tables = lappend(cxt.tables, element);
2614                                 }
2615                                 break;
2616
2617                         case T_ViewStmt:
2618                                 {
2619                                         ViewStmt   *elp = (ViewStmt *) element;
2620
2621                                         setSchemaName(cxt.schemaname, &elp->view->schemaname);
2622
2623                                         /*
2624                                          * XXX todo: deal with references between views
2625                                          */
2626                                         cxt.views = lappend(cxt.views, element);
2627                                 }
2628                                 break;
2629
2630                         case T_IndexStmt:
2631                                 {
2632                                         IndexStmt  *elp = (IndexStmt *) element;
2633
2634                                         setSchemaName(cxt.schemaname, &elp->relation->schemaname);
2635                                         cxt.indexes = lappend(cxt.indexes, element);
2636                                 }
2637                                 break;
2638
2639                         case T_CreateTrigStmt:
2640                                 {
2641                                         CreateTrigStmt *elp = (CreateTrigStmt *) element;
2642
2643                                         setSchemaName(cxt.schemaname, &elp->relation->schemaname);
2644                                         cxt.triggers = lappend(cxt.triggers, element);
2645                                 }
2646                                 break;
2647
2648                         case T_GrantStmt:
2649                                 cxt.grants = lappend(cxt.grants, element);
2650                                 break;
2651
2652                         default:
2653                                 elog(ERROR, "unrecognized node type: %d",
2654                                          (int) nodeTag(element));
2655                 }
2656         }
2657
2658         result = NIL;
2659         result = list_concat(result, cxt.sequences);
2660         result = list_concat(result, cxt.tables);
2661         result = list_concat(result, cxt.views);
2662         result = list_concat(result, cxt.indexes);
2663         result = list_concat(result, cxt.triggers);
2664         result = list_concat(result, cxt.grants);
2665
2666         return result;
2667 }
2668
2669 /*
2670  * setSchemaName
2671  *              Set or check schema name in an element of a CREATE SCHEMA command
2672  */
2673 static void
2674 setSchemaName(char *context_schema, char **stmt_schema_name)
2675 {
2676         if (*stmt_schema_name == NULL)
2677                 *stmt_schema_name = context_schema;
2678         else if (strcmp(context_schema, *stmt_schema_name) != 0)
2679                 ereport(ERROR,
2680                                 (errcode(ERRCODE_INVALID_SCHEMA_DEFINITION),
2681                                  errmsg("CREATE specifies a schema (%s) "
2682                                                 "different from the one being created (%s)",
2683                                                 *stmt_schema_name, context_schema)));
2684 }