granicus.if.org Git - postgresql/blob - src/backend/parser/gram.y

   1 %{
   2
   3 /*#define YYDEBUG 1*/
   4 /*-------------------------------------------------------------------------
   5  *
   6  * gram.y
   7  *        POSTGRES SQL YACC rules/actions
   8  *
   9  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  10  * Portions Copyright (c) 1994, Regents of the University of California
  11  *
  12  *
  13  * IDENTIFICATION
  14  *        $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.456 2004/05/26 13:56:51 momjian Exp $
  15  *
  16  * HISTORY
  17  *        AUTHOR                        DATE                    MAJOR EVENT
  18  *        Andrew Yu                     Sept, 1994              POSTQUEL to SQL conversion
  19  *        Andrew Yu                     Oct, 1994               lispy code conversion
  20  *
  21  * NOTES
  22  *        CAPITALS are used to represent terminal symbols.
  23  *        non-capitals are used to represent non-terminals.
  24  *        SQL92-specific syntax is separated from plain SQL/Postgres syntax
  25  *        to help isolate the non-extensible portions of the parser.
  26  *
  27  *        In general, nothing in this file should initiate database accesses
  28  *        nor depend on changeable state (such as SET variables).  If you do
  29  *        database accesses, your code will fail when we have aborted the
  30  *        current transaction and are just parsing commands to find the next
  31  *        ROLLBACK or COMMIT.  If you make use of SET variables, then you
  32  *        will do the wrong thing in multi-query strings like this:
  33  *                      SET SQL_inheritance TO off; SELECT * FROM foo;
  34  *        because the entire string is parsed by gram.y before the SET gets
  35  *        executed.  Anything that depends on the database or changeable state
  36  *        should be handled inside parse_analyze() so that it happens at the
  37  *        right time not the wrong time.  The handling of SQL_inheritance is
  38  *        a good example.
  39  *
  40  * WARNINGS
  41  *        If you use a list, make sure the datum is a node so that the printing
  42  *        routines work.
  43  *
  44  *        Sometimes we assign constants to makeStrings. Make sure we don't free
  45  *        those.
  46  *
  47  *-------------------------------------------------------------------------
  48  */
  49 #include "postgres.h"
  50
  51 #include <ctype.h>
  52 #include <limits.h>
  53
  54 #include "access/htup.h"
  55 #include "catalog/index.h"
  56 #include "catalog/namespace.h"
  57 #include "catalog/pg_type.h"
  58 #include "nodes/makefuncs.h"
  59 #include "nodes/params.h"
  60 #include "nodes/parsenodes.h"
  61 #include "parser/gramparse.h"
  62 #include "storage/lmgr.h"
  63 #include "utils/numeric.h"
  64 #include "utils/datetime.h"
  65 #include "utils/date.h"
  66
  67 extern List *parsetree;                 /* final parse result is delivered here */
  68
  69 static bool QueryIsRule = FALSE;
  70
  71 /*
  72  * If you need access to certain yacc-generated variables and find that
  73  * they're static by default, uncomment the next line.  (this is not a
  74  * problem, yet.)
  75  */
  76 /*#define __YYSCLASS*/
  77
  78 static Node *makeTypeCast(Node *arg, TypeName *typename);
  79 static Node *makeStringConst(char *str, TypeName *typename);
  80 static Node *makeIntConst(int val);
  81 static Node *makeFloatConst(char *str);
  82 static Node *makeAConst(Value *v);
  83 static Node *makeRowNullTest(NullTestType test, RowExpr *row);
  84 static DefElem *makeDefElem(char *name, Node *arg);
  85 static A_Const *makeBoolAConst(bool state);
  86 static FuncCall *makeOverlaps(List *largs, List *rargs);
  87 static List *extractArgTypes(List *parameters);
  88 static SelectStmt *findLeftmostSelect(SelectStmt *node);
  89 static void insertSelectOptions(SelectStmt *stmt,
  90                                                                 List *sortClause, List *forUpdate,
  91                                                                 Node *limitOffset, Node *limitCount);
  92 static Node *makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg);
  93 static Node *doNegate(Node *n);
  94 static void doNegateFloat(Value *v);
  95
  96 %}
  97
  98
  99 %union
 100 {
 101         int                                     ival;
 102         char                            chr;
 103         char                            *str;
 104         const char                      *keyword;
 105         bool                            boolean;
 106         JoinType                        jtype;
 107         DropBehavior            dbehavior;
 108         OnCommitAction          oncommit;
 109         ContainsOids            withoids;
 110         List                            *list;
 111         FastList                        fastlist;
 112         Node                            *node;
 113         Value                           *value;
 114         ColumnRef                       *columnref;
 115         ObjectType                      objtype;
 116
 117         TypeName                        *typnam;
 118         FunctionParameter   *fun_param;
 119         DefElem                         *defelt;
 120         SortBy                          *sortby;
 121         JoinExpr                        *jexpr;
 122         IndexElem                       *ielem;
 123         Alias                           *alias;
 124         RangeVar                        *range;
 125         A_Indices                       *aind;
 126         ResTarget                       *target;
 127         PrivTarget                      *privtarget;
 128
 129         InsertStmt                      *istmt;
 130         VariableSetStmt         *vsetstmt;
 131 }
 132
 133 %type <node>    stmt schema_stmt
 134                 AlterDatabaseSetStmt AlterDomainStmt AlterGroupStmt
 135                 AlterSeqStmt AlterTableStmt AlterUserStmt AlterUserSetStmt
 136                 AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
 137                 ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
 138                 CreateDomainStmt CreateGroupStmt CreateOpClassStmt CreatePLangStmt
 139                 CreateSchemaStmt CreateSeqStmt CreateStmt
 140                 CreateAssertStmt CreateTrigStmt CreateUserStmt
 141                 CreatedbStmt DeclareCursorStmt DefineStmt DeleteStmt
 142                 DropGroupStmt DropOpClassStmt DropPLangStmt DropStmt
 143                 DropAssertStmt DropTrigStmt DropRuleStmt DropCastStmt
 144                 DropUserStmt DropdbStmt ExplainStmt FetchStmt
 145                 GrantStmt IndexStmt InsertStmt ListenStmt LoadStmt
 146                 LockStmt NotifyStmt ExplainableStmt PreparableStmt
 147                 CreateFunctionStmt ReindexStmt RemoveAggrStmt
 148                 RemoveFuncStmt RemoveOperStmt RenameStmt RevokeStmt
 149                 RuleActionStmt RuleActionStmtOrEmpty RuleStmt
 150                 SelectStmt TransactionStmt TruncateStmt
 151                 UnlistenStmt UpdateStmt VacuumStmt
 152                 VariableResetStmt VariableSetStmt VariableShowStmt
 153                 ViewStmt CheckPointStmt CreateConversionStmt
 154                 DeallocateStmt PrepareStmt ExecuteStmt
 155                 AlterDbOwnerStmt
 156
 157 %type <node>    select_no_parens select_with_parens select_clause
 158                                 simple_select
 159
 160 %type <node>    alter_column_default opclass_item alter_using
 161 %type <ival>    add_drop
 162
 163 %type <node>    alter_table_cmd
 164 %type <list>    alter_table_cmds
 165
 166 %type <dbehavior>       opt_drop_behavior
 167
 168 %type <list>    createdb_opt_list copy_opt_list
 169 %type <defelt>  createdb_opt_item copy_opt_item
 170
 171 %type <ival>    opt_lock lock_type cast_context
 172 %type <boolean> opt_force opt_or_replace transaction_access_mode
 173                                 opt_grant_grant_option opt_revoke_grant_option
 174                                 opt_nowait
 175
 176 %type <boolean> like_including_defaults
 177
 178 %type <list>    user_list
 179
 180 %type <list>    OptGroupList
 181 %type <defelt>  OptGroupElem
 182
 183 %type <list>    OptUserList
 184 %type <defelt>  OptUserElem
 185
 186 %type <str>             OptSchemaName
 187 %type <list>    OptSchemaEltList
 188
 189 %type <boolean> TriggerActionTime TriggerForSpec opt_trusted
 190 %type <str>             opt_lancompiler
 191
 192 %type <str>             TriggerEvents
 193 %type <value>   TriggerFuncArg
 194
 195 %type <str>             relation_name copy_file_name
 196                                 database_name access_method_clause access_method attr_name
 197                                 index_name name function_name file_name
 198
 199 %type <list>    func_name handler_name qual_Op qual_all_Op subquery_Op
 200                                 opt_class opt_validator
 201
 202 %type <range>   qualified_name OptConstrFromTable
 203
 204 %type <str>             all_Op MathOp SpecialRuleRelation
 205
 206 %type <str>             iso_level opt_encoding
 207 %type <node>    grantee
 208 %type <list>    grantee_list
 209 %type <ival>    privilege
 210 %type <list>    privileges privilege_list
 211 %type <privtarget> privilege_target
 212 %type <node>    function_with_argtypes
 213 %type <list>    function_with_argtypes_list
 214 %type <chr>     TriggerOneEvent
 215
 216 %type <list>    stmtblock stmtmulti
 217                                 OptTableElementList TableElementList OptInherit definition
 218                                 opt_distinct opt_definition func_args
 219                                 func_args_list func_as createfunc_opt_list
 220                                 oper_argtypes RuleActionList RuleActionMulti
 221                                 opt_column_list columnList opt_name_list
 222                                 sort_clause opt_sort_clause sortby_list index_params
 223                                 name_list from_clause from_list opt_array_bounds
 224                                 qualified_name_list any_name any_name_list
 225                                 any_operator expr_list dotted_name attrs
 226                                 target_list update_target_list insert_column_list
 227                                 insert_target_list def_list opt_indirection
 228                                 group_clause TriggerFuncArgs select_limit
 229                                 opt_select_limit opclass_item_list transaction_mode_list
 230                                 transaction_mode_list_or_empty
 231                                 TableFuncElementList
 232                                 prep_type_clause prep_type_list
 233                                 execute_param_clause
 234
 235 %type <range>   into_clause OptTempTableName
 236
 237 %type <defelt>  createfunc_opt_item
 238 %type <fun_param> func_arg
 239 %type <typnam>  func_return func_type aggr_argtype
 240
 241 %type <boolean> arg_class TriggerForType OptTemp
 242 %type <oncommit> OnCommitOption
 243 %type <withoids> OptWithOids WithOidsAs
 244
 245 %type <list>    for_update_clause opt_for_update_clause update_list
 246 %type <boolean> opt_all
 247
 248 %type <node>    join_outer join_qual
 249 %type <jtype>   join_type
 250
 251 %type <list>    extract_list overlay_list position_list
 252 %type <list>    substr_list trim_list
 253 %type <ival>    opt_interval
 254 %type <node>    overlay_placing substr_from substr_for
 255
 256 %type <boolean> opt_instead opt_analyze
 257 %type <boolean> index_opt_unique opt_verbose opt_full
 258 %type <boolean> opt_freeze opt_default opt_recheck
 259 %type <defelt>  opt_binary opt_oids copy_delimiter
 260
 261 %type <boolean> copy_from opt_hold
 262
 263 %type <ival>    fetch_count     opt_column event cursor_options
 264 %type <objtype> reindex_type drop_type comment_type
 265
 266 %type <node>    fetch_direction select_limit_value select_offset_value
 267
 268 %type <list>    OptSeqList
 269 %type <defelt>  OptSeqElem
 270
 271 %type <istmt>   insert_rest
 272
 273 %type <vsetstmt> set_rest
 274
 275 %type <node>    TableElement ConstraintElem TableFuncElement
 276 %type <node>    columnDef
 277 %type <defelt>  def_elem
 278 %type <node>    def_arg columnElem where_clause insert_column_item
 279                                 a_expr b_expr c_expr AexprConst
 280                                 in_expr having_clause func_table array_expr
 281 %type <list>    row type_list array_expr_list
 282 %type <node>    case_expr case_arg when_clause case_default
 283 %type <list>    when_clause_list
 284 %type <ival>    sub_type
 285 %type <list>    OptCreateAs CreateAsList
 286 %type <node>    CreateAsElement
 287 %type <value>   NumericOnly FloatOnly IntegerOnly
 288 %type <columnref>       columnref
 289 %type <alias>   alias_clause
 290 %type <sortby>  sortby
 291 %type <ielem>   index_elem
 292 %type <node>    table_ref
 293 %type <jexpr>   joined_table
 294 %type <range>   relation_expr
 295 %type <target>  target_el insert_target_el update_target_el
 296
 297 %type <typnam>  Typename SimpleTypename ConstTypename
 298                                 GenericType Numeric opt_float
 299                                 Character ConstCharacter
 300                                 CharacterWithLength CharacterWithoutLength
 301                                 ConstDatetime ConstInterval
 302                                 Bit ConstBit BitWithLength BitWithoutLength
 303 %type <str>             character
 304 %type <str>             extract_arg
 305 %type <str>             opt_charset
 306 %type <ival>    opt_numeric opt_decimal
 307 %type <boolean> opt_varying opt_timezone
 308
 309 %type <ival>    Iconst
 310 %type <str>             Sconst comment_text
 311 %type <str>             UserId opt_boolean ColId_or_Sconst
 312 %type <list>    var_list var_list_or_default
 313 %type <str>             ColId ColLabel type_name param_name
 314 %type <node>    var_value zone_value
 315
 316 %type <keyword> unreserved_keyword func_name_keyword
 317 %type <keyword> col_name_keyword reserved_keyword
 318
 319 %type <node>    TableConstraint TableLikeClause
 320 %type <list>    ColQualList
 321 %type <node>    ColConstraint ColConstraintElem ConstraintAttr
 322 %type <ival>    key_actions key_delete key_match key_update key_action
 323 %type <ival>    ConstraintAttributeSpec ConstraintDeferrabilitySpec
 324                                 ConstraintTimeSpec
 325
 326 %type <list>    constraints_set_list
 327 %type <boolean> constraints_set_mode
 328
 329
 330 /*
 331  * If you make any token changes, update the keyword table in
 332  * parser/keywords.c and add new keywords to the appropriate one of
 333  * the reserved-or-not-so-reserved keyword lists, below.
 334  */
 335
 336 /* ordinary key words in alphabetical order */
 337 %token <keyword> ABORT_P ABSOLUTE_P ACCESS ACTION ADD AFTER
 338         AGGREGATE ALL ALSO ALTER ANALYSE ANALYZE AND ANY ARRAY AS ASC
 339         ASSERTION ASSIGNMENT AT AUTHORIZATION
 340
 341         BACKWARD BEFORE BEGIN_P BETWEEN BIGINT BINARY BIT
 342         BOOLEAN_P BOTH BY
 343
 344         CACHE CALLED CASCADE CASE CAST CHAIN CHAR_P
 345         CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
 346         CLUSTER COALESCE COLLATE COLUMN COMMENT COMMIT
 347         COMMITTED CONSTRAINT CONSTRAINTS CONVERSION_P CONVERT COPY CREATE CREATEDB
 348         CREATEUSER CROSS CSV CURRENT_DATE CURRENT_TIME
 349         CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
 350
 351         DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
 352         DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS
 353         DESC DISTINCT DO DOMAIN_P DOUBLE_P DROP
 354
 355         EACH ELSE ENCODING ENCRYPTED END_P ESCAPE EXCEPT EXCLUDING
 356         EXCLUSIVE EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
 357
 358         FALSE_P FETCH FIRST_P FLOAT_P FOR FORCE FOREIGN FORWARD
 359         FREEZE FROM FULL FUNCTION
 360
 361         GLOBAL GRANT GROUP_P
 362
 363         HANDLER HAVING HOLD HOUR_P
 364
 365         ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P INCLUDING INCREMENT
 366         INDEX INHERITS INITIALLY INNER_P INOUT INPUT_P
 367         INSENSITIVE INSERT INSTEAD INT_P INTEGER INTERSECT
 368         INTERVAL INTO INVOKER IS ISNULL ISOLATION
 369
 370         JOIN
 371
 372         KEY
 373
 374         LANCOMPILER LANGUAGE LARGE_P LAST_P LEADING LEFT LEVEL LIKE LIMIT
 375         LISTEN LOAD LOCAL LOCALTIME LOCALTIMESTAMP LOCATION
 376         LOCK_P
 377
 378         MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
 379
 380         NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NOCREATEDB
 381         NOCREATEUSER NONE NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P
 382         NULLIF NUMERIC
 383
 384         OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OR
 385         ORDER OUT_P OUTER_P OVERLAPS OVERLAY OWNER
 386
 387         PARTIAL PASSWORD PATH_P PENDANT PLACING POSITION
 388         PRECISION PRESERVE PREPARE PRIMARY
 389         PRIOR PRIVILEGES PROCEDURAL PROCEDURE
 390
 391         QUOTE
 392
 393         READ REAL RECHECK REFERENCES REINDEX RELATIVE_P RENAME REPEATABLE REPLACE
 394         RESET RESTART RESTRICT RETURNS REVOKE RIGHT ROLLBACK ROW ROWS
 395         RULE
 396
 397         SCHEMA SCROLL SECOND_P SECURITY SELECT SEQUENCE
 398         SERIALIZABLE SESSION SESSION_USER SET SETOF SHARE
 399         SHOW SIMILAR SIMPLE SMALLINT SOME STABLE START STATEMENT
 400         STATISTICS STDIN STDOUT STORAGE STRICT_P SUBSTRING SYSID
 401
 402         TABLE TEMP TEMPLATE TEMPORARY THEN TIME TIMESTAMP
 403         TO TOAST TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P
 404         TRUNCATE TRUSTED TYPE_P
 405
 406         UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
 407         UPDATE USAGE USER USING
 408
 409         VACUUM VALID VALIDATOR VALUES VARCHAR VARYING
 410         VERBOSE VERSION VIEW VOLATILE
 411
 412         WHEN WHERE WITH WITHOUT WORK WRITE
 413
 414         YEAR_P
 415
 416         ZONE
 417
 418 /* The grammar thinks these are keywords, but they are not in the keywords.c
 419  * list and so can never be entered directly.  The filter in parser.c
 420  * creates these tokens when required.
 421  */
 422 %token                  UNIONJOIN
 423
 424 /* Special keywords, not in the query language - see the "lex" file */
 425 %token <str>    IDENT FCONST SCONST BCONST XCONST Op
 426 %token <ival>   ICONST PARAM
 427
 428 /* precedence: lowest to highest */
 429 %left           UNION EXCEPT
 430 %left           INTERSECT
 431 %left           OR
 432 %left           AND
 433 %right          NOT
 434 %right          '='
 435 %nonassoc       '<' '>'
 436 %nonassoc       LIKE ILIKE SIMILAR
 437 %nonassoc       ESCAPE
 438 %nonassoc       OVERLAPS
 439 %nonassoc       BETWEEN
 440 %nonassoc       IN_P
 441 %left           POSTFIXOP               /* dummy for postfix Op rules */
 442 %left           Op OPERATOR             /* multi-character ops and user-defined operators */
 443 %nonassoc       NOTNULL
 444 %nonassoc       ISNULL
 445 %nonassoc       IS NULL_P TRUE_P FALSE_P UNKNOWN /* sets precedence for IS NULL, etc */
 446 %left           '+' '-'
 447 %left           '*' '/' '%'
 448 %left           '^'
 449 /* Unary Operators */
 450 %left           AT ZONE                 /* sets precedence for AT TIME ZONE */
 451 %right          UMINUS
 452 %left           '[' ']'
 453 %left           '(' ')'
 454 %left           TYPECAST
 455 %left           '.'
 456 /*
 457  * These might seem to be low-precedence, but actually they are not part
 458  * of the arithmetic hierarchy at all in their use as JOIN operators.
 459  * We make them high-precedence to support their use as function names.
 460  * They wouldn't be given a precedence at all, were it not that we need
 461  * left-associativity among the JOIN rules themselves.
 462  */
 463 %left           JOIN UNIONJOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
 464 %%
 465
 466 /*
 467  *      Handle comment-only lines, and ;; SELECT * FROM pg_class ;;;
 468  *      psql already handles such cases, but other interfaces don't.
 469  *      bjm 1999/10/05
 470  */
 471 stmtblock:      stmtmulti                                                               { parsetree = $1; }
 472                 ;
 473
 474 /* the thrashing around here is to discard "empty" statements... */
 475 stmtmulti:      stmtmulti ';' stmt
 476                                 { if ($3 != NULL)
 477                                         $$ = lappend($1, $3);
 478                                   else
 479                                         $$ = $1;
 480                                 }
 481                         | stmt
 482                                         { if ($1 != NULL)
 483                                                 $$ = makeList1($1);
 484                                           else
 485                                                 $$ = NIL;
 486                                         }
 487                 ;
 488
 489 stmt :
 490                         AlterDbOwnerStmt
 491                         | AlterDatabaseSetStmt
 492                         | AlterDomainStmt
 493                         | AlterGroupStmt
 494                         | AlterSeqStmt
 495                         | AlterTableStmt
 496                         | AlterUserSetStmt
 497                         | AlterUserStmt
 498                         | AnalyzeStmt
 499                         | CheckPointStmt
 500                         | ClosePortalStmt
 501                         | ClusterStmt
 502                         | CommentStmt
 503                         | ConstraintsSetStmt
 504                         | CopyStmt
 505                         | CreateAsStmt
 506                         | CreateAssertStmt
 507                         | CreateCastStmt
 508                         | CreateConversionStmt
 509                         | CreateDomainStmt
 510                         | CreateFunctionStmt
 511                         | CreateGroupStmt
 512                         | CreateOpClassStmt
 513                         | CreatePLangStmt
 514                         | CreateSchemaStmt
 515                         | CreateSeqStmt
 516                         | CreateStmt
 517                         | CreateTrigStmt
 518                         | CreateUserStmt
 519                         | CreatedbStmt
 520                         | DeallocateStmt
 521                         | DeclareCursorStmt
 522                         | DefineStmt
 523                         | DeleteStmt
 524                         | DropAssertStmt
 525                         | DropCastStmt
 526                         | DropGroupStmt
 527                         | DropOpClassStmt
 528                         | DropPLangStmt
 529                         | DropRuleStmt
 530                         | DropStmt
 531                         | DropTrigStmt
 532                         | DropUserStmt
 533                         | DropdbStmt
 534                         | ExecuteStmt
 535                         | ExplainStmt
 536                         | FetchStmt
 537                         | GrantStmt
 538                         | IndexStmt
 539                         | InsertStmt
 540                         | ListenStmt
 541                         | LoadStmt
 542                         | LockStmt
 543                         | NotifyStmt
 544                         | PrepareStmt
 545                         | ReindexStmt
 546                         | RemoveAggrStmt
 547                         | RemoveFuncStmt
 548                         | RemoveOperStmt
 549                         | RenameStmt
 550                         | RevokeStmt
 551                         | RuleStmt
 552                         | SelectStmt
 553                         | TransactionStmt
 554                         | TruncateStmt
 555                         | UnlistenStmt
 556                         | UpdateStmt
 557                         | VacuumStmt
 558                         | VariableResetStmt
 559                         | VariableSetStmt
 560                         | VariableShowStmt
 561                         | ViewStmt
 562                         | /*EMPTY*/
 563                                 { $$ = NULL; }
 564                 ;
 565
 566 /*****************************************************************************
 567  *
 568  * Create a new Postgres DBMS user
 569  *
 570  *
 571  *****************************************************************************/
 572
 573 CreateUserStmt:
 574                         CREATE USER UserId opt_with OptUserList
 575                                 {
 576                                         CreateUserStmt *n = makeNode(CreateUserStmt);
 577                                         n->user = $3;
 578                                         n->options = $5;
 579                                         $$ = (Node *)n;
 580                                 }
 581                 ;
 582
 583
 584 opt_with:       WITH                                                                    {}
 585                         | /*EMPTY*/                                                             {}
 586                 ;
 587
 588 /*****************************************************************************
 589  *
 590  * Alter a postgresql DBMS user
 591  *
 592  *
 593  *****************************************************************************/
 594
 595 AlterUserStmt:
 596                         ALTER USER UserId opt_with OptUserList
 597                                  {
 598                                         AlterUserStmt *n = makeNode(AlterUserStmt);
 599                                         n->user = $3;
 600                                         n->options = $5;
 601                                         $$ = (Node *)n;
 602                                  }
 603                 ;
 604
 605
 606 AlterUserSetStmt:
 607                         ALTER USER UserId SET set_rest
 608                                 {
 609                                         AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
 610                                         n->user = $3;
 611                                         n->variable = $5->name;
 612                                         n->value = $5->args;
 613                                         $$ = (Node *)n;
 614                                 }
 615                         | ALTER USER UserId VariableResetStmt
 616                                 {
 617                                         AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
 618                                         n->user = $3;
 619                                         n->variable = ((VariableResetStmt *)$4)->name;
 620                                         n->value = NIL;
 621                                         $$ = (Node *)n;
 622                                 }
 623                         ;
 624
 625
 626 /*****************************************************************************
 627  *
 628  * Drop a postgresql DBMS user
 629  *
 630  * XXX Ideally this would have CASCADE/RESTRICT options, but since a user
 631  * might own objects in multiple databases, there is presently no way to
 632  * implement either cascading or restricting.  Caveat DBA.
 633  *****************************************************************************/
 634
 635 DropUserStmt:
 636                         DROP USER user_list
 637                                 {
 638                                         DropUserStmt *n = makeNode(DropUserStmt);
 639                                         n->users = $3;
 640                                         $$ = (Node *)n;
 641                                 }
 642                         ;
 643
 644 /*
 645  * Options for CREATE USER and ALTER USER
 646  */
 647 OptUserList:
 648                         OptUserList OptUserElem                                 { $$ = lappend($1, $2); }
 649                         | /* EMPTY */                                                   { $$ = NIL; }
 650                 ;
 651
 652 OptUserElem:
 653                         PASSWORD Sconst
 654                                 {
 655                                         $$ = makeDefElem("password", (Node *)makeString($2));
 656                                 }
 657                         | ENCRYPTED PASSWORD Sconst
 658                                 {
 659                                         $$ = makeDefElem("encryptedPassword", (Node *)makeString($3));
 660                                 }
 661                         | UNENCRYPTED PASSWORD Sconst
 662                                 {
 663                                         $$ = makeDefElem("unencryptedPassword", (Node *)makeString($3));
 664                                 }
 665                         | SYSID Iconst
 666                                 {
 667                                         $$ = makeDefElem("sysid", (Node *)makeInteger($2));
 668                                 }
 669                         | CREATEDB
 670                                 {
 671                                         $$ = makeDefElem("createdb", (Node *)makeInteger(TRUE));
 672                                 }
 673                         | NOCREATEDB
 674                                 {
 675                                         $$ = makeDefElem("createdb", (Node *)makeInteger(FALSE));
 676                                 }
 677                         | CREATEUSER
 678                                 {
 679                                         $$ = makeDefElem("createuser", (Node *)makeInteger(TRUE));
 680                                 }
 681                         | NOCREATEUSER
 682                                 {
 683                                         $$ = makeDefElem("createuser", (Node *)makeInteger(FALSE));
 684                                 }
 685                         | IN_P GROUP_P user_list
 686                                 {
 687                                         $$ = makeDefElem("groupElts", (Node *)$3);
 688                                 }
 689                         | VALID UNTIL Sconst
 690                                 {
 691                                         $$ = makeDefElem("validUntil", (Node *)makeString($3));
 692                                 }
 693                 ;
 694
 695 user_list:      user_list ',' UserId            { $$ = lappend($1, makeString($3)); }
 696                         | UserId                                        { $$ = makeList1(makeString($1)); }
 697                 ;
 698
 699
 700
 701 /*****************************************************************************
 702  *
 703  * Create a postgresql group
 704  *
 705  *
 706  *****************************************************************************/
 707
 708 CreateGroupStmt:
 709                         CREATE GROUP_P UserId opt_with OptGroupList
 710                                 {
 711                                         CreateGroupStmt *n = makeNode(CreateGroupStmt);
 712                                         n->name = $3;
 713                                         n->options = $5;
 714                                         $$ = (Node *)n;
 715                                 }
 716                 ;
 717
 718 /*
 719  * Options for CREATE GROUP
 720  */
 721 OptGroupList:
 722                         OptGroupList OptGroupElem                               { $$ = lappend($1, $2); }
 723                         | /* EMPTY */                                                   { $$ = NIL; }
 724                 ;
 725
 726 OptGroupElem:
 727                         USER user_list
 728                                 {
 729                                         $$ = makeDefElem("userElts", (Node *)$2);
 730                                 }
 731                         | SYSID Iconst
 732                                 {
 733                                         $$ = makeDefElem("sysid", (Node *)makeInteger($2));
 734                                 }
 735                 ;
 736
 737
 738 /*****************************************************************************
 739  *
 740  * Alter a postgresql group
 741  *
 742  *
 743  *****************************************************************************/
 744
 745 AlterGroupStmt:
 746                         ALTER GROUP_P UserId add_drop USER user_list
 747                                 {
 748                                         AlterGroupStmt *n = makeNode(AlterGroupStmt);
 749                                         n->name = $3;
 750                                         n->action = $4;
 751                                         n->listUsers = $6;
 752                                         $$ = (Node *)n;
 753                                 }
 754                 ;
 755
 756 add_drop:       ADD                                                                             { $$ = +1; }
 757                         | DROP                                                                  { $$ = -1; }
 758                 ;
 759
 760
 761 /*****************************************************************************
 762  *
 763  * Drop a postgresql group
 764  *
 765  * XXX see above notes about cascading DROP USER; groups have same problem.
 766  *****************************************************************************/
 767
 768 DropGroupStmt:
 769                         DROP GROUP_P UserId
 770                                 {
 771                                         DropGroupStmt *n = makeNode(DropGroupStmt);
 772                                         n->name = $3;
 773                                         $$ = (Node *)n;
 774                                 }
 775                 ;
 776
 777
 778 /*****************************************************************************
 779  *
 780  * Manipulate a schema
 781  *
 782  *****************************************************************************/
 783
 784 CreateSchemaStmt:
 785                         CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
 786                                 {
 787                                         CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
 788                                         /* One can omit the schema name or the authorization id. */
 789                                         if ($3 != NULL)
 790                                                 n->schemaname = $3;
 791                                         else
 792                                                 n->schemaname = $5;
 793                                         n->authid = $5;
 794                                         n->schemaElts = $6;
 795                                         $$ = (Node *)n;
 796                                 }
 797                         | CREATE SCHEMA ColId OptSchemaEltList
 798                                 {
 799                                         CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
 800                                         /* ...but not both */
 801                                         n->schemaname = $3;
 802                                         n->authid = NULL;
 803                                         n->schemaElts = $4;
 804                                         $$ = (Node *)n;
 805                                 }
 806                 ;
 807
 808 OptSchemaName:
 809                         ColId                                                                   { $$ = $1; }
 810                         | /* EMPTY */                                                   { $$ = NULL; }
 811                 ;
 812
 813 OptSchemaEltList:
 814                         OptSchemaEltList schema_stmt                    { $$ = lappend($1, $2); }
 815                         | /* EMPTY */                                                   { $$ = NIL; }
 816                 ;
 817
 818 /*
 819  *      schema_stmt are the ones that can show up inside a CREATE SCHEMA
 820  *      statement (in addition to by themselves).
 821  */
 822 schema_stmt:
 823                         CreateStmt
 824                         | IndexStmt
 825                         | CreateSeqStmt
 826                         | CreateTrigStmt
 827                         | GrantStmt
 828                         | ViewStmt
 829                 ;
 830
 831
 832 /*****************************************************************************
 833  *
 834  * Set PG internal variable
 835  *        SET name TO 'var_value'
 836  * Include SQL92 syntax (thomas 1997-10-22):
 837  *        SET TIME ZONE 'var_value'
 838  *
 839  *****************************************************************************/
 840
 841 VariableSetStmt:
 842                         SET set_rest
 843                                 {
 844                                         VariableSetStmt *n = $2;
 845                                         n->is_local = false;
 846                                         $$ = (Node *) n;
 847                                 }
 848                         | SET LOCAL set_rest
 849                                 {
 850                                         VariableSetStmt *n = $3;
 851                                         n->is_local = true;
 852                                         $$ = (Node *) n;
 853                                 }
 854                         | SET SESSION set_rest
 855                                 {
 856                                         VariableSetStmt *n = $3;
 857                                         n->is_local = false;
 858                                         $$ = (Node *) n;
 859                                 }
 860                 ;
 861
 862 set_rest:  ColId TO var_list_or_default
 863                                 {
 864                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 865                                         n->name = $1;
 866                                         n->args = $3;
 867                                         $$ = n;
 868                                 }
 869                         | ColId '=' var_list_or_default
 870                                 {
 871                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 872                                         n->name = $1;
 873                                         n->args = $3;
 874                                         $$ = n;
 875                                 }
 876                         | TIME ZONE zone_value
 877                                 {
 878                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 879                                         n->name = "timezone";
 880                                         if ($3 != NULL)
 881                                                 n->args = makeList1($3);
 882                                         $$ = n;
 883                                 }
 884                         | TRANSACTION transaction_mode_list
 885                                 {
 886                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 887                                         n->name = "TRANSACTION";
 888                                         n->args = $2;
 889                                         $$ = n;
 890                                 }
 891                         | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list
 892                                 {
 893                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 894                                         n->name = "SESSION CHARACTERISTICS";
 895                                         n->args = $5;
 896                                         $$ = n;
 897                                 }
 898                         | NAMES opt_encoding
 899                                 {
 900                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 901                                         n->name = "client_encoding";
 902                                         if ($2 != NULL)
 903                                                 n->args = makeList1(makeStringConst($2, NULL));
 904                                         $$ = n;
 905                                 }
 906                         | SESSION AUTHORIZATION ColId_or_Sconst
 907                                 {
 908                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 909                                         n->name = "session_authorization";
 910                                         n->args = makeList1(makeStringConst($3, NULL));
 911                                         $$ = n;
 912                                 }
 913                         | SESSION AUTHORIZATION DEFAULT
 914                                 {
 915                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 916                                         n->name = "session_authorization";
 917                                         n->args = NIL;
 918                                         $$ = n;
 919                                 }
 920                 ;
 921
 922 var_list_or_default:
 923                         var_list                                                                { $$ = $1; }
 924                         | DEFAULT                                                               { $$ = NIL; }
 925                 ;
 926
 927 var_list:       var_value                                                               { $$ = makeList1($1); }
 928                         | var_list ',' var_value                                { $$ = lappend($1, $3); }
 929                 ;
 930
 931 var_value:      opt_boolean
 932                                 { $$ = makeStringConst($1, NULL); }
 933                         | ColId_or_Sconst
 934                                 { $$ = makeStringConst($1, NULL); }
 935                         | NumericOnly
 936                                 { $$ = makeAConst($1); }
 937                 ;
 938
 939 iso_level:      READ UNCOMMITTED                                                { $$ = "read uncommitted"; }
 940                         | READ COMMITTED                                                { $$ = "read committed"; }
 941                         | REPEATABLE READ                                               { $$ = "repeatable read"; }
 942                         | SERIALIZABLE                                                  { $$ = "serializable"; }
 943                 ;
 944
 945 opt_boolean:
 946                         TRUE_P                                                                  { $$ = "true"; }
 947                         | FALSE_P                                                               { $$ = "false"; }
 948                         | ON                                                                    { $$ = "on"; }
 949                         | OFF                                                                   { $$ = "off"; }
 950                 ;
 951
 952 /* Timezone values can be:
 953  * - a string such as 'pst8pdt'
 954  * - an identifier such as "pst8pdt"
 955  * - an integer or floating point number
 956  * - a time interval per SQL99
 957  * ColId gives reduce/reduce errors against ConstInterval and LOCAL,
 958  * so use IDENT and reject anything which is a reserved word.
 959  */
 960 zone_value:
 961                         Sconst
 962                                 {
 963                                         $$ = makeStringConst($1, NULL);
 964                                 }
 965                         | IDENT
 966                                 {
 967                                         $$ = makeStringConst($1, NULL);
 968                                 }
 969                         | ConstInterval Sconst opt_interval
 970                                 {
 971                                         A_Const *n = (A_Const *) makeStringConst($2, $1);
 972                                         if ($3 != INTERVAL_FULL_RANGE)
 973                                         {
 974                                                 if (($3 & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
 975                                                         ereport(ERROR,
 976                                                                         (errcode(ERRCODE_SYNTAX_ERROR),
 977                                                                          errmsg("time zone interval must be HOUR or HOUR TO MINUTE")));
 978                                                 n->typename->typmod = INTERVAL_TYPMOD(INTERVAL_FULL_PRECISION, $3);
 979                                         }
 980                                         $$ = (Node *)n;
 981                                 }
 982                         | ConstInterval '(' Iconst ')' Sconst opt_interval
 983                                 {
 984                                         A_Const *n = (A_Const *) makeStringConst($5, $1);
 985                                         if ($3 < 0)
 986                                                 ereport(ERROR,
 987                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 988                                                                  errmsg("INTERVAL(%d) precision must not be negative",
 989                                                                                 $3)));
 990                                         if ($3 > MAX_INTERVAL_PRECISION)
 991                                         {
 992                                                 ereport(WARNING,
 993                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 994                                                                  errmsg("INTERVAL(%d) precision reduced to maximum allowed, %d",
 995                                                                                 $3, MAX_INTERVAL_PRECISION)));
 996                                                 $3 = MAX_INTERVAL_PRECISION;
 997                                         }
 998
 999                                         if (($6 != INTERVAL_FULL_RANGE)
1000                                                 && (($6 & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0))
1001                                                 ereport(ERROR,
1002                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
1003                                                                  errmsg("time zone interval must be HOUR or HOUR TO MINUTE")));
1004
1005                                         n->typename->typmod = INTERVAL_TYPMOD($3, $6);
1006
1007                                         $$ = (Node *)n;
1008                                 }
1009                         | NumericOnly                                                   { $$ = makeAConst($1); }
1010                         | DEFAULT                                                               { $$ = NULL; }
1011                         | LOCAL                                                                 { $$ = NULL; }
1012                 ;
1013
1014 opt_encoding:
1015                         Sconst                                                                  { $$ = $1; }
1016                         | DEFAULT                                                               { $$ = NULL; }
1017                         | /*EMPTY*/                                                             { $$ = NULL; }
1018                 ;
1019
1020 ColId_or_Sconst:
1021                         ColId                                                                   { $$ = $1; }
1022                         | SCONST                                                                { $$ = $1; }
1023                 ;
1024
1025
1026 VariableShowStmt:
1027                         SHOW ColId
1028                                 {
1029                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1030                                         n->name = $2;
1031                                         $$ = (Node *) n;
1032                                 }
1033                         | SHOW TIME ZONE
1034                                 {
1035                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1036                                         n->name = "timezone";
1037                                         $$ = (Node *) n;
1038                                 }
1039                         | SHOW TRANSACTION ISOLATION LEVEL
1040                                 {
1041                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1042                                         n->name = "transaction_isolation";
1043                                         $$ = (Node *) n;
1044                                 }
1045                         | SHOW SESSION AUTHORIZATION
1046                                 {
1047                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1048                                         n->name = "session_authorization";
1049                                         $$ = (Node *) n;
1050                                 }
1051                         | SHOW ALL
1052                                 {
1053                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1054                                         n->name = "all";
1055                                         $$ = (Node *) n;
1056                                 }
1057                 ;
1058
1059 VariableResetStmt:
1060                         RESET ColId
1061                                 {
1062                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1063                                         n->name = $2;
1064                                         $$ = (Node *) n;
1065                                 }
1066                         | RESET TIME ZONE
1067                                 {
1068                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1069                                         n->name = "timezone";
1070                                         $$ = (Node *) n;
1071                                 }
1072                         | RESET TRANSACTION ISOLATION LEVEL
1073                                 {
1074                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1075                                         n->name = "transaction_isolation";
1076                                         $$ = (Node *) n;
1077                                 }
1078                         | RESET SESSION AUTHORIZATION
1079                                 {
1080                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1081                                         n->name = "session_authorization";
1082                                         $$ = (Node *) n;
1083                                 }
1084                         | RESET ALL
1085                                 {
1086                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1087                                         n->name = "all";
1088                                         $$ = (Node *) n;
1089                                 }
1090                 ;
1091
1092
1093 ConstraintsSetStmt:
1094                         SET CONSTRAINTS constraints_set_list constraints_set_mode
1095                                 {
1096                                         ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt);
1097                                         n->constraints = $3;
1098                                         n->deferred    = $4;
1099                                         $$ = (Node *) n;
1100                                 }
1101                 ;
1102
1103 constraints_set_list:
1104                         ALL                                                                             { $$ = NIL; }
1105                         | name_list                                                             { $$ = $1; }
1106                 ;
1107
1108 constraints_set_mode:
1109                         DEFERRED                                                                { $$ = TRUE; }
1110                         | IMMEDIATE                                                             { $$ = FALSE; }
1111                 ;
1112
1113
1114 /*
1115  * Checkpoint statement
1116  */
1117 CheckPointStmt:
1118                         CHECKPOINT
1119                                 {
1120                                         CheckPointStmt *n = makeNode(CheckPointStmt);
1121                                         $$ = (Node *)n;
1122                                 }
1123                 ;
1124
1125
1126 /*****************************************************************************
1127  *
1128  *      ALTER TABLE variations
1129  *
1130  *****************************************************************************/
1131
1132 AlterTableStmt:
1133                         ALTER TABLE relation_expr alter_table_cmds
1134                                 {
1135                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1136                                         n->relation = $3;
1137                                         n->cmds = $4;
1138                                         $$ = (Node *)n;
1139                                 }
1140                 ;
1141
1142 alter_table_cmds:
1143                         alter_table_cmd                                                 { $$ = makeList1($1); }
1144                         | alter_table_cmds ',' alter_table_cmd  { $$ = lappend($1, $3); }
1145                 ;
1146
1147 alter_table_cmd:
1148                         /* ALTER TABLE <relation> ADD [COLUMN] <coldef> */
1149                         ADD opt_column columnDef
1150                                 {
1151                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1152                                         n->subtype = AT_AddColumn;
1153                                         n->def = $3;
1154                                         $$ = (Node *)n;
1155                                 }
1156                         /* ALTER TABLE <relation> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
1157                         | ALTER opt_column ColId alter_column_default
1158                                 {
1159                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1160                                         n->subtype = AT_ColumnDefault;
1161                                         n->name = $3;
1162                                         n->def = $4;
1163                                         $$ = (Node *)n;
1164                                 }
1165                         /* ALTER TABLE <relation> ALTER [COLUMN] <colname> DROP NOT NULL */
1166                         | ALTER opt_column ColId DROP NOT NULL_P
1167                                 {
1168                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1169                                         n->subtype = AT_DropNotNull;
1170                                         n->name = $3;
1171                                         $$ = (Node *)n;
1172                                 }
1173                         /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET NOT NULL */
1174                         | ALTER opt_column ColId SET NOT NULL_P
1175                                 {
1176                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1177                                         n->subtype = AT_SetNotNull;
1178                                         n->name = $3;
1179                                         $$ = (Node *)n;
1180                                 }
1181                         /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STATISTICS <IntegerOnly> */
1182                         | ALTER opt_column ColId SET STATISTICS IntegerOnly
1183                                 {
1184                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1185                                         n->subtype = AT_SetStatistics;
1186                                         n->name = $3;
1187                                         n->def = (Node *) $6;
1188                                         $$ = (Node *)n;
1189                                 }
1190                         /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
1191                         | ALTER opt_column ColId SET STORAGE ColId
1192                                 {
1193                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1194                                         n->subtype = AT_SetStorage;
1195                                         n->name = $3;
1196                                         n->def = (Node *) makeString($6);
1197                                         $$ = (Node *)n;
1198                                 }
1199                         /* ALTER TABLE <relation> DROP [COLUMN] <colname> [RESTRICT|CASCADE] */
1200                         | DROP opt_column ColId opt_drop_behavior
1201                                 {
1202                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1203                                         n->subtype = AT_DropColumn;
1204                                         n->name = $3;
1205                                         n->behavior = $4;
1206                                         $$ = (Node *)n;
1207                                 }
1208                         /*
1209                          * ALTER TABLE <relation> ALTER [COLUMN] <colname> TYPE <typename>
1210                          *              [ USING <expression> ]
1211                          */
1212                         | ALTER opt_column ColId TYPE_P Typename alter_using
1213                                 {
1214                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1215                                         n->subtype = AT_AlterColumnType;
1216                                         n->name = $3;
1217                                         n->def = (Node *) $5;
1218                                         n->transform = $6;
1219                                         $$ = (Node *)n;
1220                                 }
1221                         /* ALTER TABLE <relation> ADD CONSTRAINT ... */
1222                         | ADD TableConstraint
1223                                 {
1224                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1225                                         n->subtype = AT_AddConstraint;
1226                                         n->def = $2;
1227                                         $$ = (Node *)n;
1228                                 }
1229                         /* ALTER TABLE <relation> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
1230                         | DROP CONSTRAINT name opt_drop_behavior
1231                                 {
1232                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1233                                         n->subtype = AT_DropConstraint;
1234                                         n->name = $3;
1235                                         n->behavior = $4;
1236                                         $$ = (Node *)n;
1237                                 }
1238                         /* ALTER TABLE <relation> SET WITHOUT OIDS  */
1239                         | SET WITHOUT OIDS
1240                                 {
1241                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1242                                         n->subtype = AT_DropOids;
1243                                         $$ = (Node *)n;
1244                                 }
1245                         /* ALTER TABLE <name> CREATE TOAST TABLE -- ONLY */
1246                         | CREATE TOAST TABLE
1247                                 {
1248                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1249                                         n->subtype = AT_ToastTable;
1250                                         $$ = (Node *)n;
1251                                 }
1252                         /* ALTER TABLE <name> OWNER TO UserId */
1253                         |  OWNER TO UserId
1254                                 {
1255                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1256                                         n->subtype = AT_ChangeOwner;
1257                                         n->name = $3;
1258                                         $$ = (Node *)n;
1259                                 }
1260                         /* ALTER TABLE <name> CLUSTER ON <indexname> */
1261                         | CLUSTER ON name
1262                                 {
1263                                         AlterTableCmd *n = makeNode(AlterTableCmd);
1264                                         n->subtype = AT_ClusterOn;
1265                                         n->name = $3;
1266                                         $$ = (Node *)n;
1267                                 }
1268                 ;
1269
1270 alter_column_default:
1271                         SET DEFAULT a_expr
1272                                 {
1273                                         /* Treat SET DEFAULT NULL the same as DROP DEFAULT */
1274                                         if (exprIsNullConstant($3))
1275                                                 $$ = NULL;
1276                                         else
1277                                                 $$ = $3;
1278                                 }
1279                         | DROP DEFAULT                          { $$ = NULL; }
1280                 ;
1281
1282 opt_drop_behavior:
1283                         CASCADE                                         { $$ = DROP_CASCADE; }
1284                         | RESTRICT                                      { $$ = DROP_RESTRICT; }
1285                         | /* EMPTY */                           { $$ = DROP_RESTRICT; /* default */ }
1286                 ;
1287
1288 alter_using:
1289                         USING a_expr                            { $$ = $2; }
1290                         | /* EMPTY */                           { $$ = NULL; }
1291                 ;
1292
1293 /*****************************************************************************
1294  *
1295  *              QUERY :
1296  *                              close <portalname>
1297  *
1298  *****************************************************************************/
1299
1300 ClosePortalStmt:
1301                         CLOSE name
1302                                 {
1303                                         ClosePortalStmt *n = makeNode(ClosePortalStmt);
1304                                         n->portalname = $2;
1305                                         $$ = (Node *)n;
1306                                 }
1307                 ;
1308
1309
1310 /*****************************************************************************
1311  *
1312  *              QUERY :
1313  *                              COPY <relname> ['(' columnList ')'] FROM/TO [WITH options]
1314  *
1315  *                              BINARY, OIDS, and DELIMITERS kept in old locations
1316  *                              for backward compatibility.  2002-06-18
1317  *
1318  *****************************************************************************/
1319
1320 CopyStmt:       COPY opt_binary qualified_name opt_column_list opt_oids
1321                         copy_from copy_file_name copy_delimiter opt_with copy_opt_list
1322                                 {
1323                                         CopyStmt *n = makeNode(CopyStmt);
1324                                         n->relation = $3;
1325                                         n->attlist = $4;
1326                                         n->is_from = $6;
1327                                         n->filename = $7;
1328
1329                                         n->options = NIL;
1330                                         /* Concatenate user-supplied flags */
1331                                         if ($2)
1332                                                 n->options = lappend(n->options, $2);
1333                                         if ($5)
1334                                                 n->options = lappend(n->options, $5);
1335                                         if ($8)
1336                                                 n->options = lappend(n->options, $8);
1337                                         if ($10)
1338                                                 n->options = nconc(n->options, $10);
1339                                         $$ = (Node *)n;
1340                                 }
1341                 ;
1342
1343 copy_from:
1344                         FROM                                                                    { $$ = TRUE; }
1345                         | TO                                                                    { $$ = FALSE; }
1346                 ;
1347
1348 /*
1349  * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
1350  * used depends on the direction. (It really doesn't make sense to copy from
1351  * stdout. We silently correct the "typo".               - AY 9/94
1352  */
1353 copy_file_name:
1354                         Sconst                                                                  { $$ = $1; }
1355                         | STDIN                                                                 { $$ = NULL; }
1356                         | STDOUT                                                                { $$ = NULL; }
1357                 ;
1358
1359
1360
1361 copy_opt_list:
1362                         copy_opt_list copy_opt_item                             { $$ = lappend($1, $2); }
1363                         | /* EMPTY */                                                   { $$ = NIL; }
1364                 ;
1365
1366
1367 copy_opt_item:
1368                         BINARY
1369                                 {
1370                                         $$ = makeDefElem("binary", (Node *)makeInteger(TRUE));
1371                                 }
1372                         | OIDS
1373                                 {
1374                                         $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
1375                                 }
1376                         | DELIMITER opt_as Sconst
1377                                 {
1378                                         $$ = makeDefElem("delimiter", (Node *)makeString($3));
1379                                 }
1380                         | NULL_P opt_as Sconst
1381                                 {
1382                                         $$ = makeDefElem("null", (Node *)makeString($3));
1383                                 }
1384                         | CSV
1385                                 {
1386                                         $$ = makeDefElem("csv", (Node *)makeInteger(TRUE));
1387                                 }
1388                         | QUOTE opt_as Sconst
1389                                 {
1390                                         $$ = makeDefElem("quote", (Node *)makeString($3));
1391                                 }
1392                         | ESCAPE opt_as Sconst
1393                                 {
1394                                         $$ = makeDefElem("escape", (Node *)makeString($3));
1395                                 }
1396                         | FORCE QUOTE columnList
1397                                 {
1398                                         $$ = makeDefElem("force_quote", (Node *)$3);
1399                                 }
1400                         | FORCE NOT NULL_P columnList
1401                                 {
1402                                         $$ = makeDefElem("force_notnull", (Node *)$4);
1403                                 }
1404                 ;
1405
1406 /* The following exist for backward compatibility */
1407
1408 opt_binary:
1409                         BINARY
1410                                 {
1411                                         $$ = makeDefElem("binary", (Node *)makeInteger(TRUE));
1412                                 }
1413                         | /*EMPTY*/                                                             { $$ = NULL; }
1414                 ;
1415
1416 opt_oids:
1417                         WITH OIDS
1418                                 {
1419                                         $$ = makeDefElem("oids", (Node *)makeInteger(TRUE));
1420                                 }
1421                         | /*EMPTY*/                                                             { $$ = NULL; }
1422                 ;
1423
1424 copy_delimiter:
1425                         /* USING DELIMITERS kept for backward compatibility. 2002-06-15 */
1426                         opt_using DELIMITERS Sconst
1427                                 {
1428                                         $$ = makeDefElem("delimiter", (Node *)makeString($3));
1429                                 }
1430                         | /*EMPTY*/                                                             { $$ = NULL; }
1431                 ;
1432
1433 opt_using:
1434                         USING                                                                   {}
1435                         | /*EMPTY*/                                                             {}
1436                 ;
1437
1438
1439 /*****************************************************************************
1440  *
1441  *              QUERY :
1442  *                              CREATE TABLE relname
1443  *
1444  *****************************************************************************/
1445
1446 CreateStmt:     CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')'
1447                         OptInherit OptWithOids OnCommitOption
1448                                 {
1449                                         CreateStmt *n = makeNode(CreateStmt);
1450                                         $4->istemp = $2;
1451                                         n->relation = $4;
1452                                         n->tableElts = $6;
1453                                         n->inhRelations = $8;
1454                                         n->constraints = NIL;
1455                                         n->hasoids = $9;
1456                                         n->oncommit = $10;
1457                                         $$ = (Node *)n;
1458                                 }
1459                 | CREATE OptTemp TABLE qualified_name OF qualified_name
1460                         '(' OptTableElementList ')' OptWithOids OnCommitOption
1461                                 {
1462                                         /* SQL99 CREATE TABLE OF <UDT> (cols) seems to be satisfied
1463                                          * by our inheritance capabilities. Let's try it...
1464                                          */
1465                                         CreateStmt *n = makeNode(CreateStmt);
1466                                         $4->istemp = $2;
1467                                         n->relation = $4;
1468                                         n->tableElts = $8;
1469                                         n->inhRelations = makeList1($6);
1470                                         n->constraints = NIL;
1471                                         n->hasoids = $10;
1472                                         n->oncommit = $11;
1473                                         $$ = (Node *)n;
1474                                 }
1475                 ;
1476
1477 /*
1478  * Redundancy here is needed to avoid shift/reduce conflicts,
1479  * since TEMP is not a reserved word.  See also OptTempTableName.
1480  *
1481  * NOTE: we accept both GLOBAL and LOCAL options; since we have no modules
1482  * the LOCAL keyword is really meaningless.
1483  */
1484 OptTemp:        TEMPORARY                                               { $$ = TRUE; }
1485                         | TEMP                                                  { $$ = TRUE; }
1486                         | LOCAL TEMPORARY                               { $$ = TRUE; }
1487                         | LOCAL TEMP                                    { $$ = TRUE; }
1488                         | GLOBAL TEMPORARY                              { $$ = TRUE; }
1489                         | GLOBAL TEMP                                   { $$ = TRUE; }
1490                         | /*EMPTY*/                                             { $$ = FALSE; }
1491                 ;
1492
1493 OptTableElementList:
1494                         TableElementList                                        { $$ = $1; }
1495                         | /*EMPTY*/                                                     { $$ = NIL; }
1496                 ;
1497
1498 TableElementList:
1499                         TableElement
1500                                 {
1501                                         $$ = makeList1($1);
1502                                 }
1503                         | TableElementList ',' TableElement
1504                                 {
1505                                         $$ = lappend($1, $3);
1506                                 }
1507                 ;
1508
1509 TableElement:
1510                         columnDef                                                       { $$ = $1; }
1511                         | TableLikeClause                                       { $$ = $1; }
1512                         | TableConstraint                                       { $$ = $1; }
1513                 ;
1514
1515 columnDef:      ColId Typename ColQualList
1516                                 {
1517                                         ColumnDef *n = makeNode(ColumnDef);
1518                                         n->colname = $1;
1519                                         n->typename = $2;
1520                                         n->constraints = $3;
1521                                         n->is_local = true;
1522                                         $$ = (Node *)n;
1523                                 }
1524                 ;
1525
1526 ColQualList:
1527                         ColQualList ColConstraint                               { $$ = lappend($1, $2); }
1528                         | /*EMPTY*/                                                             { $$ = NIL; }
1529                 ;
1530
1531 ColConstraint:
1532                         CONSTRAINT name ColConstraintElem
1533                                 {
1534                                         switch (nodeTag($3))
1535                                         {
1536                                                 case T_Constraint:
1537                                                         {
1538                                                                 Constraint *n = (Constraint *)$3;
1539                                                                 n->name = $2;
1540                                                         }
1541                                                         break;
1542                                                 case T_FkConstraint:
1543                                                         {
1544                                                                 FkConstraint *n = (FkConstraint *)$3;
1545                                                                 n->constr_name = $2;
1546                                                         }
1547                                                         break;
1548                                                 default:
1549                                                         break;
1550                                         }
1551                                         $$ = $3;
1552                                 }
1553                         | ColConstraintElem                                             { $$ = $1; }
1554                         | ConstraintAttr                                                { $$ = $1; }
1555                 ;
1556
1557 /* DEFAULT NULL is already the default for Postgres.
1558  * But define it here and carry it forward into the system
1559  * to make it explicit.
1560  * - thomas 1998-09-13
1561  *
1562  * WITH NULL and NULL are not SQL92-standard syntax elements,
1563  * so leave them out. Use DEFAULT NULL to explicitly indicate
1564  * that a column may have that value. WITH NULL leads to
1565  * shift/reduce conflicts with WITH TIME ZONE anyway.
1566  * - thomas 1999-01-08
1567  *
1568  * DEFAULT expression must be b_expr not a_expr to prevent shift/reduce
1569  * conflict on NOT (since NOT might start a subsequent NOT NULL constraint,
1570  * or be part of a_expr NOT LIKE or similar constructs).
1571  */
1572 ColConstraintElem:
1573                         NOT NULL_P
1574                                 {
1575                                         Constraint *n = makeNode(Constraint);
1576                                         n->contype = CONSTR_NOTNULL;
1577                                         n->name = NULL;
1578                                         n->raw_expr = NULL;
1579                                         n->cooked_expr = NULL;
1580                                         n->keys = NULL;
1581                                         $$ = (Node *)n;
1582                                 }
1583                         | NULL_P
1584                                 {
1585                                         Constraint *n = makeNode(Constraint);
1586                                         n->contype = CONSTR_NULL;
1587                                         n->name = NULL;
1588                                         n->raw_expr = NULL;
1589                                         n->cooked_expr = NULL;
1590                                         n->keys = NULL;
1591                                         $$ = (Node *)n;
1592                                 }
1593                         | UNIQUE
1594                                 {
1595                                         Constraint *n = makeNode(Constraint);
1596                                         n->contype = CONSTR_UNIQUE;
1597                                         n->name = NULL;
1598                                         n->raw_expr = NULL;
1599                                         n->cooked_expr = NULL;
1600                                         n->keys = NULL;
1601                                         $$ = (Node *)n;
1602                                 }
1603                         | PRIMARY KEY
1604                                 {
1605                                         Constraint *n = makeNode(Constraint);
1606                                         n->contype = CONSTR_PRIMARY;
1607                                         n->name = NULL;
1608                                         n->raw_expr = NULL;
1609                                         n->cooked_expr = NULL;
1610                                         n->keys = NULL;
1611                                         $$ = (Node *)n;
1612                                 }
1613                         | CHECK '(' a_expr ')'
1614                                 {
1615                                         Constraint *n = makeNode(Constraint);
1616                                         n->contype = CONSTR_CHECK;
1617                                         n->name = NULL;
1618                                         n->raw_expr = $3;
1619                                         n->cooked_expr = NULL;
1620                                         n->keys = NULL;
1621                                         $$ = (Node *)n;
1622                                 }
1623                         | DEFAULT b_expr
1624                                 {
1625                                         Constraint *n = makeNode(Constraint);
1626                                         n->contype = CONSTR_DEFAULT;
1627                                         n->name = NULL;
1628                                         if (exprIsNullConstant($2))
1629                                         {
1630                                                 /* DEFAULT NULL should be reported as empty expr */
1631                                                 n->raw_expr = NULL;
1632                                         }
1633                                         else
1634                                         {
1635                                                 n->raw_expr = $2;
1636                                         }
1637                                         n->cooked_expr = NULL;
1638                                         n->keys = NULL;
1639                                         $$ = (Node *)n;
1640                                 }
1641                         | REFERENCES qualified_name opt_column_list key_match key_actions
1642                                 {
1643                                         FkConstraint *n = makeNode(FkConstraint);
1644                                         n->constr_name          = NULL;
1645                                         n->pktable                      = $2;
1646                                         n->fk_attrs                     = NIL;
1647                                         n->pk_attrs                     = $3;
1648                                         n->fk_matchtype         = $4;
1649                                         n->fk_upd_action        = (char) ($5 >> 8);
1650                                         n->fk_del_action        = (char) ($5 & 0xFF);
1651                                         n->deferrable           = FALSE;
1652                                         n->initdeferred         = FALSE;
1653                                         $$ = (Node *)n;
1654                                 }
1655                 ;
1656
1657 /*
1658  * ConstraintAttr represents constraint attributes, which we parse as if
1659  * they were independent constraint clauses, in order to avoid shift/reduce
1660  * conflicts (since NOT might start either an independent NOT NULL clause
1661  * or an attribute).  analyze.c is responsible for attaching the attribute
1662  * information to the preceding "real" constraint node, and for complaining
1663  * if attribute clauses appear in the wrong place or wrong combinations.
1664  *
1665  * See also ConstraintAttributeSpec, which can be used in places where
1666  * there is no parsing conflict.
1667  */
1668 ConstraintAttr:
1669                         DEFERRABLE
1670                                 {
1671                                         Constraint *n = makeNode(Constraint);
1672                                         n->contype = CONSTR_ATTR_DEFERRABLE;
1673                                         $$ = (Node *)n;
1674                                 }
1675                         | NOT DEFERRABLE
1676                                 {
1677                                         Constraint *n = makeNode(Constraint);
1678                                         n->contype = CONSTR_ATTR_NOT_DEFERRABLE;
1679                                         $$ = (Node *)n;
1680                                 }
1681                         | INITIALLY DEFERRED
1682                                 {
1683                                         Constraint *n = makeNode(Constraint);
1684                                         n->contype = CONSTR_ATTR_DEFERRED;
1685                                         $$ = (Node *)n;
1686                                 }
1687                         | INITIALLY IMMEDIATE
1688                                 {
1689                                         Constraint *n = makeNode(Constraint);
1690                                         n->contype = CONSTR_ATTR_IMMEDIATE;
1691                                         $$ = (Node *)n;
1692                                 }
1693                 ;
1694
1695
1696 /*
1697  * SQL99 supports wholesale borrowing of a table definition via the LIKE clause.
1698  * This seems to be a poor man's inheritance capability, with the resulting
1699  * tables completely decoupled except for the original commonality in definitions.
1700  *
1701  * This is very similar to CREATE TABLE AS except for the INCLUDING DEFAULTS extension
1702  * which is a part of SQL 200N
1703  */
1704 TableLikeClause:
1705                         LIKE qualified_name like_including_defaults
1706                                 {
1707                                         InhRelation *n = makeNode(InhRelation);
1708                                         n->relation = $2;
1709                                         n->including_defaults = $3;
1710
1711                                         $$ = (Node *)n;
1712                                 }
1713                 ;
1714
1715 like_including_defaults:
1716                                 INCLUDING DEFAULTS              { $$ = true; }
1717                                 | EXCLUDING DEFAULTS            { $$ = false; }
1718                                 | /* EMPTY */                           { $$ = false; }
1719                 ;
1720
1721
1722 /* ConstraintElem specifies constraint syntax which is not embedded into
1723  *      a column definition. ColConstraintElem specifies the embedded form.
1724  * - thomas 1997-12-03
1725  */
1726 TableConstraint:
1727                         CONSTRAINT name ConstraintElem
1728                                 {
1729                                         switch (nodeTag($3))
1730                                         {
1731                                                 case T_Constraint:
1732                                                         {
1733                                                                 Constraint *n = (Constraint *)$3;
1734                                                                 n->name = $2;
1735                                                         }
1736                                                         break;
1737                                                 case T_FkConstraint:
1738                                                         {
1739                                                                 FkConstraint *n = (FkConstraint *)$3;
1740                                                                 n->constr_name = $2;
1741                                                         }
1742                                                         break;
1743                                                 default:
1744                                                         break;
1745                                         }
1746                                         $$ = $3;
1747                                 }
1748                         | ConstraintElem                                                { $$ = $1; }
1749                 ;
1750
1751 ConstraintElem:
1752                         CHECK '(' a_expr ')'
1753                                 {
1754                                         Constraint *n = makeNode(Constraint);
1755                                         n->contype = CONSTR_CHECK;
1756                                         n->name = NULL;
1757                                         n->raw_expr = $3;
1758                                         n->cooked_expr = NULL;
1759                                         $$ = (Node *)n;
1760                                 }
1761                         | UNIQUE '(' columnList ')'
1762                                 {
1763                                         Constraint *n = makeNode(Constraint);
1764                                         n->contype = CONSTR_UNIQUE;
1765                                         n->name = NULL;
1766                                         n->raw_expr = NULL;
1767                                         n->cooked_expr = NULL;
1768                                         n->keys = $3;
1769                                         $$ = (Node *)n;
1770                                 }
1771                         | PRIMARY KEY '(' columnList ')'
1772                                 {
1773                                         Constraint *n = makeNode(Constraint);
1774                                         n->contype = CONSTR_PRIMARY;
1775                                         n->name = NULL;
1776                                         n->raw_expr = NULL;
1777                                         n->cooked_expr = NULL;
1778                                         n->keys = $4;
1779                                         $$ = (Node *)n;
1780                                 }
1781                         | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name
1782                                 opt_column_list key_match key_actions ConstraintAttributeSpec
1783                                 {
1784                                         FkConstraint *n = makeNode(FkConstraint);
1785                                         n->constr_name          = NULL;
1786                                         n->pktable                      = $7;
1787                                         n->fk_attrs                     = $4;
1788                                         n->pk_attrs                     = $8;
1789                                         n->fk_matchtype         = $9;
1790                                         n->fk_upd_action        = (char) ($10 >> 8);
1791                                         n->fk_del_action        = (char) ($10 & 0xFF);
1792                                         n->deferrable           = ($11 & 1) != 0;
1793                                         n->initdeferred         = ($11 & 2) != 0;
1794                                         $$ = (Node *)n;
1795                                 }
1796                 ;
1797
1798 opt_column_list:
1799                         '(' columnList ')'                                              { $$ = $2; }
1800                         | /*EMPTY*/                                                             { $$ = NIL; }
1801                 ;
1802
1803 columnList:
1804                         columnElem                                                              { $$ = makeList1($1); }
1805                         | columnList ',' columnElem                             { $$ = lappend($1, $3); }
1806                 ;
1807
1808 columnElem: ColId
1809                                 {
1810                                         $$ = (Node *) makeString($1);
1811                                 }
1812                 ;
1813
1814 key_match:  MATCH FULL
1815                         {
1816                                 $$ = FKCONSTR_MATCH_FULL;
1817                         }
1818                 | MATCH PARTIAL
1819                         {
1820                                 ereport(ERROR,
1821                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1822                                                  errmsg("MATCH PARTIAL not yet implemented")));
1823                                 $$ = FKCONSTR_MATCH_PARTIAL;
1824                         }
1825                 | MATCH SIMPLE
1826                         {
1827                                 $$ = FKCONSTR_MATCH_UNSPECIFIED;
1828                         }
1829                 | /*EMPTY*/
1830                         {
1831                                 $$ = FKCONSTR_MATCH_UNSPECIFIED;
1832                         }
1833                 ;
1834
1835 /*
1836  * We combine the update and delete actions into one value temporarily
1837  * for simplicity of parsing, and then break them down again in the
1838  * calling production.  update is in the left 8 bits, delete in the right.
1839  * Note that NOACTION is the default.
1840  */
1841 key_actions:
1842                         key_update
1843                                 { $$ = ($1 << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); }
1844                         | key_delete
1845                                 { $$ = (FKCONSTR_ACTION_NOACTION << 8) | ($1 & 0xFF); }
1846                         | key_update key_delete
1847                                 { $$ = ($1 << 8) | ($2 & 0xFF); }
1848                         | key_delete key_update
1849                                 { $$ = ($2 << 8) | ($1 & 0xFF); }
1850                         | /*EMPTY*/
1851                                 { $$ = (FKCONSTR_ACTION_NOACTION << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); }
1852                 ;
1853
1854 key_update: ON UPDATE key_action                { $$ = $3; }
1855                 ;
1856
1857 key_delete: ON DELETE_P key_action              { $$ = $3; }
1858                 ;
1859
1860 key_action:
1861                         NO ACTION                                       { $$ = FKCONSTR_ACTION_NOACTION; }
1862                         | RESTRICT                                      { $$ = FKCONSTR_ACTION_RESTRICT; }
1863                         | CASCADE                                       { $$ = FKCONSTR_ACTION_CASCADE; }
1864                         | SET NULL_P                            { $$ = FKCONSTR_ACTION_SETNULL; }
1865                         | SET DEFAULT                           { $$ = FKCONSTR_ACTION_SETDEFAULT; }
1866                 ;
1867
1868 OptInherit: INHERITS '(' qualified_name_list ')'        { $$ = $3; }
1869                         | /*EMPTY*/                                                             { $$ = NIL; }
1870                 ;
1871
1872 OptWithOids:
1873                         WITH OIDS                                                               { $$ = MUST_HAVE_OIDS; }
1874                         | WITHOUT OIDS                                                  { $$ = MUST_NOT_HAVE_OIDS; }
1875                         | /*EMPTY*/                                                             { $$ = DEFAULT_OIDS; }
1876                 ;
1877
1878 OnCommitOption:  ON COMMIT DROP                         { $$ = ONCOMMIT_DROP; }
1879                         | ON COMMIT DELETE_P ROWS               { $$ = ONCOMMIT_DELETE_ROWS; }
1880                         | ON COMMIT PRESERVE ROWS               { $$ = ONCOMMIT_PRESERVE_ROWS; }
1881                         | /*EMPTY*/                                             { $$ = ONCOMMIT_NOOP; }
1882                 ;
1883
1884
1885 /*
1886  * Note: CREATE TABLE ... AS SELECT ... is just another spelling for
1887  * SELECT ... INTO.
1888  */
1889
1890 CreateAsStmt:
1891                         CREATE OptTemp TABLE qualified_name OptCreateAs WithOidsAs SelectStmt
1892                                 {
1893                                         /*
1894                                          * When the SelectStmt is a set-operation tree, we must
1895                                          * stuff the INTO information into the leftmost component
1896                                          * Select, because that's where analyze.c will expect
1897                                          * to find it.  Similarly, the output column names must
1898                                          * be attached to that Select's target list.
1899                                          */
1900                                         SelectStmt *n = findLeftmostSelect((SelectStmt *) $7);
1901                                         if (n->into != NULL)
1902                                                 ereport(ERROR,
1903                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
1904                                                                  errmsg("CREATE TABLE AS may not specify INTO")));
1905                                         $4->istemp = $2;
1906                                         n->into = $4;
1907                                         n->intoColNames = $5;
1908                                         n->intoHasOids = $6;
1909                                         $$ = $7;
1910                                 }
1911                 ;
1912
1913 /*
1914  * To avoid a shift/reduce conflict in CreateAsStmt, we need to
1915  * include the 'AS' terminal in the parsing of WITH/WITHOUT
1916  * OIDS. Unfortunately that means this production is effectively a
1917  * duplicate of OptWithOids.
1918  */
1919 WithOidsAs:
1920                         WITH OIDS AS                                                    { $$ = MUST_HAVE_OIDS; }
1921                         | WITHOUT OIDS AS                                               { $$ = MUST_NOT_HAVE_OIDS; }
1922                         | AS                                                                    { $$ = DEFAULT_OIDS; }
1923                         ;
1924
1925 OptCreateAs:
1926                         '(' CreateAsList ')'                                    { $$ = $2; }
1927                         | /*EMPTY*/                                                             { $$ = NIL; }
1928                 ;
1929
1930 CreateAsList:
1931                         CreateAsElement                                                 { $$ = makeList1($1); }
1932                         | CreateAsList ',' CreateAsElement              { $$ = lappend($1, $3); }
1933                 ;
1934
1935 CreateAsElement:
1936                         ColId
1937                                 {
1938                                         ColumnDef *n = makeNode(ColumnDef);
1939                                         n->colname = $1;
1940                                         n->typename = NULL;
1941                                         n->inhcount = 0;
1942                                         n->is_local = true;
1943                                         n->is_not_null = false;
1944                                         n->raw_default = NULL;
1945                                         n->cooked_default = NULL;
1946                                         n->constraints = NIL;
1947                                         n->support = NULL;
1948                                         $$ = (Node *)n;
1949                                 }
1950                 ;
1951
1952
1953 /*****************************************************************************
1954  *
1955  *              QUERY :
1956  *                              CREATE SEQUENCE seqname
1957  *                              ALTER SEQUENCE seqname
1958  *
1959  *****************************************************************************/
1960
1961 CreateSeqStmt:
1962                         CREATE OptTemp SEQUENCE qualified_name OptSeqList
1963                                 {
1964                                         CreateSeqStmt *n = makeNode(CreateSeqStmt);
1965                                         $4->istemp = $2;
1966                                         n->sequence = $4;
1967                                         n->options = $5;
1968                                         $$ = (Node *)n;
1969                                 }
1970                 ;
1971
1972 AlterSeqStmt:
1973                         ALTER SEQUENCE qualified_name OptSeqList
1974                                 {
1975                                         AlterSeqStmt *n = makeNode(AlterSeqStmt);
1976                                         n->sequence = $3;
1977                                         n->options = $4;
1978                                         $$ = (Node *)n;
1979                                 }
1980                 ;
1981
1982 OptSeqList: OptSeqList OptSeqElem                                       { $$ = lappend($1, $2); }
1983                         | /*EMPTY*/                                                             { $$ = NIL; }
1984                 ;
1985
1986 OptSeqElem: CACHE NumericOnly
1987                                 {
1988                                         $$ = makeDefElem("cache", (Node *)$2);
1989                                 }
1990                         | CYCLE
1991                                 {
1992                                         $$ = makeDefElem("cycle", (Node *)makeInteger(TRUE));
1993                                 }
1994                         | NO CYCLE
1995                                 {
1996                                         $$ = makeDefElem("cycle", (Node *)makeInteger(FALSE));
1997                                 }
1998                         | INCREMENT opt_by NumericOnly
1999                                 {
2000                                         $$ = makeDefElem("increment", (Node *)$3);
2001                                 }
2002                         | MAXVALUE NumericOnly
2003                                 {
2004                                         $$ = makeDefElem("maxvalue", (Node *)$2);
2005                                 }
2006                         | MINVALUE NumericOnly
2007                                 {
2008                                         $$ = makeDefElem("minvalue", (Node *)$2);
2009                                 }
2010                         | NO MAXVALUE
2011                                 {
2012                                         $$ = makeDefElem("maxvalue", NULL);
2013                                 }
2014                         | NO MINVALUE
2015                                 {
2016                                         $$ = makeDefElem("minvalue", NULL);
2017                                 }
2018                         | START opt_with NumericOnly
2019                                 {
2020                                         $$ = makeDefElem("start", (Node *)$3);
2021                                 }
2022                         | RESTART opt_with NumericOnly
2023                                 {
2024                                         $$ = makeDefElem("restart", (Node *)$3);
2025                                 }
2026                 ;
2027
2028 opt_by:         BY                              {}
2029                         | /* empty */   {}
2030           ;
2031
2032 NumericOnly:
2033                         FloatOnly                                                               { $$ = $1; }
2034                         | IntegerOnly                                                   { $$ = $1; }
2035                 ;
2036
2037 FloatOnly:      FCONST                                                                  { $$ = makeFloat($1); }
2038                         | '-' FCONST
2039                                 {
2040                                         $$ = makeFloat($2);
2041                                         doNegateFloat($$);
2042                                 }
2043                 ;
2044
2045 IntegerOnly:
2046                         Iconst
2047                                 {
2048                                         $$ = makeInteger($1);
2049                                 }
2050                         | '-' Iconst
2051                                 {
2052                                         $$ = makeInteger($2);
2053                                         $$->val.ival = - $$->val.ival;
2054                                 }
2055                 ;
2056
2057 /*****************************************************************************
2058  *
2059  *              QUERIES :
2060  *                              CREATE PROCEDURAL LANGUAGE ...
2061  *                              DROP PROCEDURAL LANGUAGE ...
2062  *
2063  *****************************************************************************/
2064
2065 CreatePLangStmt:
2066                         CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
2067                         HANDLER handler_name opt_validator opt_lancompiler
2068                         {
2069                                 CreatePLangStmt *n = makeNode(CreatePLangStmt);
2070                                 n->plname = $5;
2071                                 n->plhandler = $7;
2072                                 n->plvalidator = $8;
2073                                 n->pltrusted = $2;
2074                                 $$ = (Node *)n;
2075                         }
2076                 ;
2077
2078 opt_trusted:
2079                         TRUSTED                                                                 { $$ = TRUE; }
2080                         | /*EMPTY*/                                                             { $$ = FALSE; }
2081                 ;
2082
2083 /* This ought to be just func_name, but that causes reduce/reduce conflicts
2084  * (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
2085  * Work around by using name and dotted_name separately.
2086  */
2087 handler_name:
2088                         name
2089                                                         { $$ = makeList1(makeString($1)); }
2090                         | dotted_name                                                   { $$ = $1; }
2091                 ;
2092
2093 opt_lancompiler:
2094                         LANCOMPILER Sconst                                              { $$ = $2; }
2095                         | /*EMPTY*/                                                             { $$ = ""; }
2096                 ;
2097
2098 opt_validator:
2099                         VALIDATOR handler_name { $$ = $2; }
2100                         | /*EMPTY*/ { $$ = NULL; }
2101                 ;
2102
2103 DropPLangStmt:
2104                         DROP opt_procedural LANGUAGE ColId_or_Sconst opt_drop_behavior
2105                                 {
2106                                         DropPLangStmt *n = makeNode(DropPLangStmt);
2107                                         n->plname = $4;
2108                                         n->behavior = $5;
2109                                         $$ = (Node *)n;
2110                                 }
2111                 ;
2112
2113 opt_procedural:
2114                         PROCEDURAL                                                              {}
2115                         | /*EMPTY*/                                                             {}
2116                 ;
2117
2118 /*****************************************************************************
2119  *
2120  *              QUERIES :
2121  *                              CREATE TRIGGER ...
2122  *                              DROP TRIGGER ...
2123  *
2124  *****************************************************************************/
2125
2126 CreateTrigStmt:
2127                         CREATE TRIGGER name TriggerActionTime TriggerEvents ON
2128                         qualified_name TriggerForSpec EXECUTE PROCEDURE
2129                         func_name '(' TriggerFuncArgs ')'
2130                                 {
2131                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
2132                                         n->trigname = $3;
2133                                         n->relation = $7;
2134                                         n->funcname = $11;
2135                                         n->args = $13;
2136                                         n->before = $4;
2137                                         n->row = $8;
2138                                         memcpy(n->actions, $5, 4);
2139                                         n->isconstraint  = FALSE;
2140                                         n->deferrable    = FALSE;
2141                                         n->initdeferred  = FALSE;
2142                                         n->constrrel = NULL;
2143                                         $$ = (Node *)n;
2144                                 }
2145                         | CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
2146                         qualified_name OptConstrFromTable
2147                         ConstraintAttributeSpec
2148                         FOR EACH ROW EXECUTE PROCEDURE
2149                         func_name '(' TriggerFuncArgs ')'
2150                                 {
2151                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
2152                                         n->trigname = $4;
2153                                         n->relation = $8;
2154                                         n->funcname = $16;
2155                                         n->args = $18;
2156                                         n->before = FALSE;
2157                                         n->row = TRUE;
2158                                         memcpy(n->actions, $6, 4);
2159                                         n->isconstraint  = TRUE;
2160                                         n->deferrable = ($10 & 1) != 0;
2161                                         n->initdeferred = ($10 & 2) != 0;
2162
2163                                         n->constrrel = $9;
2164                                         $$ = (Node *)n;
2165                                 }
2166                 ;
2167
2168 TriggerActionTime:
2169                         BEFORE                                                                  { $$ = TRUE; }
2170                         | AFTER                                                                 { $$ = FALSE; }
2171                 ;
2172
2173 TriggerEvents:
2174                         TriggerOneEvent
2175                                 {
2176                                         char *e = palloc(4);
2177                                         e[0] = $1; e[1] = '\0';
2178                                         $$ = e;
2179                                 }
2180                         | TriggerOneEvent OR TriggerOneEvent
2181                                 {
2182                                         char *e = palloc(4);
2183                                         e[0] = $1; e[1] = $3; e[2] = '\0';
2184                                         $$ = e;
2185                                 }
2186                         | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
2187                                 {
2188                                         char *e = palloc(4);
2189                                         e[0] = $1; e[1] = $3; e[2] = $5; e[3] = '\0';
2190                                         $$ = e;
2191                                 }
2192                 ;
2193
2194 TriggerOneEvent:
2195                         INSERT                                                                  { $$ = 'i'; }
2196                         | DELETE_P                                                              { $$ = 'd'; }
2197                         | UPDATE                                                                { $$ = 'u'; }
2198                 ;
2199
2200 TriggerForSpec:
2201                         FOR TriggerForOpt TriggerForType
2202                                 {
2203                                         $$ = $3;
2204                                 }
2205                         | /* EMPTY */
2206                                 {
2207                                         /*
2208                                          * If ROW/STATEMENT not specified, default to
2209                                          * STATEMENT, per SQL
2210                                          */
2211                                         $$ = FALSE;
2212                                 }
2213                 ;
2214
2215 TriggerForOpt:
2216                         EACH                                                                    {}
2217                         | /*EMPTY*/                                                             {}
2218                 ;
2219
2220 TriggerForType:
2221                         ROW                                                                             { $$ = TRUE; }
2222                         | STATEMENT                                                             { $$ = FALSE; }
2223                 ;
2224
2225 TriggerFuncArgs:
2226                         TriggerFuncArg                                                  { $$ = makeList1($1); }
2227                         | TriggerFuncArgs ',' TriggerFuncArg    { $$ = lappend($1, $3); }
2228                         | /*EMPTY*/                                                             { $$ = NIL; }
2229                 ;
2230
2231 TriggerFuncArg:
2232                         ICONST
2233                                 {
2234                                         char buf[64];
2235                                         snprintf(buf, sizeof(buf), "%d", $1);
2236                                         $$ = makeString(pstrdup(buf));
2237                                 }
2238                         | FCONST                                                                { $$ = makeString($1); }
2239                         | Sconst                                                                { $$ = makeString($1); }
2240                         | BCONST                                                                { $$ = makeString($1); }
2241                         | XCONST                                                                { $$ = makeString($1); }
2242                         | ColId                                                                 { $$ = makeString($1); }
2243                 ;
2244
2245 OptConstrFromTable:
2246                         FROM qualified_name                                             { $$ = $2; }
2247                         | /*EMPTY*/                                                             { $$ = NULL; }
2248                 ;
2249
2250 ConstraintAttributeSpec:
2251                         ConstraintDeferrabilitySpec
2252                                 { $$ = $1; }
2253                         | ConstraintDeferrabilitySpec ConstraintTimeSpec
2254                                 {
2255                                         if ($1 == 0 && $2 != 0)
2256                                                 ereport(ERROR,
2257                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
2258                                                                  errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE")));
2259                                         $$ = $1 | $2;
2260                                 }
2261                         | ConstraintTimeSpec
2262                                 {
2263                                         if ($1 != 0)
2264                                                 $$ = 3;
2265                                         else
2266                                                 $$ = 0;
2267                                 }
2268                         | ConstraintTimeSpec ConstraintDeferrabilitySpec
2269                                 {
2270                                         if ($2 == 0 && $1 != 0)
2271                                                 ereport(ERROR,
2272                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
2273                                                                  errmsg("constraint declared INITIALLY DEFERRED must be DEFERRABLE")));
2274                                         $$ = $1 | $2;
2275                                 }
2276                         | /*EMPTY*/
2277                                 { $$ = 0; }
2278                 ;
2279
2280 ConstraintDeferrabilitySpec:
2281                         NOT DEFERRABLE                                                  { $$ = 0; }
2282                         | DEFERRABLE                                                    { $$ = 1; }
2283                 ;
2284
2285 ConstraintTimeSpec:
2286                         INITIALLY IMMEDIATE                                             { $$ = 0; }
2287                         | INITIALLY DEFERRED                                    { $$ = 2; }
2288                 ;
2289
2290
2291 DropTrigStmt:
2292                         DROP TRIGGER name ON qualified_name opt_drop_behavior
2293                                 {
2294                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
2295                                         n->relation = $5;
2296                                         n->property = $3;
2297                                         n->behavior = $6;
2298                                         n->removeType = OBJECT_TRIGGER;
2299                                         $$ = (Node *) n;
2300                                 }
2301                 ;
2302
2303
2304 /*****************************************************************************
2305  *
2306  *              QUERIES :
2307  *                              CREATE ASSERTION ...
2308  *                              DROP ASSERTION ...
2309  *
2310  *****************************************************************************/
2311
2312 CreateAssertStmt:
2313                         CREATE ASSERTION name CHECK '(' a_expr ')'
2314                         ConstraintAttributeSpec
2315                                 {
2316                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
2317                                         n->trigname = $3;
2318                                         n->args = makeList1($6);
2319                                         n->isconstraint  = TRUE;
2320                                         n->deferrable = ($8 & 1) != 0;
2321                                         n->initdeferred = ($8 & 2) != 0;
2322
2323                                         ereport(ERROR,
2324                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2325                                                          errmsg("CREATE ASSERTION is not yet implemented")));
2326
2327                                         $$ = (Node *)n;
2328                                 }
2329                 ;
2330
2331 DropAssertStmt:
2332                         DROP ASSERTION name opt_drop_behavior
2333                                 {
2334                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
2335                                         n->relation = NULL;
2336                                         n->property = $3;
2337                                         n->behavior = $4;
2338                                         n->removeType = OBJECT_TRIGGER; /* XXX */
2339                                         ereport(ERROR,
2340                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2341                                                          errmsg("DROP ASSERTION is not yet implemented")));
2342                                         $$ = (Node *) n;
2343                                 }
2344                 ;
2345
2346
2347 /*****************************************************************************
2348  *
2349  *              QUERY :
2350  *                              define (aggregate,operator,type)
2351  *
2352  *****************************************************************************/
2353
2354 DefineStmt:
2355                         CREATE AGGREGATE func_name definition
2356                                 {
2357                                         DefineStmt *n = makeNode(DefineStmt);
2358                                         n->kind = OBJECT_AGGREGATE;
2359                                         n->defnames = $3;
2360                                         n->definition = $4;
2361                                         $$ = (Node *)n;
2362                                 }
2363                         | CREATE OPERATOR any_operator definition
2364                                 {
2365                                         DefineStmt *n = makeNode(DefineStmt);
2366                                         n->kind = OBJECT_OPERATOR;
2367                                         n->defnames = $3;
2368                                         n->definition = $4;
2369                                         $$ = (Node *)n;
2370                                 }
2371                         | CREATE TYPE_P any_name definition
2372                                 {
2373                                         DefineStmt *n = makeNode(DefineStmt);
2374                                         n->kind = OBJECT_TYPE;
2375                                         n->defnames = $3;
2376                                         n->definition = $4;
2377                                         $$ = (Node *)n;
2378                                 }
2379                         | CREATE TYPE_P any_name AS '(' TableFuncElementList ')'
2380                                 {
2381                                         CompositeTypeStmt *n = makeNode(CompositeTypeStmt);
2382                                         RangeVar *r = makeNode(RangeVar);
2383
2384                                         /* can't use qualified_name, sigh */
2385                                         switch (length($3))
2386                                         {
2387                                                 case 1:
2388                                                         r->catalogname = NULL;
2389                                                         r->schemaname = NULL;
2390                                                         r->relname = strVal(linitial($3));
2391                                                         break;
2392                                                 case 2:
2393                                                         r->catalogname = NULL;
2394                                                         r->schemaname = strVal(linitial($3));
2395                                                         r->relname = strVal(lsecond($3));
2396                                                         break;
2397                                                 case 3:
2398                                                         r->catalogname = strVal(linitial($3));
2399                                                         r->schemaname = strVal(lsecond($3));
2400                                                         r->relname = strVal(lthird($3));
2401                                                         break;
2402                                                 default:
2403                                                         ereport(ERROR,
2404                                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2405                                                                          errmsg("improper qualified name (too many dotted names): %s",
2406                                                                                         NameListToString($3))));
2407                                                         break;
2408                                         }
2409                                         n->typevar = r;
2410                                         n->coldeflist = $6;
2411                                         $$ = (Node *)n;
2412                                 }
2413                 ;
2414
2415 definition: '(' def_list ')'                                            { $$ = $2; }
2416                 ;
2417
2418 def_list:       def_elem                                                                { $$ = makeList1($1); }
2419                         | def_list ',' def_elem                                 { $$ = lappend($1, $3); }
2420                 ;
2421
2422 def_elem:  ColLabel '=' def_arg
2423                                 {
2424                                         $$ = makeDefElem($1, (Node *)$3);
2425                                 }
2426                         | ColLabel
2427                                 {
2428                                         $$ = makeDefElem($1, NULL);
2429                                 }
2430                 ;
2431
2432 /* Note: any simple identifier will be returned as a type name! */
2433 def_arg:        func_return                                             { $$ = (Node *)$1; }
2434                         | qual_all_Op                                   { $$ = (Node *)$1; }
2435                         | NumericOnly                                   { $$ = (Node *)$1; }
2436                         | Sconst                                                { $$ = (Node *)makeString($1); }
2437                 ;
2438
2439
2440 /*****************************************************************************
2441  *
2442  *              QUERIES :
2443  *                              CREATE OPERATOR CLASS ...
2444  *                              DROP OPERATOR CLASS ...
2445  *
2446  *****************************************************************************/
2447
2448 CreateOpClassStmt:
2449                         CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename
2450                         USING access_method AS opclass_item_list
2451                                 {
2452                                         CreateOpClassStmt *n = makeNode(CreateOpClassStmt);
2453                                         n->opclassname = $4;
2454                                         n->isDefault = $5;
2455                                         n->datatype = $8;
2456                                         n->amname = $10;
2457                                         n->items = $12;
2458                                         $$ = (Node *) n;
2459                                 }
2460                 ;
2461
2462 opclass_item_list:
2463                         opclass_item                                                    { $$ = makeList1($1); }
2464                         | opclass_item_list ',' opclass_item    { $$ = lappend($1, $3); }
2465                 ;
2466
2467 opclass_item:
2468                         OPERATOR Iconst any_operator opt_recheck
2469                                 {
2470                                         CreateOpClassItem *n = makeNode(CreateOpClassItem);
2471                                         n->itemtype = OPCLASS_ITEM_OPERATOR;
2472                                         n->name = $3;
2473                                         n->args = NIL;
2474                                         n->number = $2;
2475                                         n->recheck = $4;
2476                                         $$ = (Node *) n;
2477                                 }
2478                         | OPERATOR Iconst any_operator '(' oper_argtypes ')' opt_recheck
2479                                 {
2480                                         CreateOpClassItem *n = makeNode(CreateOpClassItem);
2481                                         n->itemtype = OPCLASS_ITEM_OPERATOR;
2482                                         n->name = $3;
2483                                         n->args = $5;
2484                                         n->number = $2;
2485                                         n->recheck = $7;
2486                                         $$ = (Node *) n;
2487                                 }
2488                         | FUNCTION Iconst func_name func_args
2489                                 {
2490                                         CreateOpClassItem *n = makeNode(CreateOpClassItem);
2491                                         n->itemtype = OPCLASS_ITEM_FUNCTION;
2492                                         n->name = $3;
2493                                         n->args = extractArgTypes($4);
2494                                         n->number = $2;
2495                                         $$ = (Node *) n;
2496                                 }
2497                         | STORAGE Typename
2498                                 {
2499                                         CreateOpClassItem *n = makeNode(CreateOpClassItem);
2500                                         n->itemtype = OPCLASS_ITEM_STORAGETYPE;
2501                                         n->storedtype = $2;
2502                                         $$ = (Node *) n;
2503                                 }
2504                 ;
2505
2506 opt_default:    DEFAULT { $$ = TRUE; }
2507                         | /*EMPTY*/     { $$ = FALSE; }
2508                 ;
2509
2510 opt_recheck:    RECHECK { $$ = TRUE; }
2511                         | /*EMPTY*/     { $$ = FALSE; }
2512                 ;
2513
2514
2515 DropOpClassStmt:
2516                         DROP OPERATOR CLASS any_name USING access_method opt_drop_behavior
2517                                 {
2518                                         RemoveOpClassStmt *n = makeNode(RemoveOpClassStmt);
2519                                         n->opclassname = $4;
2520                                         n->amname = $6;
2521                                         n->behavior = $7;
2522                                         $$ = (Node *) n;
2523                                 }
2524                 ;
2525
2526
2527 /*****************************************************************************
2528  *
2529  *              QUERY:
2530  *
2531  *              DROP itemtype itemname [, itemname ...] [ RESTRICT | CASCADE ]
2532  *
2533  *****************************************************************************/
2534
2535 DropStmt:       DROP drop_type any_name_list opt_drop_behavior
2536                                 {
2537                                         DropStmt *n = makeNode(DropStmt);
2538                                         n->removeType = $2;
2539                                         n->objects = $3;
2540                                         n->behavior = $4;
2541                                         $$ = (Node *)n;
2542                                 }
2543                 ;
2544
2545 drop_type:      TABLE                                                                   { $$ = OBJECT_TABLE; }
2546                         | SEQUENCE                                                              { $$ = OBJECT_SEQUENCE; }
2547                         | VIEW                                                                  { $$ = OBJECT_VIEW; }
2548                         | INDEX                                                                 { $$ = OBJECT_INDEX; }
2549                         | TYPE_P                                                                { $$ = OBJECT_TYPE; }
2550                         | DOMAIN_P                                                              { $$ = OBJECT_DOMAIN; }
2551                         | CONVERSION_P                                                  { $$ = OBJECT_CONVERSION; }
2552                         | SCHEMA                                                                { $$ = OBJECT_SCHEMA; }
2553                 ;
2554
2555 any_name_list:
2556                         any_name                                                                { $$ = makeList1($1); }
2557                         | any_name_list ',' any_name                    { $$ = lappend($1, $3); }
2558                 ;
2559
2560 any_name:       ColId                                           { $$ = makeList1(makeString($1)); }
2561                         | dotted_name                           { $$ = $1; }
2562                 ;
2563
2564 /*****************************************************************************
2565  *
2566  *              QUERY:
2567  *                              truncate table relname
2568  *
2569  *****************************************************************************/
2570
2571 TruncateStmt:
2572                         TRUNCATE opt_table qualified_name
2573                                 {
2574                                         TruncateStmt *n = makeNode(TruncateStmt);
2575                                         n->relation = $3;
2576                                         $$ = (Node *)n;
2577                                 }
2578                 ;
2579
2580 /*****************************************************************************
2581  *
2582  *      The COMMENT ON statement can take different forms based upon the type of
2583  *      the object associated with the comment. The form of the statement is:
2584  *
2585  *      COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW |
2586  *                                 CONVERSION | LANGUAGE | OPERATOR CLASS | LARGE OBJECT |
2587  *                                 CAST ] <objname> |
2588  *                               AGGREGATE <aggname> (<aggtype>) |
2589  *                               FUNCTION <funcname> (arg1, arg2, ...) |
2590  *                               OPERATOR <op> (leftoperand_typ, rightoperand_typ) |
2591  *                               TRIGGER <triggername> ON <relname> |
2592  *                               RULE <rulename> ON <relname> ]
2593  *                         IS 'text'
2594  *
2595  *****************************************************************************/
2596
2597 CommentStmt:
2598                         COMMENT ON comment_type any_name IS comment_text
2599                                 {
2600                                         CommentStmt *n = makeNode(CommentStmt);
2601                                         n->objtype = $3;
2602                                         n->objname = $4;
2603                                         n->objargs = NIL;
2604                                         n->comment = $6;
2605                                         $$ = (Node *) n;
2606                                 }
2607                         | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')'
2608                         IS comment_text
2609                                 {
2610                                         CommentStmt *n = makeNode(CommentStmt);
2611                                         n->objtype = OBJECT_AGGREGATE;
2612                                         n->objname = $4;
2613                                         n->objargs = makeList1($6);
2614                                         n->comment = $9;
2615                                         $$ = (Node *) n;
2616                                 }
2617                         | COMMENT ON FUNCTION func_name func_args IS comment_text
2618                                 {
2619                                         CommentStmt *n = makeNode(CommentStmt);
2620                                         n->objtype = OBJECT_FUNCTION;
2621                                         n->objname = $4;
2622                                         n->objargs = extractArgTypes($5);
2623                                         n->comment = $7;
2624                                         $$ = (Node *) n;
2625                                 }
2626                         | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')'
2627                         IS comment_text
2628                                 {
2629                                         CommentStmt *n = makeNode(CommentStmt);
2630                                         n->objtype = OBJECT_OPERATOR;
2631                                         n->objname = $4;
2632                                         n->objargs = $6;
2633                                         n->comment = $9;
2634                                         $$ = (Node *) n;
2635                                 }
2636                         | COMMENT ON CONSTRAINT name ON any_name IS comment_text
2637                                 {
2638                                         CommentStmt *n = makeNode(CommentStmt);
2639                                         n->objtype = OBJECT_CONSTRAINT;
2640                                         n->objname = lappend($6, makeString($4));
2641                                         n->objargs = NIL;
2642                                         n->comment = $8;
2643                                         $$ = (Node *) n;
2644                                 }
2645                         | COMMENT ON RULE name ON any_name IS comment_text
2646                                 {
2647                                         CommentStmt *n = makeNode(CommentStmt);
2648                                         n->objtype = OBJECT_RULE;
2649                                         n->objname = lappend($6, makeString($4));
2650                                         n->objargs = NIL;
2651                                         n->comment = $8;
2652                                         $$ = (Node *) n;
2653                                 }
2654                         | COMMENT ON RULE name IS comment_text
2655                                 {
2656                                         /* Obsolete syntax supported for awhile for compatibility */
2657                                         CommentStmt *n = makeNode(CommentStmt);
2658                                         n->objtype = OBJECT_RULE;
2659                                         n->objname = makeList1(makeString($4));
2660                                         n->objargs = NIL;
2661                                         n->comment = $6;
2662                                         $$ = (Node *) n;
2663                                 }
2664                         | COMMENT ON TRIGGER name ON any_name IS comment_text
2665                                 {
2666                                         CommentStmt *n = makeNode(CommentStmt);
2667                                         n->objtype = OBJECT_TRIGGER;
2668                                         n->objname = lappend($6, makeString($4));
2669                                         n->objargs = NIL;
2670                                         n->comment = $8;
2671                                         $$ = (Node *) n;
2672                                 }
2673                         | COMMENT ON OPERATOR CLASS any_name USING access_method IS comment_text
2674                                 {
2675                                         CommentStmt *n = makeNode(CommentStmt);
2676                                         n->objtype = OBJECT_OPCLASS;
2677                                         n->objname = $5;
2678                                         n->objargs = makeList1(makeString($7));
2679                                         n->comment = $9;
2680                                         $$ = (Node *) n;
2681                                 }
2682                         | COMMENT ON LARGE_P OBJECT_P NumericOnly IS comment_text
2683                                 {
2684                                         CommentStmt *n = makeNode(CommentStmt);
2685                                         n->objtype = OBJECT_LARGEOBJECT;
2686                                         n->objname = makeList1($5);
2687                                         n->objargs = NIL;
2688                                         n->comment = $7;
2689                                         $$ = (Node *) n;
2690                                 }
2691                         | COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
2692                                 {
2693                                         CommentStmt *n = makeNode(CommentStmt);
2694                                         n->objtype = OBJECT_CAST;
2695                                         n->objname = makeList1($5);
2696                                         n->objargs = makeList1($7);
2697                                         n->comment = $10;
2698                                         $$ = (Node *) n;
2699                                 }
2700                         | COMMENT ON opt_procedural LANGUAGE any_name IS comment_text
2701                                 {
2702                                         CommentStmt *n = makeNode(CommentStmt);
2703                                         n->objtype = OBJECT_LANGUAGE;
2704                                         n->objname = $5;
2705                                         n->objargs = NIL;
2706                                         n->comment = $7;
2707                                         $$ = (Node *) n;
2708                                 }
2709                 ;
2710
2711 comment_type:
2712                         COLUMN                                                          { $$ = OBJECT_COLUMN; }
2713                         | DATABASE                                                      { $$ = OBJECT_DATABASE; }
2714                         | SCHEMA                                                        { $$ = OBJECT_SCHEMA; }
2715                         | INDEX                                                         { $$ = OBJECT_INDEX; }
2716                         | SEQUENCE                                                      { $$ = OBJECT_SEQUENCE; }
2717                         | TABLE                                                         { $$ = OBJECT_TABLE; }
2718                         | DOMAIN_P                                                      { $$ = OBJECT_TYPE; }
2719                         | TYPE_P                                                        { $$ = OBJECT_TYPE; }
2720                         | VIEW                                                          { $$ = OBJECT_VIEW; }
2721                         | CONVERSION_P                                          { $$ = OBJECT_CONVERSION; }
2722                 ;
2723
2724 comment_text:
2725                         Sconst                                                          { $$ = $1; }
2726                         | NULL_P                                                        { $$ = NULL; }
2727                 ;
2728
2729 /*****************************************************************************
2730  *
2731  *              QUERY:
2732  *                      fetch/move
2733  *
2734  *****************************************************************************/
2735
2736 FetchStmt:      FETCH fetch_direction from_in name
2737                                 {
2738                                         FetchStmt *n = (FetchStmt *) $2;
2739                                         n->portalname = $4;
2740                                         n->ismove = FALSE;
2741                                         $$ = (Node *)n;
2742                                 }
2743                         | FETCH name
2744                                 {
2745                                         FetchStmt *n = makeNode(FetchStmt);
2746                                         n->direction = FETCH_FORWARD;
2747                                         n->howMany = 1;
2748                                         n->portalname = $2;
2749                                         n->ismove = FALSE;
2750                                         $$ = (Node *)n;
2751                                 }
2752                         | MOVE fetch_direction from_in name
2753                                 {
2754                                         FetchStmt *n = (FetchStmt *) $2;
2755                                         n->portalname = $4;
2756                                         n->ismove = TRUE;
2757                                         $$ = (Node *)n;
2758                                 }
2759                         | MOVE name
2760                                 {
2761                                         FetchStmt *n = makeNode(FetchStmt);
2762                                         n->direction = FETCH_FORWARD;
2763                                         n->howMany = 1;
2764                                         n->portalname = $2;
2765                                         n->ismove = TRUE;
2766                                         $$ = (Node *)n;
2767                                 }
2768                 ;
2769
2770 fetch_direction:
2771                         /*EMPTY*/
2772                                 {
2773                                         FetchStmt *n = makeNode(FetchStmt);
2774                                         n->direction = FETCH_FORWARD;
2775                                         n->howMany = 1;
2776                                         $$ = (Node *)n;
2777                                 }
2778                         | NEXT
2779                                 {
2780                                         FetchStmt *n = makeNode(FetchStmt);
2781                                         n->direction = FETCH_FORWARD;
2782                                         n->howMany = 1;
2783                                         $$ = (Node *)n;
2784                                 }
2785                         | PRIOR
2786                                 {
2787                                         FetchStmt *n = makeNode(FetchStmt);
2788                                         n->direction = FETCH_BACKWARD;
2789                                         n->howMany = 1;
2790                                         $$ = (Node *)n;
2791                                 }
2792                         | FIRST_P
2793                                 {
2794                                         FetchStmt *n = makeNode(FetchStmt);
2795                                         n->direction = FETCH_ABSOLUTE;
2796                                         n->howMany = 1;
2797                                         $$ = (Node *)n;
2798                                 }
2799                         | LAST_P
2800                                 {
2801                                         FetchStmt *n = makeNode(FetchStmt);
2802                                         n->direction = FETCH_ABSOLUTE;
2803                                         n->howMany = -1;
2804                                         $$ = (Node *)n;
2805                                 }
2806                         | ABSOLUTE_P fetch_count
2807                                 {
2808                                         FetchStmt *n = makeNode(FetchStmt);
2809                                         n->direction = FETCH_ABSOLUTE;
2810                                         n->howMany = $2;
2811                                         $$ = (Node *)n;
2812                                 }
2813                         | RELATIVE_P fetch_count
2814                                 {
2815                                         FetchStmt *n = makeNode(FetchStmt);
2816                                         n->direction = FETCH_RELATIVE;
2817                                         n->howMany = $2;
2818                                         $$ = (Node *)n;
2819                                 }
2820                         | fetch_count
2821                                 {
2822                                         FetchStmt *n = makeNode(FetchStmt);
2823                                         n->direction = FETCH_FORWARD;
2824                                         n->howMany = $1;
2825                                         $$ = (Node *)n;
2826                                 }
2827                         | ALL
2828                                 {
2829                                         FetchStmt *n = makeNode(FetchStmt);
2830                                         n->direction = FETCH_FORWARD;
2831                                         n->howMany = FETCH_ALL;
2832                                         $$ = (Node *)n;
2833                                 }
2834                         | FORWARD
2835                                 {
2836                                         FetchStmt *n = makeNode(FetchStmt);
2837                                         n->direction = FETCH_FORWARD;
2838                                         n->howMany = 1;
2839                                         $$ = (Node *)n;
2840                                 }
2841                         | FORWARD fetch_count
2842                                 {
2843                                         FetchStmt *n = makeNode(FetchStmt);
2844                                         n->direction = FETCH_FORWARD;
2845                                         n->howMany = $2;
2846                                         $$ = (Node *)n;
2847                                 }
2848                         | FORWARD ALL
2849                                 {
2850                                         FetchStmt *n = makeNode(FetchStmt);
2851                                         n->direction = FETCH_FORWARD;
2852                                         n->howMany = FETCH_ALL;
2853                                         $$ = (Node *)n;
2854                                 }
2855                         | BACKWARD
2856                                 {
2857                                         FetchStmt *n = makeNode(FetchStmt);
2858                                         n->direction = FETCH_BACKWARD;
2859                                         n->howMany = 1;
2860                                         $$ = (Node *)n;
2861                                 }
2862                         | BACKWARD fetch_count
2863                                 {
2864                                         FetchStmt *n = makeNode(FetchStmt);
2865                                         n->direction = FETCH_BACKWARD;
2866                                         n->howMany = $2;
2867                                         $$ = (Node *)n;
2868                                 }
2869                         | BACKWARD ALL
2870                                 {
2871                                         FetchStmt *n = makeNode(FetchStmt);
2872                                         n->direction = FETCH_BACKWARD;
2873                                         n->howMany = FETCH_ALL;
2874                                         $$ = (Node *)n;
2875                                 }
2876                 ;
2877
2878 fetch_count:
2879                         Iconst                                                                  { $$ = $1; }
2880                         | '-' Iconst                                                    { $$ = - $2; }
2881                 ;
2882
2883 from_in:        FROM                                                                    {}
2884                         | IN_P                                                                  {}
2885                 ;
2886
2887
2888 /*****************************************************************************
2889  *
2890  * GRANT and REVOKE statements
2891  *
2892  *****************************************************************************/
2893
2894 GrantStmt:      GRANT privileges ON privilege_target TO grantee_list
2895                         opt_grant_grant_option
2896                                 {
2897                                         GrantStmt *n = makeNode(GrantStmt);
2898                                         n->is_grant = true;
2899                                         n->privileges = $2;
2900                                         n->objtype = ($4)->objtype;
2901                                         n->objects = ($4)->objs;
2902                                         n->grantees = $6;
2903                                         n->grant_option = $7;
2904                                         $$ = (Node*)n;
2905                                 }
2906                 ;
2907
2908 RevokeStmt: REVOKE opt_revoke_grant_option privileges ON privilege_target
2909                         FROM grantee_list opt_drop_behavior
2910                                 {
2911                                         GrantStmt *n = makeNode(GrantStmt);
2912                                         n->is_grant = false;
2913                                         n->privileges = $3;
2914                                         n->objtype = ($5)->objtype;
2915                                         n->objects = ($5)->objs;
2916                                         n->grantees = $7;
2917                                         n->grant_option = $2;
2918                                         n->behavior = $8;
2919
2920                                         $$ = (Node *)n;
2921                                 }
2922                 ;
2923
2924
2925 /* either ALL [PRIVILEGES] or a list of individual privileges */
2926 privileges: privilege_list                              { $$ = $1; }
2927                         | ALL                                           { $$ = makeListi1(ACL_ALL_RIGHTS); }
2928                         | ALL PRIVILEGES                        { $$ = makeListi1(ACL_ALL_RIGHTS); }
2929                 ;
2930
2931 privilege_list:
2932                         privilege                                                               { $$ = makeListi1($1); }
2933                         | privilege_list ',' privilege                  { $$ = lappendi($1, $3); }
2934                 ;
2935
2936 /* Not all of these privilege types apply to all objects, but that
2937  * gets sorted out later.
2938  */
2939 privilege:      SELECT                                                                  { $$ = ACL_SELECT; }
2940                         | INSERT                                                                { $$ = ACL_INSERT; }
2941                         | UPDATE                                                                { $$ = ACL_UPDATE; }
2942                         | DELETE_P                                                              { $$ = ACL_DELETE; }
2943                         | RULE                                                                  { $$ = ACL_RULE; }
2944                         | REFERENCES                                                    { $$ = ACL_REFERENCES; }
2945                         | TRIGGER                                                               { $$ = ACL_TRIGGER; }
2946                         | EXECUTE                                                               { $$ = ACL_EXECUTE; }
2947                         | USAGE                                                                 { $$ = ACL_USAGE; }
2948                         | CREATE                                                                { $$ = ACL_CREATE; }
2949                         | TEMPORARY                                                             { $$ = ACL_CREATE_TEMP; }
2950                         | TEMP                                                                  { $$ = ACL_CREATE_TEMP; }
2951                 ;
2952
2953
2954 /* Don't bother trying to fold the first two rules into one using
2955    opt_table.  You're going to get conflicts. */
2956 privilege_target:
2957                         qualified_name_list
2958                                 {
2959                                         PrivTarget *n = makeNode(PrivTarget);
2960                                         n->objtype = ACL_OBJECT_RELATION;
2961                                         n->objs = $1;
2962                                         $$ = n;
2963                                 }
2964                         | TABLE qualified_name_list
2965                                 {
2966                                         PrivTarget *n = makeNode(PrivTarget);
2967                                         n->objtype = ACL_OBJECT_RELATION;
2968                                         n->objs = $2;
2969                                         $$ = n;
2970                                 }
2971                         | FUNCTION function_with_argtypes_list
2972                                 {
2973                                         PrivTarget *n = makeNode(PrivTarget);
2974                                         n->objtype = ACL_OBJECT_FUNCTION;
2975                                         n->objs = $2;
2976                                         $$ = n;
2977                                 }
2978                         | DATABASE name_list
2979                                 {
2980                                         PrivTarget *n = makeNode(PrivTarget);
2981                                         n->objtype = ACL_OBJECT_DATABASE;
2982                                         n->objs = $2;
2983                                         $$ = n;
2984                                 }
2985                         | LANGUAGE name_list
2986                                 {
2987                                         PrivTarget *n = makeNode(PrivTarget);
2988                                         n->objtype = ACL_OBJECT_LANGUAGE;
2989                                         n->objs = $2;
2990                                         $$ = n;
2991                                 }
2992                         | SCHEMA name_list
2993                                 {
2994                                         PrivTarget *n = makeNode(PrivTarget);
2995                                         n->objtype = ACL_OBJECT_NAMESPACE;
2996                                         n->objs = $2;
2997                                         $$ = n;
2998                                 }
2999                 ;
3000
3001
3002 grantee_list:
3003                         grantee                                                                 { $$ = makeList1($1); }
3004                         | grantee_list ',' grantee                              { $$ = lappend($1, $3); }
3005                 ;
3006
3007 grantee:        ColId
3008                                 {
3009                                         PrivGrantee *n = makeNode(PrivGrantee);
3010                                         /* This hack lets us avoid reserving PUBLIC as a keyword*/
3011                                         if (strcmp($1, "public") == 0)
3012                                                 n->username = NULL;
3013                                         else
3014                                                 n->username = $1;
3015                                         n->groupname = NULL;
3016                                         $$ = (Node *)n;
3017                                 }
3018                         | GROUP_P ColId
3019                                 {
3020                                         PrivGrantee *n = makeNode(PrivGrantee);
3021                                         /* Treat GROUP PUBLIC as a synonym for PUBLIC */
3022                                         if (strcmp($2, "public") == 0)
3023                                                 n->groupname = NULL;
3024                                         else
3025                                                 n->groupname = $2;
3026                                         n->username = NULL;
3027                                         $$ = (Node *)n;
3028                                 }
3029                 ;
3030
3031
3032 opt_grant_grant_option:
3033                         WITH GRANT OPTION { $$ = TRUE; }
3034                         | /*EMPTY*/ { $$ = FALSE; }
3035                 ;
3036
3037 opt_revoke_grant_option:
3038                         GRANT OPTION FOR { $$ = TRUE; }
3039                         | /*EMPTY*/ { $$ = FALSE; }
3040                 ;
3041
3042
3043 function_with_argtypes_list:
3044                         function_with_argtypes                                  { $$ = makeList1($1); }
3045                         | function_with_argtypes_list ',' function_with_argtypes
3046                                                                                                         { $$ = lappend($1, $3); }
3047                 ;
3048
3049 function_with_argtypes:
3050                         func_name func_args
3051                                 {
3052                                         FuncWithArgs *n = makeNode(FuncWithArgs);
3053                                         n->funcname = $1;
3054                                         n->funcargs = extractArgTypes($2);
3055                                         $$ = (Node *)n;
3056                                 }
3057                 ;
3058
3059
3060 /*****************************************************************************
3061  *
3062  *              QUERY:
3063  *                              create index <indexname> on <relname>
3064  *                                [ using <access> ] "(" ( <col> [ using <opclass> ] )+ ")"
3065  *                                [ where <predicate> ]
3066  *
3067  *****************************************************************************/
3068
3069 IndexStmt:      CREATE index_opt_unique INDEX index_name ON qualified_name
3070                         access_method_clause '(' index_params ')' where_clause
3071                                 {
3072                                         IndexStmt *n = makeNode(IndexStmt);
3073                                         n->unique = $2;
3074                                         n->idxname = $4;
3075                                         n->relation = $6;
3076                                         n->accessMethod = $7;
3077                                         n->indexParams = $9;
3078                                         n->whereClause = $11;
3079                                         $$ = (Node *)n;
3080                                 }
3081                 ;
3082
3083 index_opt_unique:
3084                         UNIQUE                                                                  { $$ = TRUE; }
3085                         | /*EMPTY*/                                                             { $$ = FALSE; }
3086                 ;
3087
3088 access_method_clause:
3089                         USING access_method                                             { $$ = $2; }
3090                         | /*EMPTY*/                                                             { $$ = DEFAULT_INDEX_TYPE; }
3091                 ;
3092
3093 index_params:   index_elem                                                      { $$ = makeList1($1); }
3094                         | index_params ',' index_elem                   { $$ = lappend($1, $3); }
3095                 ;
3096
3097 /*
3098  * Index attributes can be either simple column references, or arbitrary
3099  * expressions in parens.  For backwards-compatibility reasons, we allow
3100  * an expression that's just a function call to be written without parens.
3101  */
3102 index_elem:     attr_name opt_class
3103                                 {
3104                                         $$ = makeNode(IndexElem);
3105                                         $$->name = $1;
3106                                         $$->expr = NULL;
3107                                         $$->opclass = $2;
3108                                 }
3109                         | func_name '(' expr_list ')' opt_class
3110                                 {
3111                                         FuncCall *n = makeNode(FuncCall);
3112                                         n->funcname = $1;
3113                                         n->args = $3;
3114                                         n->agg_star = FALSE;
3115                                         n->agg_distinct = FALSE;
3116
3117                                         $$ = makeNode(IndexElem);
3118                                         $$->name = NULL;
3119                                         $$->expr = (Node *)n;
3120                                         $$->opclass = $5;
3121                                 }
3122                         | '(' a_expr ')' opt_class
3123                                 {
3124                                         $$ = makeNode(IndexElem);
3125                                         $$->name = NULL;
3126                                         $$->expr = $2;
3127                                         $$->opclass = $4;
3128                                 }
3129                 ;
3130
3131 opt_class:      any_name                                                                { $$ = $1; }
3132                         | USING any_name                                                { $$ = $2; }
3133                         | /*EMPTY*/                                                             { $$ = NIL; }
3134                 ;
3135
3136 /*****************************************************************************
3137  *
3138  *              QUERY:
3139  *                              create [or replace] function <fname>
3140  *                                              [(<type-1> { , <type-n>})]
3141  *                                              returns <type-r>
3142  *                                              as <filename or code in language as appropriate>
3143  *                                              language <lang> [with parameters]
3144  *
3145  *****************************************************************************/
3146
3147 CreateFunctionStmt:
3148                         CREATE opt_or_replace FUNCTION func_name func_args
3149                         RETURNS func_return createfunc_opt_list opt_definition
3150                                 {
3151                                         CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
3152                                         n->replace = $2;
3153                                         n->funcname = $4;
3154                                         n->parameters = $5;
3155                                         n->returnType = $7;
3156                                         n->options = $8;
3157                                         n->withClause = $9;
3158                                         $$ = (Node *)n;
3159                                 }
3160                 ;
3161
3162 opt_or_replace:
3163                         OR REPLACE                                                              { $$ = TRUE; }
3164                         | /*EMPTY*/                                                             { $$ = FALSE; }
3165                 ;
3166
3167 func_args:      '(' func_args_list ')'                                  { $$ = $2; }
3168                         | '(' ')'                                                               { $$ = NIL; }
3169                 ;
3170
3171 func_args_list:
3172                         func_arg                                                                { $$ = makeList1($1); }
3173                         | func_args_list ',' func_arg                   { $$ = lappend($1, $3); }
3174                 ;
3175
3176 /* We can catch over-specified arguments here if we want to,
3177  * but for now better to silently swallow typmod, etc.
3178  * - thomas 2000-03-22
3179  */
3180 func_arg:
3181                         arg_class param_name func_type
3182                                 {
3183                                         FunctionParameter *n = makeNode(FunctionParameter);
3184                                         n->name = $2;
3185                                         n->argType = $3;
3186                                         $$ = n;
3187                                 }
3188                         | arg_class func_type
3189                                 {
3190                                         FunctionParameter *n = makeNode(FunctionParameter);
3191                                         n->name = NULL;
3192                                         n->argType = $2;
3193                                         $$ = n;
3194                                 }
3195                 ;
3196
3197 arg_class:      IN_P                                                                    { $$ = FALSE; }
3198                         | OUT_P
3199                                 {
3200                                         ereport(ERROR,
3201                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3202                                                          errmsg("CREATE FUNCTION / OUT parameters are not implemented")));
3203                                         $$ = TRUE;
3204                                 }
3205                         | INOUT
3206                                 {
3207                                         ereport(ERROR,
3208                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3209                                                          errmsg("CREATE FUNCTION / INOUT parameters are not implemented")));
3210                                         $$ = FALSE;
3211                                 }
3212                         | /*EMPTY*/                                                             { $$ = FALSE; }
3213                 ;
3214
3215 /*
3216  * Ideally param_name should be ColId, but that causes too many conflicts.
3217  */
3218 param_name:     function_name
3219                 ;
3220
3221 func_return:
3222                         func_type
3223                                 {
3224                                         /* We can catch over-specified arguments here if we want to,
3225                                          * but for now better to silently swallow typmod, etc.
3226                                          * - thomas 2000-03-22
3227                                          */
3228                                         $$ = $1;
3229                                 }
3230                 ;
3231
3232 /*
3233  * We would like to make the second production here be ColId attrs etc,
3234  * but that causes reduce/reduce conflicts.  type_name is next best choice.
3235  */
3236 func_type:      Typename                                                                { $$ = $1; }
3237                         | type_name attrs '%' TYPE_P
3238                                 {
3239                                         $$ = makeNode(TypeName);
3240                                         $$->names = lcons(makeString($1), $2);
3241                                         $$->pct_type = true;
3242                                         $$->typmod = -1;
3243                                 }
3244                 ;
3245
3246
3247 createfunc_opt_list:
3248                         /* Must be at least one to prevent conflict */
3249                         createfunc_opt_item                     { $$ = makeList1($1); }
3250                         | createfunc_opt_list createfunc_opt_item { $$ = lappend($1, $2); }
3251         ;
3252
3253 createfunc_opt_item:
3254                         AS func_as
3255                                 {
3256                                         $$ = makeDefElem("as", (Node *)$2);
3257                                 }
3258                         | LANGUAGE ColId_or_Sconst
3259                                 {
3260                                         $$ = makeDefElem("language", (Node *)makeString($2));
3261                                 }
3262                         | IMMUTABLE
3263                                 {
3264                                         $$ = makeDefElem("volatility", (Node *)makeString("immutable"));
3265                                 }
3266                         | STABLE
3267                                 {
3268                                         $$ = makeDefElem("volatility", (Node *)makeString("stable"));
3269                                 }
3270                         | VOLATILE
3271                                 {
3272                                         $$ = makeDefElem("volatility", (Node *)makeString("volatile"));
3273                                 }
3274                         | CALLED ON NULL_P INPUT_P
3275                                 {
3276                                         $$ = makeDefElem("strict", (Node *)makeInteger(FALSE));
3277                                 }
3278                         | RETURNS NULL_P ON NULL_P INPUT_P
3279                                 {
3280                                         $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
3281                                 }
3282                         | STRICT_P
3283                                 {
3284                                         $$ = makeDefElem("strict", (Node *)makeInteger(TRUE));
3285                                 }
3286                         | EXTERNAL SECURITY DEFINER
3287                                 {
3288                                         $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
3289                                 }
3290                         | EXTERNAL SECURITY INVOKER
3291                                 {
3292                                         $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
3293                                 }
3294                         | SECURITY DEFINER
3295                                 {
3296                                         $$ = makeDefElem("security", (Node *)makeInteger(TRUE));
3297                                 }
3298                         | SECURITY INVOKER
3299                                 {
3300                                         $$ = makeDefElem("security", (Node *)makeInteger(FALSE));
3301                                 }
3302                 ;
3303
3304 func_as:        Sconst                                          { $$ = makeList1(makeString($1)); }
3305                         | Sconst ',' Sconst
3306                                 {
3307                                         $$ = makeList2(makeString($1), makeString($3));
3308                                 }
3309                 ;
3310
3311 opt_definition:
3312                         WITH definition                                                 { $$ = $2; }
3313                         | /*EMPTY*/                                                             { $$ = NIL; }
3314                 ;
3315
3316
3317 /*****************************************************************************
3318  *
3319  *              QUERY:
3320  *
3321  *              DROP FUNCTION funcname (arg1, arg2, ...) [ RESTRICT | CASCADE ]
3322  *              DROP AGGREGATE aggname (aggtype) [ RESTRICT | CASCADE ]
3323  *              DROP OPERATOR opname (leftoperand_typ, rightoperand_typ) [ RESTRICT | CASCADE ]
3324  *
3325  *****************************************************************************/
3326
3327 RemoveFuncStmt:
3328                         DROP FUNCTION func_name func_args opt_drop_behavior
3329                                 {
3330                                         RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
3331                                         n->funcname = $3;
3332                                         n->args = extractArgTypes($4);
3333                                         n->behavior = $5;
3334                                         $$ = (Node *)n;
3335                                 }
3336                 ;
3337
3338 RemoveAggrStmt:
3339                         DROP AGGREGATE func_name '(' aggr_argtype ')' opt_drop_behavior
3340                                 {
3341                                                 RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
3342                                                 n->aggname = $3;
3343                                                 n->aggtype = $5;
3344                                                 n->behavior = $7;
3345                                                 $$ = (Node *)n;
3346                                 }
3347                 ;
3348
3349 aggr_argtype:
3350                         Typename                                                                { $$ = $1; }
3351                         | '*'                                                                   { $$ = NULL; }
3352                 ;
3353
3354 RemoveOperStmt:
3355                         DROP OPERATOR any_operator '(' oper_argtypes ')' opt_drop_behavior
3356                                 {
3357                                         RemoveOperStmt *n = makeNode(RemoveOperStmt);
3358                                         n->opname = $3;
3359                                         n->args = $5;
3360                                         n->behavior = $7;
3361                                         $$ = (Node *)n;
3362                                 }
3363                 ;
3364
3365 oper_argtypes:
3366                         Typename
3367                                 {
3368                                    ereport(ERROR,
3369                                                    (errcode(ERRCODE_SYNTAX_ERROR),
3370                                                         errmsg("missing argument"),
3371                                                         errhint("Use NONE to denote the missing argument of a unary operator.")));
3372                                 }
3373                         | Typename ',' Typename
3374                                         { $$ = makeList2($1, $3); }
3375                         | NONE ',' Typename /* left unary */
3376                                         { $$ = makeList2(NULL, $3); }
3377                         | Typename ',' NONE /* right unary */
3378                                         { $$ = makeList2($1, NULL); }
3379                 ;
3380
3381 any_operator:
3382                         all_Op
3383                                         { $$ = makeList1(makeString($1)); }
3384                         | ColId '.' any_operator
3385                                         { $$ = lcons(makeString($1), $3); }
3386                 ;
3387
3388
3389 /*****************************************************************************
3390  *
3391  *              CREATE CAST / DROP CAST
3392  *
3393  *****************************************************************************/
3394
3395 CreateCastStmt: CREATE CAST '(' Typename AS Typename ')'
3396                                         WITH FUNCTION function_with_argtypes cast_context
3397                                 {
3398                                         CreateCastStmt *n = makeNode(CreateCastStmt);
3399                                         n->sourcetype = $4;
3400                                         n->targettype = $6;
3401                                         n->func = (FuncWithArgs *) $10;
3402                                         n->context = (CoercionContext) $11;
3403                                         $$ = (Node *)n;
3404                                 }
3405                         | CREATE CAST '(' Typename AS Typename ')'
3406                                         WITHOUT FUNCTION cast_context
3407                                 {
3408                                         CreateCastStmt *n = makeNode(CreateCastStmt);
3409                                         n->sourcetype = $4;
3410                                         n->targettype = $6;
3411                                         n->func = NULL;
3412                                         n->context = (CoercionContext) $10;
3413                                         $$ = (Node *)n;
3414                                 }
3415                 ;
3416
3417 cast_context:  AS IMPLICIT_P                                    { $$ = COERCION_IMPLICIT; }
3418                 | AS ASSIGNMENT                                                 { $$ = COERCION_ASSIGNMENT; }
3419                 | /*EMPTY*/                                                             { $$ = COERCION_EXPLICIT; }
3420                 ;
3421
3422
3423 DropCastStmt: DROP CAST '(' Typename AS Typename ')' opt_drop_behavior
3424                                 {
3425                                         DropCastStmt *n = makeNode(DropCastStmt);
3426                                         n->sourcetype = $4;
3427                                         n->targettype = $6;
3428                                         n->behavior = $8;
3429                                         $$ = (Node *)n;
3430                                 }
3431                 ;
3432
3433
3434
3435 /*****************************************************************************
3436  *
3437  *              QUERY:
3438  *
3439  *              REINDEX type <typename> [FORCE] [ALL]
3440  *
3441  *****************************************************************************/
3442
3443 ReindexStmt:
3444                         REINDEX reindex_type qualified_name opt_force
3445                                 {
3446                                         ReindexStmt *n = makeNode(ReindexStmt);
3447                                         n->kind = $2;
3448                                         n->relation = $3;
3449                                         n->name = NULL;
3450                                         n->force = $4;
3451                                         $$ = (Node *)n;
3452                                 }
3453                         | REINDEX DATABASE name opt_force
3454                                 {
3455                                         ReindexStmt *n = makeNode(ReindexStmt);
3456                                         n->kind = OBJECT_DATABASE;
3457                                         n->name = $3;
3458                                         n->relation = NULL;
3459                                         n->force = $4;
3460                                         $$ = (Node *)n;
3461                                 }
3462                 ;
3463
3464 reindex_type:
3465                         INDEX                                                                   { $$ = OBJECT_INDEX; }
3466                         | TABLE                                                                 { $$ = OBJECT_TABLE; }
3467                 ;
3468
3469 opt_force:      FORCE                                                                   {  $$ = TRUE; }
3470                         | /* EMPTY */                                                   {  $$ = FALSE; }
3471                 ;
3472
3473
3474 /*****************************************************************************
3475  *
3476  * ALTER THING name RENAME TO newname
3477  *
3478  *****************************************************************************/
3479
3480 RenameStmt: ALTER AGGREGATE func_name '(' aggr_argtype ')' RENAME TO name
3481                                 {
3482                                         RenameStmt *n = makeNode(RenameStmt);
3483                                         n->renameType = OBJECT_AGGREGATE;
3484                                         n->object = $3;
3485                                         n->objarg = makeList1($5);
3486                                         n->newname = $9;
3487                                         $$ = (Node *)n;
3488                                 }
3489                         | ALTER CONVERSION_P any_name RENAME TO name
3490                                 {
3491                                         RenameStmt *n = makeNode(RenameStmt);
3492                                         n->renameType = OBJECT_CONVERSION;
3493                                         n->object = $3;
3494                                         n->newname = $6;
3495                                         $$ = (Node *)n;
3496                                 }
3497                         | ALTER DATABASE database_name RENAME TO database_name
3498                                 {
3499                                         RenameStmt *n = makeNode(RenameStmt);
3500                                         n->renameType = OBJECT_DATABASE;
3501                                         n->subname = $3;
3502                                         n->newname = $6;
3503                                         $$ = (Node *)n;
3504                                 }
3505                         | ALTER FUNCTION func_name func_args RENAME TO name
3506                                 {
3507                                         RenameStmt *n = makeNode(RenameStmt);
3508                                         n->renameType = OBJECT_FUNCTION;
3509                                         n->object = $3;
3510                                         n->objarg = extractArgTypes($4);
3511                                         n->newname = $7;
3512                                         $$ = (Node *)n;
3513                                 }
3514                         | ALTER GROUP_P UserId RENAME TO UserId
3515                                 {
3516                                         RenameStmt *n = makeNode(RenameStmt);
3517                                         n->renameType = OBJECT_GROUP;
3518                                         n->subname = $3;
3519                                         n->newname = $6;
3520                                         $$ = (Node *)n;
3521                                 }
3522                         | ALTER LANGUAGE name RENAME TO name
3523                                 {
3524                                         RenameStmt *n = makeNode(RenameStmt);
3525                                         n->renameType = OBJECT_LANGUAGE;
3526                                         n->subname = $3;
3527                                         n->newname = $6;
3528                                         $$ = (Node *)n;
3529                                 }
3530                         | ALTER OPERATOR CLASS any_name USING access_method RENAME TO name
3531                                 {
3532                                         RenameStmt *n = makeNode(RenameStmt);
3533                                         n->renameType = OBJECT_OPCLASS;
3534                                         n->object = $4;
3535                                         n->subname = $6;
3536                                         n->newname = $9;
3537                                         $$ = (Node *)n;
3538                                 }
3539                         | ALTER SCHEMA name RENAME TO name
3540                                 {
3541                                         RenameStmt *n = makeNode(RenameStmt);
3542                                         n->renameType = OBJECT_SCHEMA;
3543                                         n->subname = $3;
3544                                         n->newname = $6;
3545                                         $$ = (Node *)n;
3546                                 }
3547                         | ALTER TABLE relation_expr RENAME TO name
3548                                 {
3549                                         RenameStmt *n = makeNode(RenameStmt);
3550                                         n->renameType = OBJECT_TABLE;
3551                                         n->relation = $3;
3552                                         n->subname = NULL;
3553                                         n->newname = $6;
3554                                         $$ = (Node *)n;
3555                                 }
3556                         | ALTER TABLE relation_expr RENAME opt_column name TO name
3557                                 {
3558                                         RenameStmt *n = makeNode(RenameStmt);
3559                                         n->renameType = OBJECT_COLUMN;
3560                                         n->relation = $3;
3561                                         n->subname = $6;
3562                                         n->newname = $8;
3563                                         $$ = (Node *)n;
3564                                 }
3565                         | ALTER TRIGGER name ON relation_expr RENAME TO name
3566                                 {
3567                                         RenameStmt *n = makeNode(RenameStmt);
3568                                         n->relation = $5;
3569                                         n->subname = $3;
3570                                         n->newname = $8;
3571                                         n->renameType = OBJECT_TRIGGER;
3572                                         $$ = (Node *)n;
3573                                 }
3574                         | ALTER USER UserId RENAME TO UserId
3575                                 {
3576                                         RenameStmt *n = makeNode(RenameStmt);
3577                                         n->renameType = OBJECT_USER;
3578                                         n->subname = $3;
3579                                         n->newname = $6;
3580                                         $$ = (Node *)n;
3581                                 }
3582                 ;
3583
3584 opt_column: COLUMN                                                                      { $$ = COLUMN; }
3585                         | /*EMPTY*/                                                             { $$ = 0; }
3586                 ;
3587
3588
3589 /*****************************************************************************
3590  *
3591  *              QUERY:  Define Rewrite Rule
3592  *
3593  *****************************************************************************/
3594
3595 RuleStmt:       CREATE opt_or_replace RULE name AS
3596                         { QueryIsRule=TRUE; }
3597                         ON event TO qualified_name where_clause
3598                         DO opt_instead RuleActionList
3599                                 {
3600                                         RuleStmt *n = makeNode(RuleStmt);
3601                                         n->replace = $2;
3602                                         n->relation = $10;
3603                                         n->rulename = $4;
3604                                         n->whereClause = $11;
3605                                         n->event = $8;
3606                                         n->instead = $13;
3607                                         n->actions = $14;
3608                                         $$ = (Node *)n;
3609                                         QueryIsRule=FALSE;
3610                                 }
3611                 ;
3612
3613 RuleActionList:
3614                         NOTHING                                                                 { $$ = NIL; }
3615                         | RuleActionStmt                                                { $$ = makeList1($1); }
3616                         | '(' RuleActionMulti ')'                               { $$ = $2; }
3617                 ;
3618
3619 /* the thrashing around here is to discard "empty" statements... */
3620 RuleActionMulti:
3621                         RuleActionMulti ';' RuleActionStmtOrEmpty
3622                                 { if ($3 != NULL)
3623                                         $$ = lappend($1, $3);
3624                                   else
3625                                         $$ = $1;
3626                                 }
3627                         | RuleActionStmtOrEmpty
3628                                 { if ($1 != NULL)
3629                                         $$ = makeList1($1);
3630                                   else
3631                                         $$ = NIL;
3632                                 }
3633                 ;
3634
3635 RuleActionStmt:
3636                         SelectStmt
3637                         | InsertStmt
3638                         | UpdateStmt
3639                         | DeleteStmt
3640                         | NotifyStmt
3641                 ;
3642
3643 RuleActionStmtOrEmpty:
3644                         RuleActionStmt                                                  { $$ = $1; }
3645                         |       /*EMPTY*/                                                       { $$ = NULL; }
3646                 ;
3647
3648 /* change me to select, update, etc. some day */
3649 event:          SELECT                                                                  { $$ = CMD_SELECT; }
3650                         | UPDATE                                                                { $$ = CMD_UPDATE; }
3651                         | DELETE_P                                                              { $$ = CMD_DELETE; }
3652                         | INSERT                                                                { $$ = CMD_INSERT; }
3653                  ;
3654
3655 opt_instead:
3656                         INSTEAD                                                                 { $$ = TRUE; }
3657                         | ALSO                                                                  { $$ = FALSE; }
3658                         | /*EMPTY*/                                                             { $$ = FALSE; }
3659                 ;
3660
3661
3662 DropRuleStmt:
3663                         DROP RULE name ON qualified_name opt_drop_behavior
3664                                 {
3665                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
3666                                         n->relation = $5;
3667                                         n->property = $3;
3668                                         n->behavior = $6;
3669                                         n->removeType = OBJECT_RULE;
3670                                         $$ = (Node *) n;
3671                                 }
3672                 ;
3673
3674
3675 /*****************************************************************************
3676  *
3677  *              QUERY:
3678  *                              NOTIFY <qualified_name> can appear both in rule bodies and
3679  *                              as a query-level command
3680  *
3681  *****************************************************************************/
3682
3683 NotifyStmt: NOTIFY qualified_name
3684                                 {
3685                                         NotifyStmt *n = makeNode(NotifyStmt);
3686                                         n->relation = $2;
3687                                         $$ = (Node *)n;
3688                                 }
3689                 ;
3690
3691 ListenStmt: LISTEN qualified_name
3692                                 {
3693                                         ListenStmt *n = makeNode(ListenStmt);
3694                                         n->relation = $2;
3695                                         $$ = (Node *)n;
3696                                 }
3697                 ;
3698
3699 UnlistenStmt:
3700                         UNLISTEN qualified_name
3701                                 {
3702                                         UnlistenStmt *n = makeNode(UnlistenStmt);
3703                                         n->relation = $2;
3704                                         $$ = (Node *)n;
3705                                 }
3706                         | UNLISTEN '*'
3707                                 {
3708                                         UnlistenStmt *n = makeNode(UnlistenStmt);
3709                                         n->relation = makeNode(RangeVar);
3710                                         n->relation->relname = "*";
3711                                         n->relation->schemaname = NULL;
3712                                         $$ = (Node *)n;
3713                                 }
3714                 ;
3715
3716
3717 /*****************************************************************************
3718  *
3719  *              Transactions:
3720  *
3721  *              BEGIN / COMMIT / ROLLBACK
3722  *              (also older versions END / ABORT)
3723  *
3724  *****************************************************************************/
3725
3726 TransactionStmt:
3727                         ABORT_P opt_transaction
3728                                 {
3729                                         TransactionStmt *n = makeNode(TransactionStmt);
3730                                         n->kind = TRANS_STMT_ROLLBACK;
3731                                         n->options = NIL;
3732                                         $$ = (Node *)n;
3733                                 }
3734                         | BEGIN_P opt_transaction transaction_mode_list_or_empty
3735                                 {
3736                                         TransactionStmt *n = makeNode(TransactionStmt);
3737                                         n->kind = TRANS_STMT_BEGIN;
3738                                         n->options = $3;
3739                                         $$ = (Node *)n;
3740                                 }
3741                         | START TRANSACTION transaction_mode_list_or_empty
3742                                 {
3743                                         TransactionStmt *n = makeNode(TransactionStmt);
3744                                         n->kind = TRANS_STMT_START;
3745                                         n->options = $3;
3746                                         $$ = (Node *)n;
3747                                 }
3748                         | COMMIT opt_transaction
3749                                 {
3750                                         TransactionStmt *n = makeNode(TransactionStmt);
3751                                         n->kind = TRANS_STMT_COMMIT;
3752                                         n->options = NIL;
3753                                         $$ = (Node *)n;
3754                                 }
3755                         | END_P opt_transaction
3756                                 {
3757                                         TransactionStmt *n = makeNode(TransactionStmt);
3758                                         n->kind = TRANS_STMT_COMMIT;
3759                                         n->options = NIL;
3760                                         $$ = (Node *)n;
3761                                 }
3762                         | ROLLBACK opt_transaction
3763                                 {
3764                                         TransactionStmt *n = makeNode(TransactionStmt);
3765                                         n->kind = TRANS_STMT_ROLLBACK;
3766                                         n->options = NIL;
3767                                         $$ = (Node *)n;
3768                                 }
3769                 ;
3770
3771 opt_transaction:        WORK                                                    {}
3772                         | TRANSACTION                                                   {}
3773                         | /*EMPTY*/                                                             {}
3774                 ;
3775
3776 transaction_mode_list:
3777                         ISOLATION LEVEL iso_level
3778                                         { $$ = makeList1(makeDefElem("transaction_isolation",
3779                                                                                                  makeStringConst($3, NULL))); }
3780                         | transaction_access_mode
3781                                         { $$ = makeList1(makeDefElem("transaction_read_only",
3782                                                                                                  makeIntConst($1))); }
3783                         | ISOLATION LEVEL iso_level transaction_access_mode
3784                                         {
3785                                                 $$ = makeList2(makeDefElem("transaction_isolation",
3786                                                                                                    makeStringConst($3, NULL)),
3787                                                                            makeDefElem("transaction_read_only",
3788                                                                                                    makeIntConst($4)));
3789                                         }
3790                         | transaction_access_mode ISOLATION LEVEL iso_level
3791                                         {
3792                                                 $$ = makeList2(makeDefElem("transaction_read_only",
3793                                                                                                    makeIntConst($1)),
3794                                                                            makeDefElem("transaction_isolation",
3795                                                                                                    makeStringConst($4, NULL)));
3796                                         }
3797                 ;
3798
3799 transaction_mode_list_or_empty:
3800                         transaction_mode_list
3801                         | /* EMPTY */
3802                                         { $$ = NIL; }
3803                 ;
3804
3805 transaction_access_mode:
3806                         READ ONLY { $$ = TRUE; }
3807                         | READ WRITE { $$ = FALSE; }
3808                 ;
3809
3810
3811 /*****************************************************************************
3812  *
3813  *              QUERY:
3814  *                              create view <viewname> '('target-list ')' AS <query>
3815  *
3816  *****************************************************************************/
3817
3818 ViewStmt:       CREATE opt_or_replace VIEW qualified_name opt_column_list
3819                                 AS SelectStmt
3820                                 {
3821                                         ViewStmt *n = makeNode(ViewStmt);
3822                                         n->replace = $2;
3823                                         n->view = $4;
3824                                         n->aliases = $5;
3825                                         n->query = (Query *) $7;
3826                                         $$ = (Node *)n;
3827                                 }
3828                 ;
3829
3830
3831 /*****************************************************************************
3832  *
3833  *              QUERY:
3834  *                              load "filename"
3835  *
3836  *****************************************************************************/
3837
3838 LoadStmt:       LOAD file_name
3839                                 {
3840                                         LoadStmt *n = makeNode(LoadStmt);
3841                                         n->filename = $2;
3842                                         $$ = (Node *)n;
3843                                 }
3844                 ;
3845
3846
3847 /*****************************************************************************
3848  *
3849  *              CREATE DATABASE
3850  *
3851  *****************************************************************************/
3852
3853 CreatedbStmt:
3854                         CREATE DATABASE database_name opt_with createdb_opt_list
3855                                 {
3856                                         CreatedbStmt *n = makeNode(CreatedbStmt);
3857                                         n->dbname = $3;
3858                                         n->options = $5;
3859                                         $$ = (Node *)n;
3860                                 }
3861                 ;
3862
3863 createdb_opt_list:
3864                         createdb_opt_list createdb_opt_item             { $$ = lappend($1, $2); }
3865                         | /* EMPTY */                                                   { $$ = NIL; }
3866                 ;
3867
3868 createdb_opt_item:
3869                         LOCATION opt_equal Sconst
3870                                 {
3871                                         $$ = makeDefElem("location", (Node *)makeString($3));
3872                                 }
3873                         | LOCATION opt_equal DEFAULT
3874                                 {
3875                                         $$ = makeDefElem("location", NULL);
3876                                 }
3877                         | TEMPLATE opt_equal name
3878                                 {
3879                                         $$ = makeDefElem("template", (Node *)makeString($3));
3880                                 }
3881                         | TEMPLATE opt_equal DEFAULT
3882                                 {
3883                                         $$ = makeDefElem("template", NULL);
3884                                 }
3885                         | ENCODING opt_equal Sconst
3886                                 {
3887                                         $$ = makeDefElem("encoding", (Node *)makeString($3));
3888                                 }
3889                         | ENCODING opt_equal Iconst
3890                                 {
3891                                         $$ = makeDefElem("encoding", (Node *)makeInteger($3));
3892                                 }
3893                         | ENCODING opt_equal DEFAULT
3894                                 {
3895                                         $$ = makeDefElem("encoding", NULL);
3896                                 }
3897                         | OWNER opt_equal name
3898                                 {
3899                                         $$ = makeDefElem("owner", (Node *)makeString($3));
3900                                 }
3901                         | OWNER opt_equal DEFAULT
3902                                 {
3903                                         $$ = makeDefElem("owner", NULL);
3904                                 }
3905                 ;
3906
3907 /*
3908  *      Though the equals sign doesn't match other WITH options, pg_dump uses
3909  *      equals for backward compability, and it doesn't seem worth removing it.
3910  *      2002-02-25
3911  */
3912 opt_equal:      '='                                                                             {}
3913                         | /*EMPTY*/                                                             {}
3914                 ;
3915
3916
3917 /*****************************************************************************
3918  *
3919  *              ALTER DATABASE
3920  *
3921  *****************************************************************************/
3922
3923 AlterDbOwnerStmt: ALTER DATABASE database_name OWNER TO UserId
3924                                 {
3925                                         AlterDbOwnerStmt *n = makeNode(AlterDbOwnerStmt);
3926                                         n->dbname = $3;
3927                                         n->uname = $6;
3928                                         $$ = (Node *)n;
3929                                 }
3930                 ;
3931
3932 AlterDatabaseSetStmt:
3933                         ALTER DATABASE database_name SET set_rest
3934                                 {
3935                                         AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
3936                                         n->dbname = $3;
3937                                         n->variable = $5->name;
3938                                         n->value = $5->args;
3939                                         $$ = (Node *)n;
3940                                 }
3941                         | ALTER DATABASE database_name VariableResetStmt
3942                                 {
3943                                         AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
3944                                         n->dbname = $3;
3945                                         n->variable = ((VariableResetStmt *)$4)->name;
3946                                         n->value = NIL;
3947                                         $$ = (Node *)n;
3948                                 }
3949                 ;
3950
3951
3952 /*****************************************************************************
3953  *
3954  *              DROP DATABASE
3955  *
3956  * This is implicitly CASCADE, no need for drop behavior
3957  *****************************************************************************/
3958
3959 DropdbStmt: DROP DATABASE database_name
3960                                 {
3961                                         DropdbStmt *n = makeNode(DropdbStmt);
3962                                         n->dbname = $3;
3963                                         $$ = (Node *)n;
3964                                 }
3965                 ;
3966
3967
3968 /*****************************************************************************
3969  *
3970  * Manipulate a domain
3971  *
3972  *****************************************************************************/
3973
3974 CreateDomainStmt:
3975                         CREATE DOMAIN_P any_name opt_as Typename ColQualList
3976                                 {
3977                                         CreateDomainStmt *n = makeNode(CreateDomainStmt);
3978                                         n->domainname = $3;
3979                                         n->typename = $5;
3980                                         n->constraints = $6;
3981                                         $$ = (Node *)n;
3982                                 }
3983                 ;
3984
3985 AlterDomainStmt:
3986                         /* ALTER DOMAIN <domain> {SET DEFAULT <expr>|DROP DEFAULT} */
3987                         ALTER DOMAIN_P any_name alter_column_default
3988                                 {
3989                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
3990                                         n->subtype = 'T';
3991                                         n->typename = $3;
3992                                         n->def = $4;
3993                                         $$ = (Node *)n;
3994                                 }
3995                         /* ALTER DOMAIN <domain> DROP NOT NULL */
3996                         | ALTER DOMAIN_P any_name DROP NOT NULL_P
3997                                 {
3998                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
3999                                         n->subtype = 'N';
4000                                         n->typename = $3;
4001                                         $$ = (Node *)n;
4002                                 }
4003                         /* ALTER DOMAIN <domain> SET NOT NULL */
4004                         | ALTER DOMAIN_P any_name SET NOT NULL_P
4005                                 {
4006                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
4007                                         n->subtype = 'O';
4008                                         n->typename = $3;
4009                                         $$ = (Node *)n;
4010                                 }
4011                         /* ALTER DOMAIN <domain> ADD CONSTRAINT ... */
4012                         | ALTER DOMAIN_P any_name ADD TableConstraint
4013                                 {
4014                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
4015                                         n->subtype = 'C';
4016                                         n->typename = $3;
4017                                         n->def = $5;
4018                                         $$ = (Node *)n;
4019                                 }
4020                         /* ALTER DOMAIN <domain> DROP CONSTRAINT <name> [RESTRICT|CASCADE] */
4021                         | ALTER DOMAIN_P any_name DROP CONSTRAINT name opt_drop_behavior
4022                                 {
4023                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
4024                                         n->subtype = 'X';
4025                                         n->typename = $3;
4026                                         n->name = $6;
4027                                         n->behavior = $7;
4028                                         $$ = (Node *)n;
4029                                 }
4030                         /* ALTER DOMAIN <domain> OWNER TO UserId */
4031                         | ALTER DOMAIN_P any_name OWNER TO UserId
4032                                 {
4033                                         AlterDomainStmt *n = makeNode(AlterDomainStmt);
4034                                         n->subtype = 'U';
4035                                         n->typename = $3;
4036                                         n->name = $6;
4037                                         $$ = (Node *)n;
4038                                 }
4039                         ;
4040
4041 opt_as:         AS                                                                              {}
4042                         | /* EMPTY */                                                   {}
4043                 ;
4044
4045
4046 /*****************************************************************************
4047  *
4048  * Manipulate a conversion
4049  *
4050  *              CREATE [DEFAULT] CONVERSION <conversion_name>
4051  *              FOR <encoding_name> TO <encoding_name> FROM <func_name>
4052  *
4053  *****************************************************************************/
4054
4055 CreateConversionStmt:
4056                         CREATE opt_default CONVERSION_P any_name FOR Sconst
4057                         TO Sconst FROM any_name
4058                         {
4059                           CreateConversionStmt *n = makeNode(CreateConversionStmt);
4060                           n->conversion_name = $4;
4061                           n->for_encoding_name = $6;
4062                           n->to_encoding_name = $8;
4063                           n->func_name = $10;
4064                           n->def = $2;
4065                           $$ = (Node *)n;
4066                         }
4067                 ;
4068
4069 /*****************************************************************************
4070  *
4071  *              QUERY:
4072  *                              cluster <index_name> on <qualified_name>
4073  *                              cluster <qualified_name>
4074  *                              cluster
4075  *
4076  *****************************************************************************/
4077
4078 ClusterStmt:
4079                         CLUSTER index_name ON qualified_name
4080                                 {
4081                                    ClusterStmt *n = makeNode(ClusterStmt);
4082                                    n->relation = $4;
4083                                    n->indexname = $2;
4084                                    $$ = (Node*)n;
4085                                 }
4086                         | CLUSTER qualified_name
4087                                 {
4088                                ClusterStmt *n = makeNode(ClusterStmt);
4089                                    n->relation = $2;
4090                                    n->indexname = NULL;
4091                                    $$ = (Node*)n;
4092                                 }
4093                         | CLUSTER
4094                             {
4095                                    ClusterStmt *n = makeNode(ClusterStmt);
4096                                    n->relation = NULL;
4097                                    n->indexname = NULL;
4098                                    $$ = (Node*)n;
4099                                 }
4100                 ;
4101
4102 /*****************************************************************************
4103  *
4104  *              QUERY:
4105  *                              vacuum
4106  *                              analyze
4107  *
4108  *****************************************************************************/
4109
4110 VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
4111                                 {
4112                                         VacuumStmt *n = makeNode(VacuumStmt);
4113                                         n->vacuum = true;
4114                                         n->analyze = false;
4115                                         n->full = $2;
4116                                         n->freeze = $3;
4117                                         n->verbose = $4;
4118                                         n->relation = NULL;
4119                                         n->va_cols = NIL;
4120                                         $$ = (Node *)n;
4121                                 }
4122                         | VACUUM opt_full opt_freeze opt_verbose qualified_name
4123                                 {
4124                                         VacuumStmt *n = makeNode(VacuumStmt);
4125                                         n->vacuum = true;
4126                                         n->analyze = false;
4127                                         n->full = $2;
4128                                         n->freeze = $3;
4129                                         n->verbose = $4;
4130                                         n->relation = $5;
4131                                         n->va_cols = NIL;
4132                                         $$ = (Node *)n;
4133                                 }
4134                         | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
4135                                 {
4136                                         VacuumStmt *n = (VacuumStmt *) $5;
4137                                         n->vacuum = true;
4138                                         n->full = $2;
4139                                         n->freeze = $3;
4140                                         n->verbose |= $4;
4141                                         $$ = (Node *)n;
4142                                 }
4143                 ;
4144
4145 AnalyzeStmt:
4146                         analyze_keyword opt_verbose
4147                                 {
4148                                         VacuumStmt *n = makeNode(VacuumStmt);
4149                                         n->vacuum = false;
4150                                         n->analyze = true;
4151                                         n->full = false;
4152                                         n->freeze = false;
4153                                         n->verbose = $2;
4154                                         n->relation = NULL;
4155                                         n->va_cols = NIL;
4156                                         $$ = (Node *)n;
4157                                 }
4158                         | analyze_keyword opt_verbose qualified_name opt_name_list
4159                                 {
4160                                         VacuumStmt *n = makeNode(VacuumStmt);
4161                                         n->vacuum = false;
4162                                         n->analyze = true;
4163                                         n->full = false;
4164                                         n->freeze = false;
4165                                         n->verbose = $2;
4166                                         n->relation = $3;
4167                                         n->va_cols = $4;
4168                                         $$ = (Node *)n;
4169                                 }
4170                 ;
4171
4172 analyze_keyword:
4173                         ANALYZE                                                                 {}
4174                         | ANALYSE /* British */                                 {}
4175                 ;
4176
4177 opt_verbose:
4178                         VERBOSE                                                                 { $$ = TRUE; }
4179                         | /*EMPTY*/                                                             { $$ = FALSE; }
4180                 ;
4181
4182 opt_full:       FULL                                                                    { $$ = TRUE; }
4183                         | /*EMPTY*/                                                             { $$ = FALSE; }
4184                 ;
4185
4186 opt_freeze: FREEZE                                                                      { $$ = TRUE; }
4187                         | /*EMPTY*/                                                             { $$ = FALSE; }
4188                 ;
4189
4190 opt_name_list:
4191                         '(' name_list ')'                                               { $$ = $2; }
4192                         | /*EMPTY*/                                                             { $$ = NIL; }
4193                 ;
4194
4195
4196 /*****************************************************************************
4197  *
4198  *              QUERY:
4199  *                              EXPLAIN [ANALYZE] [VERBOSE] query
4200  *
4201  *****************************************************************************/
4202
4203 ExplainStmt: EXPLAIN opt_analyze opt_verbose ExplainableStmt
4204                                 {
4205                                         ExplainStmt *n = makeNode(ExplainStmt);
4206                                         n->analyze = $2;
4207                                         n->verbose = $3;
4208                                         n->query = (Query*)$4;
4209                                         $$ = (Node *)n;
4210                                 }
4211                 ;
4212
4213 ExplainableStmt:
4214                         SelectStmt
4215                         | InsertStmt
4216                         | UpdateStmt
4217                         | DeleteStmt
4218                         | DeclareCursorStmt
4219                         | ExecuteStmt                                   /* by default all are $$=$1 */
4220                 ;
4221
4222 opt_analyze:
4223                         analyze_keyword                 { $$ = TRUE; }
4224                         | /* EMPTY */                   { $$ = FALSE; }
4225                 ;
4226
4227 /*****************************************************************************
4228  *
4229  *              QUERY:
4230  *                              PREPARE <plan_name> [(args, ...)] AS <query>
4231  *
4232  *****************************************************************************/
4233
4234 PrepareStmt: PREPARE name prep_type_clause AS PreparableStmt
4235                                 {
4236                                         PrepareStmt *n = makeNode(PrepareStmt);
4237                                         n->name = $2;
4238                                         n->argtypes = $3;
4239                                         n->query = (Query *) $5;
4240                                         $$ = (Node *) n;
4241                                 }
4242                 ;
4243
4244 prep_type_clause: '(' prep_type_list ')'        { $$ = $2; }
4245                                 | /* EMPTY */                           { $$ = NIL; }
4246                 ;
4247
4248 prep_type_list: Typename                        { $$ = makeList1($1); }
4249                           | prep_type_list ',' Typename
4250                                                                         { $$ = lappend($1, $3); }
4251                 ;
4252
4253 PreparableStmt:
4254                         SelectStmt
4255                         | InsertStmt
4256                         | UpdateStmt
4257                         | DeleteStmt                                    /* by default all are $$=$1 */
4258                 ;
4259
4260 /*****************************************************************************
4261  *
4262  * EXECUTE <plan_name> [(params, ...)]
4263  * CREATE TABLE <name> AS EXECUTE <plan_name> [(params, ...)]
4264  *
4265  *****************************************************************************/
4266
4267 ExecuteStmt: EXECUTE name execute_param_clause
4268                                 {
4269                                         ExecuteStmt *n = makeNode(ExecuteStmt);
4270                                         n->name = $2;
4271                                         n->params = $3;
4272                                         n->into = NULL;
4273                                         $$ = (Node *) n;
4274                                 }
4275                         | CREATE OptTemp TABLE qualified_name OptCreateAs AS EXECUTE name execute_param_clause
4276                                 {
4277                                         ExecuteStmt *n = makeNode(ExecuteStmt);
4278                                         n->name = $8;
4279                                         n->params = $9;
4280                                         $4->istemp = $2;
4281                                         n->into = $4;
4282                                         if ($5)
4283                                                 ereport(ERROR,
4284                                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4285                                                                  errmsg("column name list not allowed in CREATE TABLE / AS EXECUTE")));
4286                                         /* ... because it's not implemented, but it could be */
4287                                         $$ = (Node *) n;
4288                                 }
4289                 ;
4290
4291 execute_param_clause: '(' expr_list ')'                         { $$ = $2; }
4292                                         | /* EMPTY */                                   { $$ = NIL; }
4293                                         ;
4294
4295 /*****************************************************************************
4296  *
4297  *              QUERY:
4298  *                              DEALLOCATE [PREPARE] <plan_name>
4299  *
4300  *****************************************************************************/
4301
4302 DeallocateStmt: DEALLOCATE name
4303                                         {
4304                                                 DeallocateStmt *n = makeNode(DeallocateStmt);
4305                                                 n->name = $2;
4306                                                 $$ = (Node *) n;
4307                                         }
4308                                 | DEALLOCATE PREPARE name
4309                                         {
4310                                                 DeallocateStmt *n = makeNode(DeallocateStmt);
4311                                                 n->name = $3;
4312                                                 $$ = (Node *) n;
4313                                         }
4314                 ;
4315
4316 /*****************************************************************************
4317  *
4318  *              QUERY:
4319  *                              INSERT STATEMENTS
4320  *
4321  *****************************************************************************/
4322
4323 InsertStmt:
4324                         INSERT INTO qualified_name insert_rest
4325                                 {
4326                                         $4->relation = $3;
4327                                         $$ = (Node *) $4;
4328                                 }
4329                 ;
4330
4331 insert_rest:
4332                         VALUES '(' insert_target_list ')'
4333                                 {
4334                                         $$ = makeNode(InsertStmt);
4335                                         $$->cols = NIL;
4336                                         $$->targetList = $3;
4337                                         $$->selectStmt = NULL;
4338                                 }
4339                         | DEFAULT VALUES
4340                                 {
4341                                         $$ = makeNode(InsertStmt);
4342                                         $$->cols = NIL;
4343                                         $$->targetList = NIL;
4344                                         $$->selectStmt = NULL;
4345                                 }
4346                         | SelectStmt
4347                                 {
4348                                         $$ = makeNode(InsertStmt);
4349                                         $$->cols = NIL;
4350                                         $$->targetList = NIL;
4351                                         $$->selectStmt = $1;
4352                                 }
4353                         | '(' insert_column_list ')' VALUES '(' insert_target_list ')'
4354                                 {
4355                                         $$ = makeNode(InsertStmt);
4356                                         $$->cols = $2;
4357                                         $$->targetList = $6;
4358                                         $$->selectStmt = NULL;
4359                                 }
4360                         | '(' insert_column_list ')' SelectStmt
4361                                 {
4362                                         $$ = makeNode(InsertStmt);
4363                                         $$->cols = $2;
4364                                         $$->targetList = NIL;
4365                                         $$->selectStmt = $4;
4366                                 }
4367                 ;
4368
4369 insert_column_list:
4370                         insert_column_item                                              { $$ = makeList1($1); }
4371                         | insert_column_list ',' insert_column_item
4372                                         { $$ = lappend($1, $3); }
4373                 ;
4374
4375 insert_column_item:
4376                         ColId opt_indirection
4377                                 {
4378                                         ResTarget *n = makeNode(ResTarget);
4379                                         n->name = $1;
4380                                         n->indirection = $2;
4381                                         n->val = NULL;
4382                                         $$ = (Node *)n;
4383                                 }
4384                 ;
4385
4386
4387 /*****************************************************************************
4388  *
4389  *              QUERY:
4390  *                              DELETE STATEMENTS
4391  *
4392  *****************************************************************************/
4393
4394 DeleteStmt: DELETE_P FROM relation_expr where_clause
4395                                 {
4396                                         DeleteStmt *n = makeNode(DeleteStmt);
4397                                         n->relation = $3;
4398                                         n->whereClause = $4;
4399                                         $$ = (Node *)n;
4400                                 }
4401                 ;
4402
4403 LockStmt:       LOCK_P opt_table qualified_name_list opt_lock opt_nowait
4404                                 {
4405                                         LockStmt *n = makeNode(LockStmt);
4406
4407                                         n->relations = $3;
4408                                         n->mode = $4;
4409                                         n->nowait = $5;
4410                                         $$ = (Node *)n;
4411                                 }
4412                 ;
4413
4414 opt_lock:       IN_P lock_type MODE                     { $$ = $2; }
4415                         | /*EMPTY*/                                             { $$ = AccessExclusiveLock; }
4416                 ;
4417
4418 lock_type:      ACCESS SHARE                                    { $$ = AccessShareLock; }
4419                         | ROW SHARE                                             { $$ = RowShareLock; }
4420                         | ROW EXCLUSIVE                                 { $$ = RowExclusiveLock; }
4421                         | SHARE UPDATE EXCLUSIVE                { $$ = ShareUpdateExclusiveLock; }
4422                         | SHARE                                                 { $$ = ShareLock; }
4423                         | SHARE ROW EXCLUSIVE                   { $$ = ShareRowExclusiveLock; }
4424                         | EXCLUSIVE                                             { $$ = ExclusiveLock; }
4425                         | ACCESS EXCLUSIVE                              { $$ = AccessExclusiveLock; }
4426                 ;
4427
4428 opt_nowait:     NOWAIT                  { $$ = TRUE; }
4429                         | /*EMPTY*/                                             { $$ = FALSE; }
4430                 ;
4431
4432
4433 /*****************************************************************************
4434  *
4435  *              QUERY:
4436  *                              UpdateStmt (UPDATE)
4437  *
4438  *****************************************************************************/
4439
4440 UpdateStmt: UPDATE relation_expr
4441                         SET update_target_list
4442                         from_clause
4443                         where_clause
4444                                 {
4445                                         UpdateStmt *n = makeNode(UpdateStmt);
4446                                         n->relation = $2;
4447                                         n->targetList = $4;
4448                                         n->fromClause = $5;
4449                                         n->whereClause = $6;
4450                                         $$ = (Node *)n;
4451                                 }
4452                 ;
4453
4454
4455 /*****************************************************************************
4456  *
4457  *              QUERY:
4458  *                              CURSOR STATEMENTS
4459  *
4460  *****************************************************************************/
4461 DeclareCursorStmt: DECLARE name cursor_options CURSOR opt_hold FOR SelectStmt
4462                                 {
4463                                         DeclareCursorStmt *n = makeNode(DeclareCursorStmt);
4464                                         n->portalname = $2;
4465                                         n->options = $3;
4466                                         n->query = $7;
4467                                         if ($5)
4468                                                 n->options |= CURSOR_OPT_HOLD;
4469                                         $$ = (Node *)n;
4470                                 }
4471                 ;
4472
4473 cursor_options: /*EMPTY*/                                       { $$ = 0; }
4474                         | cursor_options NO SCROLL              { $$ = $1 | CURSOR_OPT_NO_SCROLL; }
4475                         | cursor_options SCROLL                 { $$ = $1 | CURSOR_OPT_SCROLL; }
4476                         | cursor_options BINARY                 { $$ = $1 | CURSOR_OPT_BINARY; }
4477                         | cursor_options INSENSITIVE    { $$ = $1 | CURSOR_OPT_INSENSITIVE; }
4478                 ;
4479
4480 opt_hold: /* EMPTY */                                           { $$ = FALSE; }
4481                         | WITH HOLD                                             { $$ = TRUE; }
4482                         | WITHOUT HOLD                                  { $$ = FALSE; }
4483                 ;
4484
4485 /*****************************************************************************
4486  *
4487  *              QUERY:
4488  *                              SELECT STATEMENTS
4489  *
4490  *****************************************************************************/
4491
4492 /* A complete SELECT statement looks like this.
4493  *
4494  * The rule returns either a single SelectStmt node or a tree of them,
4495  * representing a set-operation tree.
4496  *
4497  * There is an ambiguity when a sub-SELECT is within an a_expr and there
4498  * are excess parentheses: do the parentheses belong to the sub-SELECT or
4499  * to the surrounding a_expr?  We don't really care, but yacc wants to know.
4500  * To resolve the ambiguity, we are careful to define the grammar so that
4501  * the decision is staved off as long as possible: as long as we can keep
4502  * absorbing parentheses into the sub-SELECT, we will do so, and only when
4503  * it's no longer possible to do that will we decide that parens belong to
4504  * the expression.      For example, in "SELECT (((SELECT 2)) + 3)" the extra
4505  * parentheses are treated as part of the sub-select.  The necessity of doing
4506  * it that way is shown by "SELECT (((SELECT 2)) UNION SELECT 2)".      Had we
4507  * parsed "((SELECT 2))" as an a_expr, it'd be too late to go back to the
4508  * SELECT viewpoint when we see the UNION.
4509  *
4510  * This approach is implemented by defining a nonterminal select_with_parens,
4511  * which represents a SELECT with at least one outer layer of parentheses,
4512  * and being careful to use select_with_parens, never '(' SelectStmt ')',
4513  * in the expression grammar.  We will then have shift-reduce conflicts
4514  * which we can resolve in favor of always treating '(' <select> ')' as
4515  * a select_with_parens.  To resolve the conflicts, the productions that
4516  * conflict with the select_with_parens productions are manually given
4517  * precedences lower than the precedence of ')', thereby ensuring that we
4518  * shift ')' (and then reduce to select_with_parens) rather than trying to
4519  * reduce the inner <select> nonterminal to something else.  We use UMINUS
4520  * precedence for this, which is a fairly arbitrary choice.
4521  *
4522  * To be able to define select_with_parens itself without ambiguity, we need
4523  * a nonterminal select_no_parens that represents a SELECT structure with no
4524  * outermost parentheses.  This is a little bit tedious, but it works.
4525  *
4526  * In non-expression contexts, we use SelectStmt which can represent a SELECT
4527  * with or without outer parentheses.
4528  */
4529
4530 SelectStmt: select_no_parens                    %prec UMINUS
4531                         | select_with_parens            %prec UMINUS
4532                 ;
4533
4534 select_with_parens:
4535                         '(' select_no_parens ')'                                { $$ = $2; }
4536                         | '(' select_with_parens ')'                    { $$ = $2; }
4537                 ;
4538
4539 /*
4540  *      FOR UPDATE may be before or after LIMIT/OFFSET.
4541  *      In <=7.2.X, LIMIT/OFFSET had to be after FOR UPDATE
4542  *      We now support both orderings, but prefer LIMIT/OFFSET before FOR UPDATE
4543  *      2002-08-28 bjm
4544  */
4545 select_no_parens:
4546                         simple_select                                           { $$ = $1; }
4547                         | select_clause sort_clause
4548                                 {
4549                                         insertSelectOptions((SelectStmt *) $1, $2, NIL,
4550                                                                                 NULL, NULL);
4551                                         $$ = $1;
4552                                 }
4553                         | select_clause opt_sort_clause for_update_clause opt_select_limit
4554                                 {
4555                                         insertSelectOptions((SelectStmt *) $1, $2, $3,
4556                                                                                 nth(0, $4), nth(1, $4));
4557                                         $$ = $1;
4558                                 }
4559                         | select_clause opt_sort_clause select_limit opt_for_update_clause
4560                                 {
4561                                         insertSelectOptions((SelectStmt *) $1, $2, $4,
4562                                                                                 nth(0, $3), nth(1, $3));
4563                                         $$ = $1;
4564                                 }
4565                 ;
4566
4567 select_clause:
4568                         simple_select                                                   { $$ = $1; }
4569                         | select_with_parens                                    { $$ = $1; }
4570                 ;
4571
4572 /*
4573  * This rule parses SELECT statements that can appear within set operations,
4574  * including UNION, INTERSECT and EXCEPT.  '(' and ')' can be used to specify
4575  * the ordering of the set operations.  Without '(' and ')' we want the
4576  * operations to be ordered per the precedence specs at the head of this file.
4577  *
4578  * As with select_no_parens, simple_select cannot have outer parentheses,
4579  * but can have parenthesized subclauses.
4580  *
4581  * Note that sort clauses cannot be included at this level --- SQL92 requires
4582  *              SELECT foo UNION SELECT bar ORDER BY baz
4583  * to be parsed as
4584  *              (SELECT foo UNION SELECT bar) ORDER BY baz
4585  * not
4586  *              SELECT foo UNION (SELECT bar ORDER BY baz)
4587  * Likewise FOR UPDATE and LIMIT.  Therefore, those clauses are described
4588  * as part of the select_no_parens production, not simple_select.
4589  * This does not limit functionality, because you can reintroduce sort and
4590  * limit clauses inside parentheses.
4591  *
4592  * NOTE: only the leftmost component SelectStmt should have INTO.
4593  * However, this is not checked by the grammar; parse analysis must check it.
4594  */
4595 simple_select:
4596                         SELECT opt_distinct target_list
4597                         into_clause from_clause where_clause
4598                         group_clause having_clause
4599                                 {
4600                                         SelectStmt *n = makeNode(SelectStmt);
4601                                         n->distinctClause = $2;
4602                                         n->targetList = $3;
4603                                         n->into = $4;
4604                                         n->intoColNames = NIL;
4605                                         n->intoHasOids = DEFAULT_OIDS;
4606                                         n->fromClause = $5;
4607                                         n->whereClause = $6;
4608                                         n->groupClause = $7;
4609                                         n->havingClause = $8;
4610                                         $$ = (Node *)n;
4611                                 }
4612                         | select_clause UNION opt_all select_clause
4613                                 {
4614                                         $$ = makeSetOp(SETOP_UNION, $3, $1, $4);
4615                                 }
4616                         | select_clause INTERSECT opt_all select_clause
4617                                 {
4618                                         $$ = makeSetOp(SETOP_INTERSECT, $3, $1, $4);
4619                                 }
4620                         | select_clause EXCEPT opt_all select_clause
4621                                 {
4622                                         $$ = makeSetOp(SETOP_EXCEPT, $3, $1, $4);
4623                                 }
4624                 ;
4625
4626 into_clause:
4627                         INTO OptTempTableName                                   { $$ = $2; }
4628                         | /*EMPTY*/                                                             { $$ = NULL; }
4629                 ;
4630
4631 /*
4632  * Redundancy here is needed to avoid shift/reduce conflicts,
4633  * since TEMP is not a reserved word.  See also OptTemp.
4634  */
4635 OptTempTableName:
4636                         TEMPORARY opt_table qualified_name
4637                                 {
4638                                         $$ = $3;
4639                                         $$->istemp = true;
4640                                 }
4641                         | TEMP opt_table qualified_name
4642                                 {
4643                                         $$ = $3;
4644                                         $$->istemp = true;
4645                                 }
4646                         | LOCAL TEMPORARY opt_table qualified_name
4647                                 {
4648                                         $$ = $4;
4649                                         $$->istemp = true;
4650                                 }
4651                         | LOCAL TEMP opt_table qualified_name
4652                                 {
4653                                         $$ = $4;
4654                                         $$->istemp = true;
4655                                 }
4656                         | GLOBAL TEMPORARY opt_table qualified_name
4657                                 {
4658                                         $$ = $4;
4659                                         $$->istemp = true;
4660                                 }
4661                         | GLOBAL TEMP opt_table qualified_name
4662                                 {
4663                                         $$ = $4;
4664                                         $$->istemp = true;
4665                                 }
4666                         | TABLE qualified_name
4667                                 {
4668                                         $$ = $2;
4669                                         $$->istemp = false;
4670                                 }
4671                         | qualified_name
4672                                 {
4673                                         $$ = $1;
4674                                         $$->istemp = false;
4675                                 }
4676                 ;
4677
4678 opt_table:      TABLE                                                                   {}
4679                         | /*EMPTY*/                                                             {}
4680                 ;
4681
4682 opt_all:        ALL                                                                             { $$ = TRUE; }
4683                         | DISTINCT                                                              { $$ = FALSE; }
4684                         | /*EMPTY*/                                                             { $$ = FALSE; }
4685                 ;
4686
4687 /* We use (NIL) as a placeholder to indicate that all target expressions
4688  * should be placed in the DISTINCT list during parsetree analysis.
4689  */
4690 opt_distinct:
4691                         DISTINCT                                                                { $$ = makeList1(NIL); }
4692                         | DISTINCT ON '(' expr_list ')'                 { $$ = $4; }
4693                         | ALL                                                                   { $$ = NIL; }
4694                         | /*EMPTY*/                                                             { $$ = NIL; }
4695                 ;
4696
4697 opt_sort_clause:
4698                         sort_clause                                                             { $$ = $1;}
4699                         | /*EMPTY*/                                                             { $$ = NIL; }
4700                 ;
4701
4702 sort_clause:
4703                         ORDER BY sortby_list                                    { $$ = $3; }
4704                 ;
4705
4706 sortby_list:
4707                         sortby                                                                  { $$ = makeList1($1); }
4708                         | sortby_list ',' sortby                                { $$ = lappend($1, $3); }
4709                 ;
4710
4711 sortby:         a_expr USING qual_all_Op
4712                                 {
4713                                         $$ = makeNode(SortBy);
4714                                         $$->node = $1;
4715                                         $$->sortby_kind = SORTBY_USING;
4716                                         $$->useOp = $3;
4717                                 }
4718                         | a_expr ASC
4719                                 {
4720                                         $$ = makeNode(SortBy);
4721                                         $$->node = $1;
4722                                         $$->sortby_kind = SORTBY_ASC;
4723                                         $$->useOp = NIL;
4724                                 }
4725                         | a_expr DESC
4726                                 {
4727                                         $$ = makeNode(SortBy);
4728                                         $$->node = $1;
4729                                         $$->sortby_kind = SORTBY_DESC;
4730                                         $$->useOp = NIL;
4731                                 }
4732                         | a_expr
4733                                 {
4734                                         $$ = makeNode(SortBy);
4735                                         $$->node = $1;
4736                                         $$->sortby_kind = SORTBY_ASC;   /* default */
4737                                         $$->useOp = NIL;
4738                                 }
4739                 ;
4740
4741
4742 select_limit:
4743                         LIMIT select_limit_value OFFSET select_offset_value
4744                                 { $$ = makeList2($4, $2); }
4745                         | OFFSET select_offset_value LIMIT select_limit_value
4746                                 { $$ = makeList2($2, $4); }
4747                         | LIMIT select_limit_value
4748                                 { $$ = makeList2(NULL, $2); }
4749                         | OFFSET select_offset_value
4750                                 { $$ = makeList2($2, NULL); }
4751                         | LIMIT select_limit_value ',' select_offset_value
4752                                 {
4753                                         /* Disabled because it was too confusing, bjm 2002-02-18 */
4754                                         ereport(ERROR,
4755                                                         (errcode(ERRCODE_SYNTAX_ERROR),
4756                                                          errmsg("LIMIT #,# syntax is not supported"),
4757                                                          errhint("Use separate LIMIT and OFFSET clauses.")));
4758                                 }
4759                 ;
4760
4761 opt_select_limit:
4762                         select_limit                                                    { $$ = $1; }
4763                         | /* EMPTY */
4764                                         { $$ = makeList2(NULL,NULL); }
4765                 ;
4766
4767 select_limit_value:
4768                         a_expr                                                                  { $$ = $1; }
4769                         | ALL
4770                                 {
4771                                         /* LIMIT ALL is represented as a NULL constant */
4772                                         A_Const *n = makeNode(A_Const);
4773                                         n->val.type = T_Null;
4774                                         $$ = (Node *)n;
4775                                 }
4776                 ;
4777
4778 select_offset_value:
4779                         a_expr                                                                  { $$ = $1; }
4780                 ;
4781
4782 /*
4783  *      jimmy bell-style recursive queries aren't supported in the
4784  *      current system.
4785  *
4786  *      ...however, recursive addattr and rename supported.  make special
4787  *      cases for these.
4788  */
4789
4790 group_clause:
4791                         GROUP_P BY expr_list                                    { $$ = $3; }
4792                         | /*EMPTY*/                                                             { $$ = NIL; }
4793                 ;
4794
4795 having_clause:
4796                         HAVING a_expr                                                   { $$ = $2; }
4797                         | /*EMPTY*/                                                             { $$ = NULL; }
4798                 ;
4799
4800 for_update_clause:
4801                         FOR UPDATE update_list                                  { $$ = $3; }
4802                         | FOR READ ONLY                                                 { $$ = NULL; }
4803                 ;
4804
4805 opt_for_update_clause:
4806                         for_update_clause                                               { $$ = $1; }
4807                         | /* EMPTY */                                                   { $$ = NULL; }
4808                 ;
4809
4810 update_list:
4811                         OF name_list                                                    { $$ = $2; }
4812                         | /* EMPTY */                                                   { $$ = makeList1(NULL); }
4813                 ;
4814
4815 /*****************************************************************************
4816  *
4817  *      clauses common to all Optimizable Stmts:
4818  *              from_clause             - allow list of both JOIN expressions and table names
4819  *              where_clause    - qualifications for joins or restrictions
4820  *
4821  *****************************************************************************/
4822
4823 from_clause:
4824                         FROM from_list                                                  { $$ = $2; }
4825                         | /*EMPTY*/                                                             { $$ = NIL; }
4826                 ;
4827
4828 from_list:
4829                         table_ref                                                               { $$ = makeList1($1); }
4830                         | from_list ',' table_ref                               { $$ = lappend($1, $3); }
4831                 ;
4832
4833 /*
4834  * table_ref is where an alias clause can be attached.  Note we cannot make
4835  * alias_clause have an empty production because that causes parse conflicts
4836  * between table_ref := '(' joined_table ')' alias_clause
4837  * and joined_table := '(' joined_table ')'.  So, we must have the
4838  * redundant-looking productions here instead.
4839  */
4840 table_ref:      relation_expr
4841                                 {
4842                                         $$ = (Node *) $1;
4843                                 }
4844                         | relation_expr alias_clause
4845                                 {
4846                                         $1->alias = $2;
4847                                         $$ = (Node *) $1;
4848                                 }
4849                         | func_table
4850                                 {
4851                                         RangeFunction *n = makeNode(RangeFunction);
4852                                         n->funccallnode = $1;
4853                                         n->coldeflist = NIL;
4854                                         $$ = (Node *) n;
4855                                 }
4856                         | func_table alias_clause
4857                                 {
4858                                         RangeFunction *n = makeNode(RangeFunction);
4859                                         n->funccallnode = $1;
4860                                         n->alias = $2;
4861                                         n->coldeflist = NIL;
4862                                         $$ = (Node *) n;
4863                                 }
4864                         | func_table AS '(' TableFuncElementList ')'
4865                                 {
4866                                         RangeFunction *n = makeNode(RangeFunction);
4867                                         n->funccallnode = $1;
4868                                         n->coldeflist = $4;
4869                                         $$ = (Node *) n;
4870                                 }
4871                         | func_table AS ColId '(' TableFuncElementList ')'
4872                                 {
4873                                         RangeFunction *n = makeNode(RangeFunction);
4874                                         Alias *a = makeNode(Alias);
4875                                         n->funccallnode = $1;
4876                                         a->aliasname = $3;
4877                                         n->alias = a;
4878                                         n->coldeflist = $5;
4879                                         $$ = (Node *) n;
4880                                 }
4881                         | func_table ColId '(' TableFuncElementList ')'
4882                                 {
4883                                         RangeFunction *n = makeNode(RangeFunction);
4884                                         Alias *a = makeNode(Alias);
4885                                         n->funccallnode = $1;
4886                                         a->aliasname = $2;
4887                                         n->alias = a;
4888                                         n->coldeflist = $4;
4889                                         $$ = (Node *) n;
4890                                 }
4891                         | select_with_parens
4892                                 {
4893                                         /*
4894                                          * The SQL spec does not permit a subselect
4895                                          * (<derived_table>) without an alias clause,
4896                                          * so we don't either.  This avoids the problem
4897                                          * of needing to invent a unique refname for it.
4898                                          * That could be surmounted if there's sufficient
4899                                          * popular demand, but for now let's just implement
4900                                          * the spec and see if anyone complains.
4901                                          * However, it does seem like a good idea to emit
4902                                          * an error message that's better than "syntax error".
4903                                          */
4904                                         ereport(ERROR,
4905                                                         (errcode(ERRCODE_SYNTAX_ERROR),
4906                                                          errmsg("subquery in FROM must have an alias"),
4907                                                          errhint("For example, FROM (SELECT ...) [AS] foo.")));
4908                                         $$ = NULL;
4909                                 }
4910                         | select_with_parens alias_clause
4911                                 {
4912                                         RangeSubselect *n = makeNode(RangeSubselect);
4913                                         n->subquery = $1;
4914                                         n->alias = $2;
4915                                         $$ = (Node *) n;
4916                                 }
4917                         | joined_table
4918                                 {
4919                                         $$ = (Node *) $1;
4920                                 }
4921                         | '(' joined_table ')' alias_clause
4922                                 {
4923                                         $2->alias = $4;
4924                                         $$ = (Node *) $2;
4925                                 }
4926                 ;
4927
4928
4929 /*
4930  * It may seem silly to separate joined_table from table_ref, but there is
4931  * method in SQL92's madness: if you don't do it this way you get reduce-
4932  * reduce conflicts, because it's not clear to the parser generator whether
4933  * to expect alias_clause after ')' or not.  For the same reason we must
4934  * treat 'JOIN' and 'join_type JOIN' separately, rather than allowing
4935  * join_type to expand to empty; if we try it, the parser generator can't
4936  * figure out when to reduce an empty join_type right after table_ref.
4937  *
4938  * Note that a CROSS JOIN is the same as an unqualified
4939  * INNER JOIN, and an INNER JOIN/ON has the same shape
4940  * but a qualification expression to limit membership.
4941  * A NATURAL JOIN implicitly matches column names between
4942  * tables and the shape is determined by which columns are
4943  * in common. We'll collect columns during the later transformations.
4944  */
4945
4946 joined_table:
4947                         '(' joined_table ')'
4948                                 {
4949                                         $$ = $2;
4950                                 }
4951                         | table_ref CROSS JOIN table_ref
4952                                 {
4953                                         /* CROSS JOIN is same as unqualified inner join */
4954                                         JoinExpr *n = makeNode(JoinExpr);
4955                                         n->jointype = JOIN_INNER;
4956                                         n->isNatural = FALSE;
4957                                         n->larg = $1;
4958                                         n->rarg = $4;
4959                                         n->using = NIL;
4960                                         n->quals = NULL;
4961                                         $$ = n;
4962                                 }
4963                         | table_ref UNIONJOIN table_ref
4964                                 {
4965                                         /* UNION JOIN is made into 1 token to avoid shift/reduce
4966                                          * conflict against regular UNION keyword.
4967                                          */
4968                                         JoinExpr *n = makeNode(JoinExpr);
4969                                         n->jointype = JOIN_UNION;
4970                                         n->isNatural = FALSE;
4971                                         n->larg = $1;
4972                                         n->rarg = $3;
4973                                         n->using = NIL;
4974                                         n->quals = NULL;
4975                                         $$ = n;
4976                                 }
4977                         | table_ref join_type JOIN table_ref join_qual
4978                                 {
4979                                         JoinExpr *n = makeNode(JoinExpr);
4980                                         n->jointype = $2;
4981                                         n->isNatural = FALSE;
4982                                         n->larg = $1;
4983                                         n->rarg = $4;
4984                                         if ($5 != NULL && IsA($5, List))
4985                                                 n->using = (List *) $5; /* USING clause */
4986                                         else
4987                                                 n->quals = $5; /* ON clause */
4988                                         $$ = n;
4989                                 }
4990                         | table_ref JOIN table_ref join_qual
4991                                 {
4992                                         /* letting join_type reduce to empty doesn't work */
4993                                         JoinExpr *n = makeNode(JoinExpr);
4994                                         n->jointype = JOIN_INNER;
4995                                         n->isNatural = FALSE;
4996                                         n->larg = $1;
4997                                         n->rarg = $3;
4998                                         if ($4 != NULL && IsA($4, List))
4999                                                 n->using = (List *) $4; /* USING clause */
5000                                         else
5001                                                 n->quals = $4; /* ON clause */
5002                                         $$ = n;
5003                                 }
5004                         | table_ref NATURAL join_type JOIN table_ref
5005                                 {
5006                                         JoinExpr *n = makeNode(JoinExpr);
5007                                         n->jointype = $3;
5008                                         n->isNatural = TRUE;
5009                                         n->larg = $1;
5010                                         n->rarg = $5;
5011                                         n->using = NIL; /* figure out which columns later... */
5012                                         n->quals = NULL; /* fill later */
5013                                         $$ = n;
5014                                 }
5015                         | table_ref NATURAL JOIN table_ref
5016                                 {
5017                                         /* letting join_type reduce to empty doesn't work */
5018                                         JoinExpr *n = makeNode(JoinExpr);
5019                                         n->jointype = JOIN_INNER;
5020                                         n->isNatural = TRUE;
5021                                         n->larg = $1;
5022                                         n->rarg = $4;
5023                                         n->using = NIL; /* figure out which columns later... */
5024                                         n->quals = NULL; /* fill later */
5025                                         $$ = n;
5026                                 }
5027                 ;
5028
5029 alias_clause:
5030                         AS ColId '(' name_list ')'
5031                                 {
5032                                         $$ = makeNode(Alias);
5033                                         $$->aliasname = $2;
5034                                         $$->colnames = $4;
5035                                 }
5036                         | AS ColId
5037                                 {
5038                                         $$ = makeNode(Alias);
5039                                         $$->aliasname = $2;
5040                                 }
5041                         | ColId '(' name_list ')'
5042                                 {
5043                                         $$ = makeNode(Alias);
5044                                         $$->aliasname = $1;
5045                                         $$->colnames = $3;
5046                                 }
5047                         | ColId
5048                                 {
5049                                         $$ = makeNode(Alias);
5050                                         $$->aliasname = $1;
5051                                 }
5052                 ;
5053
5054 join_type:      FULL join_outer                                                 { $$ = JOIN_FULL; }
5055                         | LEFT join_outer                                               { $$ = JOIN_LEFT; }
5056                         | RIGHT join_outer                                              { $$ = JOIN_RIGHT; }
5057                         | INNER_P                                                               { $$ = JOIN_INNER; }
5058                 ;
5059
5060 /* OUTER is just noise... */
5061 join_outer: OUTER_P                                                                     { $$ = NULL; }
5062                         | /*EMPTY*/                                                             { $$ = NULL; }
5063                 ;
5064
5065 /* JOIN qualification clauses
5066  * Possibilities are:
5067  *      USING ( column list ) allows only unqualified column names,
5068  *                                                which must match between tables.
5069  *      ON expr allows more general qualifications.
5070  *
5071  * We return USING as a List node, while an ON-expr will not be a List.
5072  */
5073
5074 join_qual:      USING '(' name_list ')'                                 { $$ = (Node *) $3; }
5075                         | ON a_expr                                                             { $$ = $2; }
5076                 ;
5077
5078
5079 relation_expr:
5080                         qualified_name
5081                                 {
5082                                         /* default inheritance */
5083                                         $$ = $1;
5084                                         $$->inhOpt = INH_DEFAULT;
5085                                         $$->alias = NULL;
5086                                 }
5087                         | qualified_name '*'
5088                                 {
5089                                         /* inheritance query */
5090                                         $$ = $1;
5091                                         $$->inhOpt = INH_YES;
5092                                         $$->alias = NULL;
5093                                 }
5094                         | ONLY qualified_name
5095                                 {
5096                                         /* no inheritance */
5097                                         $$ = $2;
5098                                         $$->inhOpt = INH_NO;
5099                                         $$->alias = NULL;
5100                                 }
5101                         | ONLY '(' qualified_name ')'
5102                                 {
5103                                         /* no inheritance, SQL99-style syntax */
5104                                         $$ = $3;
5105                                         $$->inhOpt = INH_NO;
5106                                         $$->alias = NULL;
5107                                 }
5108                 ;
5109
5110
5111 func_table: func_name '(' ')'
5112                                 {
5113                                         FuncCall *n = makeNode(FuncCall);
5114                                         n->funcname = $1;
5115                                         n->args = NIL;
5116                                         n->agg_star = FALSE;
5117                                         n->agg_distinct = FALSE;
5118                                         $$ = (Node *)n;
5119                                 }
5120                         | func_name '(' expr_list ')'
5121                                 {
5122                                         FuncCall *n = makeNode(FuncCall);
5123                                         n->funcname = $1;
5124                                         n->args = $3;
5125                                         n->agg_star = FALSE;
5126                                         n->agg_distinct = FALSE;
5127                                         $$ = (Node *)n;
5128                                 }
5129                 ;
5130
5131
5132 where_clause:
5133                         WHERE a_expr                                                    { $$ = $2; }
5134                         | /*EMPTY*/                                                             { $$ = NULL; }
5135                 ;
5136
5137
5138 TableFuncElementList:
5139                         TableFuncElement
5140                                 {
5141                                         $$ = makeList1($1);
5142                                 }
5143                         | TableFuncElementList ',' TableFuncElement
5144                                 {
5145                                         $$ = lappend($1, $3);
5146                                 }
5147                 ;
5148
5149 TableFuncElement:       ColId Typename
5150                                 {
5151                                         ColumnDef *n = makeNode(ColumnDef);
5152                                         n->colname = $1;
5153                                         n->typename = $2;
5154                                         n->constraints = NIL;
5155                                         n->is_local = true;
5156                                         $$ = (Node *)n;
5157                                 }
5158                 ;
5159
5160 /*****************************************************************************
5161  *
5162  *      Type syntax
5163  *              SQL92 introduces a large amount of type-specific syntax.
5164  *              Define individual clauses to handle these cases, and use
5165  *               the generic case to handle regular type-extensible Postgres syntax.
5166  *              - thomas 1997-10-10
5167  *
5168  *****************************************************************************/
5169
5170 Typename:       SimpleTypename opt_array_bounds
5171                                 {
5172                                         $$ = $1;
5173                                         $$->arrayBounds = $2;
5174                                 }
5175                         | SETOF SimpleTypename opt_array_bounds
5176                                 {
5177                                         $$ = $2;
5178                                         $$->arrayBounds = $3;
5179                                         $$->setof = TRUE;
5180                                 }
5181                         | SimpleTypename ARRAY '[' Iconst ']'
5182                                 {
5183                                         /* SQL99's redundant syntax */
5184                                         $$ = $1;
5185                                         $$->arrayBounds = makeList1(makeInteger($4));
5186                                 }
5187                         | SETOF SimpleTypename ARRAY '[' Iconst ']'
5188                                 {
5189                                         /* SQL99's redundant syntax */
5190                                         $$ = $2;
5191                                         $$->arrayBounds = makeList1(makeInteger($5));
5192                                         $$->setof = TRUE;
5193                                 }
5194                 ;
5195
5196 opt_array_bounds:
5197                         opt_array_bounds '[' ']'
5198                                         {  $$ = lappend($1, makeInteger(-1)); }
5199                         | opt_array_bounds '[' Iconst ']'
5200                                         {  $$ = lappend($1, makeInteger($3)); }
5201                         | /*EMPTY*/
5202                                         {  $$ = NIL; }
5203                 ;
5204
5205 /*
5206  * XXX ideally, the production for a qualified typename should be ColId attrs
5207  * (there's no obvious reason why the first name should need to be restricted)
5208  * and should be an alternative of GenericType (so that it can be used to
5209  * specify a type for a literal in AExprConst).  However doing either causes
5210  * reduce/reduce conflicts that I haven't been able to find a workaround
5211  * for.  FIXME later.
5212  */
5213 SimpleTypename:
5214                         GenericType                                                             { $$ = $1; }
5215                         | Numeric                                                               { $$ = $1; }
5216                         | Bit                                                                   { $$ = $1; }
5217                         | Character                                                             { $$ = $1; }
5218                         | ConstDatetime                                                 { $$ = $1; }
5219                         | ConstInterval opt_interval
5220                                 {
5221                                         $$ = $1;
5222                                         if ($2 != INTERVAL_FULL_RANGE)
5223                                                 $$->typmod = INTERVAL_TYPMOD(INTERVAL_FULL_PRECISION, $2);
5224                                 }
5225                         | ConstInterval '(' Iconst ')' opt_interval
5226                                 {
5227                                         $$ = $1;
5228                                         if ($3 < 0)
5229                                                 ereport(ERROR,
5230                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5231                                                                  errmsg("INTERVAL(%d) precision must not be negative",
5232                                                                                 $3)));
5233                                         if ($3 > MAX_INTERVAL_PRECISION)
5234                                         {
5235                                                 ereport(WARNING,
5236                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5237                                                                  errmsg("INTERVAL(%d) precision reduced to maximum allowed, %d",
5238                                                                                 $3, MAX_INTERVAL_PRECISION)));
5239                                                 $3 = MAX_INTERVAL_PRECISION;
5240                                         }
5241                                         $$->typmod = INTERVAL_TYPMOD($3, $5);
5242                                 }
5243                         | type_name attrs
5244                                 {
5245                                         $$ = makeNode(TypeName);
5246                                         $$->names = lcons(makeString($1), $2);
5247                                         $$->typmod = -1;
5248                                 }
5249                 ;
5250
5251 /* We have a separate ConstTypename to allow defaulting fixed-length
5252  * types such as CHAR() and BIT() to an unspecified length.
5253  * SQL9x requires that these default to a length of one, but this
5254  * makes no sense for constructs like CHAR 'hi' and BIT '0101',
5255  * where there is an obvious better choice to make.
5256  * Note that ConstInterval is not included here since it must
5257  * be pushed up higher in the rules to accomodate the postfix
5258  * options (e.g. INTERVAL '1' YEAR).
5259  */
5260 ConstTypename:
5261                         GenericType                                                             { $$ = $1; }
5262                         | Numeric                                                               { $$ = $1; }
5263                         | ConstBit                                                              { $$ = $1; }
5264                         | ConstCharacter                                                { $$ = $1; }
5265                         | ConstDatetime                                                 { $$ = $1; }
5266                 ;
5267
5268 GenericType:
5269                         type_name
5270                                 {
5271                                         $$ = makeTypeName($1);
5272                                 }
5273                 ;
5274
5275 /* SQL92 numeric data types
5276  * Check FLOAT() precision limits assuming IEEE floating types.
5277  * - thomas 1997-09-18
5278  * Provide real DECIMAL() and NUMERIC() implementations now - Jan 1998-12-30
5279  */
5280 Numeric:        INT_P
5281                                 {
5282                                         $$ = SystemTypeName("int4");
5283                                 }
5284                         | INTEGER
5285                                 {
5286                                         $$ = SystemTypeName("int4");
5287                                 }
5288                         | SMALLINT
5289                                 {
5290                                         $$ = SystemTypeName("int2");
5291                                 }
5292                         | BIGINT
5293                                 {
5294                                         $$ = SystemTypeName("int8");
5295                                 }
5296                         | REAL
5297                                 {
5298                                         $$ = SystemTypeName("float4");
5299                                 }
5300                         | FLOAT_P opt_float
5301                                 {
5302                                         $$ = $2;
5303                                 }
5304                         | DOUBLE_P PRECISION
5305                                 {
5306                                         $$ = SystemTypeName("float8");
5307                                 }
5308                         | DECIMAL_P opt_decimal
5309                                 {
5310                                         $$ = SystemTypeName("numeric");
5311                                         $$->typmod = $2;
5312                                 }
5313                         | DEC opt_decimal
5314                                 {
5315                                         $$ = SystemTypeName("numeric");
5316                                         $$->typmod = $2;
5317                                 }
5318                         | NUMERIC opt_numeric
5319                                 {
5320                                         $$ = SystemTypeName("numeric");
5321                                         $$->typmod = $2;
5322                                 }
5323                         | BOOLEAN_P
5324                                 {
5325                                         $$ = SystemTypeName("bool");
5326                                 }
5327                 ;
5328
5329 opt_float:      '(' Iconst ')'
5330                                 {
5331                                         if ($2 < 1)
5332                                                 ereport(ERROR,
5333                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5334                                                                  errmsg("precision for type float must be at least 1 bit")));
5335                                         else if ($2 <= 24)
5336                                                 $$ = SystemTypeName("float4");
5337                                         else if ($2 <= 53)
5338                                                 $$ = SystemTypeName("float8");
5339                                         else
5340                                                 ereport(ERROR,
5341                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5342                                                                  errmsg("precision for type float must be less than 54 bits")));
5343                                 }
5344                         | /*EMPTY*/
5345                                 {
5346                                         $$ = SystemTypeName("float8");
5347                                 }
5348                 ;
5349
5350 opt_numeric:
5351                         '(' Iconst ',' Iconst ')'
5352                                 {
5353                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
5354                                                 ereport(ERROR,
5355                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5356                                                                  errmsg("NUMERIC precision %d must be between 1 and %d",
5357                                                                                 $2, NUMERIC_MAX_PRECISION)));
5358                                         if ($4 < 0 || $4 > $2)
5359                                                 ereport(ERROR,
5360                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5361                                                                  errmsg("NUMERIC scale %d must be between 0 and precision %d",
5362                                                                                 $4, $2)));
5363
5364                                         $$ = (($2 << 16) | $4) + VARHDRSZ;
5365                                 }
5366                         | '(' Iconst ')'
5367                                 {
5368                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
5369                                                 ereport(ERROR,
5370                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5371                                                                  errmsg("NUMERIC precision %d must be between 1 and %d",
5372                                                                                 $2, NUMERIC_MAX_PRECISION)));
5373
5374                                         $$ = ($2 << 16) + VARHDRSZ;
5375                                 }
5376                         | /*EMPTY*/
5377                                 {
5378                                         /* Insert "-1" meaning "no limit" */
5379                                         $$ = -1;
5380                                 }
5381                 ;
5382
5383 opt_decimal:
5384                         '(' Iconst ',' Iconst ')'
5385                                 {
5386                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
5387                                                 ereport(ERROR,
5388                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5389                                                                  errmsg("DECIMAL precision %d must be between 1 and %d",
5390                                                                                 $2, NUMERIC_MAX_PRECISION)));
5391                                         if ($4 < 0 || $4 > $2)
5392                                                 ereport(ERROR,
5393                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5394                                                                  errmsg("DECIMAL scale %d must be between 0 and precision %d",
5395                                                                                 $4, $2)));
5396
5397                                         $$ = (($2 << 16) | $4) + VARHDRSZ;
5398                                 }
5399                         | '(' Iconst ')'
5400                                 {
5401                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
5402                                                 ereport(ERROR,
5403                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5404                                                                  errmsg("DECIMAL precision %d must be between 1 and %d",
5405                                                                                 $2, NUMERIC_MAX_PRECISION)));
5406
5407                                         $$ = ($2 << 16) + VARHDRSZ;
5408                                 }
5409                         | /*EMPTY*/
5410                                 {
5411                                         /* Insert "-1" meaning "no limit" */
5412                                         $$ = -1;
5413                                 }
5414                 ;
5415
5416
5417 /*
5418  * SQL92 bit-field data types
5419  * The following implements BIT() and BIT VARYING().
5420  */
5421 Bit:            BitWithLength
5422                                 {
5423                                         $$ = $1;
5424                                 }
5425                         | BitWithoutLength
5426                                 {
5427                                         $$ = $1;
5428                                 }
5429                 ;
5430
5431 /* ConstBit is like Bit except "BIT" defaults to unspecified length */
5432 /* See notes for ConstCharacter, which addresses same issue for "CHAR" */
5433 ConstBit:       BitWithLength
5434                                 {
5435                                         $$ = $1;
5436                                 }
5437                         | BitWithoutLength
5438                                 {
5439                                         $$->typmod = -1;
5440                                         $$ = $1;
5441                                 }
5442                 ;
5443
5444 BitWithLength:
5445                         BIT opt_varying '(' Iconst ')'
5446                                 {
5447                                         char *typname;
5448
5449                                         typname = $2 ? "varbit" : "bit";
5450                                         $$ = SystemTypeName(typname);
5451                                         if ($4 < 1)
5452                                                 ereport(ERROR,
5453                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5454                                                                  errmsg("length for type %s must be at least 1",
5455                                                                                 typname)));
5456                                         else if ($4 > (MaxAttrSize * BITS_PER_BYTE))
5457                                                 ereport(ERROR,
5458                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5459                                                                  errmsg("length for type %s cannot exceed %d",
5460                                                                                 typname, MaxAttrSize * BITS_PER_BYTE)));
5461                                         $$->typmod = $4;
5462                                 }
5463                 ;
5464
5465 BitWithoutLength:
5466                         BIT opt_varying
5467                                 {
5468                                         /* bit defaults to bit(1), varbit to no limit */
5469                                         if ($2)
5470                                         {
5471                                                 $$ = SystemTypeName("varbit");
5472                                                 $$->typmod = -1;
5473                                         }
5474                                         else
5475                                         {
5476                                                 $$ = SystemTypeName("bit");
5477                                                 $$->typmod = 1;
5478                                         }
5479                                 }
5480                 ;
5481
5482
5483 /*
5484  * SQL92 character data types
5485  * The following implements CHAR() and VARCHAR().
5486  */
5487 Character:  CharacterWithLength
5488                                 {
5489                                         $$ = $1;
5490                                 }
5491                         | CharacterWithoutLength
5492                                 {
5493                                         $$ = $1;
5494                                 }
5495                 ;
5496
5497 ConstCharacter:  CharacterWithLength
5498                                 {
5499                                         $$ = $1;
5500                                 }
5501                         | CharacterWithoutLength
5502                                 {
5503                                         /* Length was not specified so allow to be unrestricted.
5504                                          * This handles problems with fixed-length (bpchar) strings
5505                                          * which in column definitions must default to a length
5506                                          * of one, but should not be constrained if the length
5507                                          * was not specified.
5508                                          */
5509                                         $1->typmod = -1;
5510                                         $$ = $1;
5511                                 }
5512                 ;
5513
5514 CharacterWithLength:  character '(' Iconst ')' opt_charset
5515                                 {
5516                                         if (($5 != NULL) && (strcmp($5, "sql_text") != 0))
5517                                         {
5518                                                 char *type;
5519
5520                                                 type = palloc(strlen($1) + 1 + strlen($5) + 1);
5521                                                 strcpy(type, $1);
5522                                                 strcat(type, "_");
5523                                                 strcat(type, $5);
5524                                                 $1 = type;
5525                                         }
5526
5527                                         $$ = SystemTypeName($1);
5528
5529                                         if ($3 < 1)
5530                                                 ereport(ERROR,
5531                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5532                                                                  errmsg("length for type %s must be at least 1",
5533                                                                                 $1)));
5534                                         else if ($3 > MaxAttrSize)
5535                                                 ereport(ERROR,
5536                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5537                                                                  errmsg("length for type %s cannot exceed %d",
5538                                                                                 $1, MaxAttrSize)));
5539
5540                                         /* we actually implement these like a varlen, so
5541                                          * the first 4 bytes is the length. (the difference
5542                                          * between these and "text" is that we blank-pad and
5543                                          * truncate where necessary)
5544                                          */
5545                                         $$->typmod = VARHDRSZ + $3;
5546                                 }
5547                 ;
5548
5549 CharacterWithoutLength:  character opt_charset
5550                                 {
5551                                         if (($2 != NULL) && (strcmp($2, "sql_text") != 0))
5552                                         {
5553                                                 char *type;
5554
5555                                                 type = palloc(strlen($1) + 1 + strlen($2) + 1);
5556                                                 strcpy(type, $1);
5557                                                 strcat(type, "_");
5558                                                 strcat(type, $2);
5559                                                 $1 = type;
5560                                         }
5561
5562                                         $$ = SystemTypeName($1);
5563
5564                                         /* char defaults to char(1), varchar to no limit */
5565                                         if (strcmp($1, "bpchar") == 0)
5566                                                 $$->typmod = VARHDRSZ + 1;
5567                                         else
5568                                                 $$->typmod = -1;
5569                                 }
5570                 ;
5571
5572 character:      CHARACTER opt_varying
5573                                                                                 { $$ = $2 ? "varchar": "bpchar"; }
5574                         | CHAR_P opt_varying
5575                                                                                 { $$ = $2 ? "varchar": "bpchar"; }
5576                         | VARCHAR
5577                                                                                 { $$ = "varchar"; }
5578                         | NATIONAL CHARACTER opt_varying
5579                                                                                 { $$ = $3 ? "varchar": "bpchar"; }
5580                         | NATIONAL CHAR_P opt_varying
5581                                                                                 { $$ = $3 ? "varchar": "bpchar"; }
5582                         | NCHAR opt_varying
5583                                                                                 { $$ = $2 ? "varchar": "bpchar"; }
5584                 ;
5585
5586 opt_varying:
5587                         VARYING                                                                 { $$ = TRUE; }
5588                         | /*EMPTY*/                                                             { $$ = FALSE; }
5589                 ;
5590
5591 opt_charset:
5592                         CHARACTER SET ColId                                             { $$ = $3; }
5593                         | /*EMPTY*/                                                             { $$ = NULL; }
5594                 ;
5595
5596 ConstDatetime:
5597                         TIMESTAMP '(' Iconst ')' opt_timezone
5598                                 {
5599                                         if ($5)
5600                                                 $$ = SystemTypeName("timestamptz");
5601                                         else
5602                                                 $$ = SystemTypeName("timestamp");
5603                                         /* XXX the timezone field seems to be unused
5604                                          * - thomas 2001-09-06
5605                                          */
5606                                         $$->timezone = $5;
5607                                         if ($3 < 0)
5608                                                 ereport(ERROR,
5609                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5610                                                                  errmsg("TIMESTAMP(%d)%s precision must not be negative",
5611                                                                                 $3, ($5 ? " WITH TIME ZONE": ""))));
5612                                         if ($3 > MAX_TIMESTAMP_PRECISION)
5613                                         {
5614                                                 ereport(WARNING,
5615                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5616                                                                  errmsg("TIMESTAMP(%d)%s precision reduced to maximum allowed, %d",
5617                                                                                 $3, ($5 ? " WITH TIME ZONE": ""),
5618                                                                                 MAX_TIMESTAMP_PRECISION)));
5619                                                 $3 = MAX_TIMESTAMP_PRECISION;
5620                                         }
5621                                         $$->typmod = $3;
5622                                 }
5623                         | TIMESTAMP opt_timezone
5624                                 {
5625                                         if ($2)
5626                                                 $$ = SystemTypeName("timestamptz");
5627                                         else
5628                                                 $$ = SystemTypeName("timestamp");
5629                                         /* XXX the timezone field seems to be unused
5630                                          * - thomas 2001-09-06
5631                                          */
5632                                         $$->timezone = $2;
5633                                         /* SQL99 specified a default precision of six
5634                                          * for schema definitions. But for timestamp
5635                                          * literals we don't want to throw away precision
5636                                          * so leave this as unspecified for now.
5637                                          * Later, we may want a different production
5638                                          * for schemas. - thomas 2001-12-07
5639                                          */
5640                                         $$->typmod = -1;
5641                                 }
5642                         | TIME '(' Iconst ')' opt_timezone
5643                                 {
5644                                         if ($5)
5645                                                 $$ = SystemTypeName("timetz");
5646                                         else
5647                                                 $$ = SystemTypeName("time");
5648                                         if ($3 < 0)
5649                                                 ereport(ERROR,
5650                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5651                                                                  errmsg("TIME(%d)%s precision must not be negative",
5652                                                                                 $3, ($5 ? " WITH TIME ZONE": ""))));
5653                                         if ($3 > MAX_TIME_PRECISION)
5654                                         {
5655                                                 ereport(WARNING,
5656                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5657                                                                  errmsg("TIME(%d)%s precision reduced to maximum allowed, %d",
5658                                                                                 $3, ($5 ? " WITH TIME ZONE": ""),
5659                                                                                 MAX_TIME_PRECISION)));
5660                                                 $3 = MAX_TIME_PRECISION;
5661                                         }
5662                                         $$->typmod = $3;
5663                                 }
5664                         | TIME opt_timezone
5665                                 {
5666                                         if ($2)
5667                                                 $$ = SystemTypeName("timetz");
5668                                         else
5669                                                 $$ = SystemTypeName("time");
5670                                         /* SQL99 specified a default precision of zero.
5671                                          * See comments for timestamp above on why we will
5672                                          * leave this unspecified for now. - thomas 2001-12-07
5673                                          */
5674                                         $$->typmod = -1;
5675                                 }
5676                 ;
5677
5678 ConstInterval:
5679                         INTERVAL                                                                { $$ = SystemTypeName("interval"); }
5680                 ;
5681
5682 opt_timezone:
5683                         WITH TIME ZONE                                                  { $$ = TRUE; }
5684                         | WITHOUT TIME ZONE                                             { $$ = FALSE; }
5685                         | /*EMPTY*/                                                             { $$ = FALSE; }
5686                 ;
5687
5688 opt_interval:
5689                         YEAR_P                                                                  { $$ = INTERVAL_MASK(YEAR); }
5690                         | MONTH_P                                                               { $$ = INTERVAL_MASK(MONTH); }
5691                         | DAY_P                                                                 { $$ = INTERVAL_MASK(DAY); }
5692                         | HOUR_P                                                                { $$ = INTERVAL_MASK(HOUR); }
5693                         | MINUTE_P                                                              { $$ = INTERVAL_MASK(MINUTE); }
5694                         | SECOND_P                                                              { $$ = INTERVAL_MASK(SECOND); }
5695                         | YEAR_P TO MONTH_P
5696                                         { $$ = INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH); }
5697                         | DAY_P TO HOUR_P
5698                                         { $$ = INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR); }
5699                         | DAY_P TO MINUTE_P
5700                                         { $$ = INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)
5701                                                 | INTERVAL_MASK(MINUTE); }
5702                         | DAY_P TO SECOND_P
5703                                         { $$ = INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)
5704                                                 | INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND); }
5705                         | HOUR_P TO MINUTE_P
5706                                         { $$ = INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE); }
5707                         | HOUR_P TO SECOND_P
5708                                         { $$ = INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE)
5709                                                 | INTERVAL_MASK(SECOND); }
5710                         | MINUTE_P TO SECOND_P
5711                                         { $$ = INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND); }
5712                         | /*EMPTY*/                                                             { $$ = INTERVAL_FULL_RANGE; }
5713                 ;
5714
5715
5716 /*****************************************************************************
5717  *
5718  *      expression grammar
5719  *
5720  *****************************************************************************/
5721
5722 /*
5723  * General expressions
5724  * This is the heart of the expression syntax.
5725  *
5726  * We have two expression types: a_expr is the unrestricted kind, and
5727  * b_expr is a subset that must be used in some places to avoid shift/reduce
5728  * conflicts.  For example, we can't do BETWEEN as "BETWEEN a_expr AND a_expr"
5729  * because that use of AND conflicts with AND as a boolean operator.  So,
5730  * b_expr is used in BETWEEN and we remove boolean keywords from b_expr.
5731  *
5732  * Note that '(' a_expr ')' is a b_expr, so an unrestricted expression can
5733  * always be used by surrounding it with parens.
5734  *
5735  * c_expr is all the productions that are common to a_expr and b_expr;
5736  * it's factored out just to eliminate redundant coding.
5737  */
5738 a_expr:         c_expr                                                                  { $$ = $1; }
5739                         | a_expr TYPECAST Typename
5740                                         { $$ = makeTypeCast($1, $3); }
5741                         | a_expr AT TIME ZONE c_expr
5742                                 {
5743                                         FuncCall *n = makeNode(FuncCall);
5744                                         n->funcname = SystemFuncName("timezone");
5745                                         n->args = makeList2($5, $1);
5746                                         n->agg_star = FALSE;
5747                                         n->agg_distinct = FALSE;
5748                                         $$ = (Node *) n;
5749                                 }
5750                 /*
5751                  * These operators must be called out explicitly in order to make use
5752                  * of yacc/bison's automatic operator-precedence handling.  All other
5753                  * operator names are handled by the generic productions using "Op",
5754                  * below; and all those operators will have the same precedence.
5755                  *
5756                  * If you add more explicitly-known operators, be sure to add them
5757                  * also to b_expr and to the MathOp list above.
5758                  */
5759                         | '+' a_expr                                    %prec UMINUS
5760                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2); }
5761                         | '-' a_expr                                    %prec UMINUS
5762                                 { $$ = doNegate($2); }
5763                         | '%' a_expr
5764                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", NULL, $2); }
5765                         | '^' a_expr
5766                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", NULL, $2); }
5767                         | a_expr '%'
5768                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, NULL); }
5769                         | a_expr '^'
5770                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, NULL); }
5771                         | a_expr '+' a_expr
5772                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3); }
5773                         | a_expr '-' a_expr
5774                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3); }
5775                         | a_expr '*' a_expr
5776                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3); }
5777                         | a_expr '/' a_expr
5778                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3); }
5779                         | a_expr '%' a_expr
5780                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3); }
5781                         | a_expr '^' a_expr
5782                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3); }
5783                         | a_expr '<' a_expr
5784                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3); }
5785                         | a_expr '>' a_expr
5786                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3); }
5787                         | a_expr '=' a_expr
5788                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3); }
5789
5790                         | a_expr qual_Op a_expr                         %prec Op
5791                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3); }
5792                         | qual_Op a_expr                                        %prec Op
5793                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2); }
5794                         | a_expr qual_Op                                        %prec POSTFIXOP
5795                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL); }
5796
5797                         | a_expr AND a_expr
5798                                 { $$ = (Node *) makeA_Expr(AEXPR_AND, NIL, $1, $3); }
5799                         | a_expr OR a_expr
5800                                 { $$ = (Node *) makeA_Expr(AEXPR_OR, NIL, $1, $3); }
5801                         | NOT a_expr
5802                                 { $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, $2); }
5803
5804                         | a_expr LIKE a_expr
5805                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, $3); }
5806                         | a_expr LIKE a_expr ESCAPE a_expr
5807                                 {
5808                                         FuncCall *n = makeNode(FuncCall);
5809                                         n->funcname = SystemFuncName("like_escape");
5810                                         n->args = makeList2($3, $5);
5811                                         n->agg_star = FALSE;
5812                                         n->agg_distinct = FALSE;
5813                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", $1, (Node *) n);
5814                                 }
5815                         | a_expr NOT LIKE a_expr
5816                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, $4); }
5817                         | a_expr NOT LIKE a_expr ESCAPE a_expr
5818                                 {
5819                                         FuncCall *n = makeNode(FuncCall);
5820                                         n->funcname = SystemFuncName("like_escape");
5821                                         n->args = makeList2($4, $6);
5822                                         n->agg_star = FALSE;
5823                                         n->agg_distinct = FALSE;
5824                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", $1, (Node *) n);
5825                                 }
5826                         | a_expr ILIKE a_expr
5827                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, $3); }
5828                         | a_expr ILIKE a_expr ESCAPE a_expr
5829                                 {
5830                                         FuncCall *n = makeNode(FuncCall);
5831                                         n->funcname = SystemFuncName("like_escape");
5832                                         n->args = makeList2($3, $5);
5833                                         n->agg_star = FALSE;
5834                                         n->agg_distinct = FALSE;
5835                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", $1, (Node *) n);
5836                                 }
5837                         | a_expr NOT ILIKE a_expr
5838                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, $4); }
5839                         | a_expr NOT ILIKE a_expr ESCAPE a_expr
5840                                 {
5841                                         FuncCall *n = makeNode(FuncCall);
5842                                         n->funcname = SystemFuncName("like_escape");
5843                                         n->args = makeList2($4, $6);
5844                                         n->agg_star = FALSE;
5845                                         n->agg_distinct = FALSE;
5846                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", $1, (Node *) n);
5847                                 }
5848
5849                         | a_expr SIMILAR TO a_expr                              %prec SIMILAR
5850                                 {
5851                                         A_Const *c = makeNode(A_Const);
5852                                         FuncCall *n = makeNode(FuncCall);
5853                                         c->val.type = T_Null;
5854                                         n->funcname = SystemFuncName("similar_escape");
5855                                         n->args = makeList2($4, (Node *) c);
5856                                         n->agg_star = FALSE;
5857                                         n->agg_distinct = FALSE;
5858                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
5859                                 }
5860                         | a_expr SIMILAR TO a_expr ESCAPE a_expr
5861                                 {
5862                                         FuncCall *n = makeNode(FuncCall);
5863                                         n->funcname = SystemFuncName("similar_escape");
5864                                         n->args = makeList2($4, $6);
5865                                         n->agg_star = FALSE;
5866                                         n->agg_distinct = FALSE;
5867                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "~", $1, (Node *) n);
5868                                 }
5869                         | a_expr NOT SIMILAR TO a_expr                  %prec SIMILAR
5870                                 {
5871                                         A_Const *c = makeNode(A_Const);
5872                                         FuncCall *n = makeNode(FuncCall);
5873                                         c->val.type = T_Null;
5874                                         n->funcname = SystemFuncName("similar_escape");
5875                                         n->args = makeList2($5, (Node *) c);
5876                                         n->agg_star = FALSE;
5877                                         n->agg_distinct = FALSE;
5878                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
5879                                 }
5880                         | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
5881                                 {
5882                                         FuncCall *n = makeNode(FuncCall);
5883                                         n->funcname = SystemFuncName("similar_escape");
5884                                         n->args = makeList2($5, $7);
5885                                         n->agg_star = FALSE;
5886                                         n->agg_distinct = FALSE;
5887                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~", $1, (Node *) n);
5888                                 }
5889
5890                         /* NullTest clause
5891                          * Define SQL92-style Null test clause.
5892                          * Allow two forms described in the standard:
5893                          *      a IS NULL
5894                          *      a IS NOT NULL
5895                          * Allow two SQL extensions
5896                          *      a ISNULL
5897                          *      a NOTNULL
5898                          */
5899                         | a_expr ISNULL
5900                                 {
5901                                         if (IsA($1, RowExpr))
5902                                                 $$ = makeRowNullTest(IS_NULL, (RowExpr *) $1);
5903                                         else
5904                                         {
5905                                                 NullTest *n = makeNode(NullTest);
5906                                                 n->arg = (Expr *) $1;
5907                                                 n->nulltesttype = IS_NULL;
5908                                                 $$ = (Node *)n;
5909                                         }
5910                                 }
5911                         | a_expr IS NULL_P
5912                                 {
5913                                         if (IsA($1, RowExpr))
5914                                                 $$ = makeRowNullTest(IS_NULL, (RowExpr *) $1);
5915                                         else
5916                                         {
5917                                                 NullTest *n = makeNode(NullTest);
5918                                                 n->arg = (Expr *) $1;
5919                                                 n->nulltesttype = IS_NULL;
5920                                                 $$ = (Node *)n;
5921                                         }
5922                                 }
5923                         | a_expr NOTNULL
5924                                 {
5925                                         if (IsA($1, RowExpr))
5926                                                 $$ = makeRowNullTest(IS_NOT_NULL, (RowExpr *) $1);
5927                                         else
5928                                         {
5929                                                 NullTest *n = makeNode(NullTest);
5930                                                 n->arg = (Expr *) $1;
5931                                                 n->nulltesttype = IS_NOT_NULL;
5932                                                 $$ = (Node *)n;
5933                                         }
5934                                 }
5935                         | a_expr IS NOT NULL_P
5936                                 {
5937                                         if (IsA($1, RowExpr))
5938                                                 $$ = makeRowNullTest(IS_NOT_NULL, (RowExpr *) $1);
5939                                         else
5940                                         {
5941                                                 NullTest *n = makeNode(NullTest);
5942                                                 n->arg = (Expr *) $1;
5943                                                 n->nulltesttype = IS_NOT_NULL;
5944                                                 $$ = (Node *)n;
5945                                         }
5946                                 }
5947                         | row OVERLAPS row
5948                                 {
5949                                         $$ = (Node *)makeOverlaps($1, $3);
5950                                 }
5951                         | a_expr IS TRUE_P
5952                                 {
5953                                         BooleanTest *b = makeNode(BooleanTest);
5954                                         b->arg = (Expr *) $1;
5955                                         b->booltesttype = IS_TRUE;
5956                                         $$ = (Node *)b;
5957                                 }
5958                         | a_expr IS NOT TRUE_P
5959                                 {
5960                                         BooleanTest *b = makeNode(BooleanTest);
5961                                         b->arg = (Expr *) $1;
5962                                         b->booltesttype = IS_NOT_TRUE;
5963                                         $$ = (Node *)b;
5964                                 }
5965                         | a_expr IS FALSE_P
5966                                 {
5967                                         BooleanTest *b = makeNode(BooleanTest);
5968                                         b->arg = (Expr *) $1;
5969                                         b->booltesttype = IS_FALSE;
5970                                         $$ = (Node *)b;
5971                                 }
5972                         | a_expr IS NOT FALSE_P
5973                                 {
5974                                         BooleanTest *b = makeNode(BooleanTest);
5975                                         b->arg = (Expr *) $1;
5976                                         b->booltesttype = IS_NOT_FALSE;
5977                                         $$ = (Node *)b;
5978                                 }
5979                         | a_expr IS UNKNOWN
5980                                 {
5981                                         BooleanTest *b = makeNode(BooleanTest);
5982                                         b->arg = (Expr *) $1;
5983                                         b->booltesttype = IS_UNKNOWN;
5984                                         $$ = (Node *)b;
5985                                 }
5986                         | a_expr IS NOT UNKNOWN
5987                                 {
5988                                         BooleanTest *b = makeNode(BooleanTest);
5989                                         b->arg = (Expr *) $1;
5990                                         b->booltesttype = IS_NOT_UNKNOWN;
5991                                         $$ = (Node *)b;
5992                                 }
5993                         | a_expr IS DISTINCT FROM a_expr                        %prec IS
5994                                 {
5995                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5);
5996                                 }
5997                         | a_expr IS OF '(' type_list ')'                        %prec IS
5998                                 {
5999                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5);
6000                                 }
6001                         | a_expr IS NOT OF '(' type_list ')'            %prec IS
6002                                 {
6003                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "!=", $1, (Node *) $6);
6004                                 }
6005                         | a_expr BETWEEN b_expr AND b_expr                      %prec BETWEEN
6006                                 {
6007                                         $$ = (Node *) makeA_Expr(AEXPR_AND, NIL,
6008                                                 (Node *) makeSimpleA_Expr(AEXPR_OP, ">=", $1, $3),
6009                                                 (Node *) makeSimpleA_Expr(AEXPR_OP, "<=", $1, $5));
6010                                 }
6011                         | a_expr NOT BETWEEN b_expr AND b_expr          %prec BETWEEN
6012                                 {
6013                                         $$ = (Node *) makeA_Expr(AEXPR_OR, NIL,
6014                                                 (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $4),
6015                                                 (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $6));
6016                                 }
6017                         | a_expr IN_P in_expr
6018                                 {
6019                                         /* in_expr returns a SubLink or a list of a_exprs */
6020                                         if (IsA($3, SubLink))
6021                                         {
6022                                                         SubLink *n = (SubLink *)$3;
6023                                                         n->subLinkType = ANY_SUBLINK;
6024                                                         if (IsA($1, RowExpr))
6025                                                                 n->lefthand = ((RowExpr *) $1)->args;
6026                                                         else
6027                                                                 n->lefthand = makeList1($1);
6028                                                         n->operName = makeList1(makeString("="));
6029                                                         $$ = (Node *)n;
6030                                         }
6031                                         else
6032                                         {
6033                                                 Node *n = NULL;
6034                                                 ListCell *l;
6035                                                 foreach(l, (List *) $3)
6036                                                 {
6037                                                         Node *cmp;
6038                                                         cmp = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, lfirst(l));
6039                                                         if (n == NULL)
6040                                                                 n = cmp;
6041                                                         else
6042                                                                 n = (Node *) makeA_Expr(AEXPR_OR, NIL, n, cmp);
6043                                                 }
6044                                                 $$ = n;
6045                                         }
6046                                 }
6047                         | a_expr NOT IN_P in_expr
6048                                 {
6049                                         /* in_expr returns a SubLink or a list of a_exprs */
6050                                         if (IsA($4, SubLink))
6051                                         {
6052                                                 /* Make an IN node */
6053                                                 SubLink *n = (SubLink *)$4;
6054                                                 n->subLinkType = ANY_SUBLINK;
6055                                                 if (IsA($1, RowExpr))
6056                                                         n->lefthand = ((RowExpr *) $1)->args;
6057                                                 else
6058                                                         n->lefthand = makeList1($1);
6059                                                 n->operName = makeList1(makeString("="));
6060                                                 /* Stick a NOT on top */
6061                                                 $$ = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (Node *) n);
6062                                         }
6063                                         else
6064                                         {
6065                                                 Node *n = NULL;
6066                                                 ListCell *l;
6067                                                 foreach(l, (List *) $4)
6068                                                 {
6069                                                         Node *cmp;
6070                                                         cmp = (Node *) makeSimpleA_Expr(AEXPR_OP, "<>", $1, lfirst(l));
6071                                                         if (n == NULL)
6072                                                                 n = cmp;
6073                                                         else
6074                                                                 n = (Node *) makeA_Expr(AEXPR_AND, NIL, n, cmp);
6075                                                 }
6076                                                 $$ = n;
6077                                         }
6078                                 }
6079                         | a_expr subquery_Op sub_type select_with_parens %prec Op
6080                                 {
6081                                         SubLink *n = makeNode(SubLink);
6082                                         n->subLinkType = $3;
6083                                         if (IsA($1, RowExpr))
6084                                                 n->lefthand = ((RowExpr *) $1)->args;
6085                                         else
6086                                                 n->lefthand = makeList1($1);
6087                                         n->operName = $2;
6088                                         n->subselect = $4;
6089                                         $$ = (Node *)n;
6090                                 }
6091                         | a_expr subquery_Op sub_type '(' a_expr ')' %prec Op
6092                                 {
6093                                         if ($3 == ANY_SUBLINK)
6094                                                 $$ = (Node *) makeA_Expr(AEXPR_OP_ANY, $2, $1, $5);
6095                                         else
6096                                                 $$ = (Node *) makeA_Expr(AEXPR_OP_ALL, $2, $1, $5);
6097                                 }
6098                         | UNIQUE select_with_parens %prec Op
6099                                 {
6100                                         /* Not sure how to get rid of the parentheses
6101                                          * but there are lots of shift/reduce errors without them.
6102                                          *
6103                                          * Should be able to implement this by plopping the entire
6104                                          * select into a node, then transforming the target expressions
6105                                          * from whatever they are into count(*), and testing the
6106                                          * entire result equal to one.
6107                                          * But, will probably implement a separate node in the executor.
6108                                          */
6109                                         ereport(ERROR,
6110                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
6111                                                          errmsg("UNIQUE predicate is not yet implemented")));
6112                                 }
6113                 ;
6114
6115 /*
6116  * Restricted expressions
6117  *
6118  * b_expr is a subset of the complete expression syntax defined by a_expr.
6119  *
6120  * Presently, AND, NOT, IS, and IN are the a_expr keywords that would
6121  * cause trouble in the places where b_expr is used.  For simplicity, we
6122  * just eliminate all the boolean-keyword-operator productions from b_expr.
6123  */
6124 b_expr:         c_expr
6125                                 { $$ = $1; }
6126                         | b_expr TYPECAST Typename
6127                                 { $$ = makeTypeCast($1, $3); }
6128                         | '+' b_expr                                    %prec UMINUS
6129                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, $2); }
6130                         | '-' b_expr                                    %prec UMINUS
6131                                 { $$ = doNegate($2); }
6132                         | '%' b_expr
6133                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", NULL, $2); }
6134                         | '^' b_expr
6135                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", NULL, $2); }
6136                         | b_expr '%'
6137                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, NULL); }
6138                         | b_expr '^'
6139                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, NULL); }
6140                         | b_expr '+' b_expr
6141                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3); }
6142                         | b_expr '-' b_expr
6143                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", $1, $3); }
6144                         | b_expr '*' b_expr
6145                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", $1, $3); }
6146                         | b_expr '/' b_expr
6147                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", $1, $3); }
6148                         | b_expr '%' b_expr
6149                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", $1, $3); }
6150                         | b_expr '^' b_expr
6151                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", $1, $3); }
6152                         | b_expr '<' b_expr
6153                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", $1, $3); }
6154                         | b_expr '>' b_expr
6155                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", $1, $3); }
6156                         | b_expr '=' b_expr
6157                                 { $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3); }
6158                         | b_expr qual_Op b_expr                         %prec Op
6159                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, $3); }
6160                         | qual_Op b_expr                                        %prec Op
6161                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $1, NULL, $2); }
6162                         | b_expr qual_Op                                        %prec POSTFIXOP
6163                                 { $$ = (Node *) makeA_Expr(AEXPR_OP, $2, $1, NULL); }
6164                         | b_expr IS DISTINCT FROM b_expr        %prec IS
6165                                 {
6166                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", $1, $5);
6167                                 }
6168                         | b_expr IS OF '(' type_list ')'        %prec IS
6169                                 {
6170                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", $1, (Node *) $5);
6171                                 }
6172                         | b_expr IS NOT OF '(' type_list ')'    %prec IS
6173                                 {
6174                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_OF, "!=", $1, (Node *) $6);
6175                                 }
6176                 ;
6177
6178 /*
6179  * Productions that can be used in both a_expr and b_expr.
6180  *
6181  * Note: productions that refer recursively to a_expr or b_expr mostly
6182  * cannot appear here.  However, it's OK to refer to a_exprs that occur
6183  * inside parentheses, such as function arguments; that cannot introduce
6184  * ambiguity to the b_expr syntax.
6185  */
6186 c_expr:         columnref                                                               { $$ = (Node *) $1; }
6187                         | AexprConst                                                    { $$ = $1; }
6188                         | PARAM attrs opt_indirection
6189                                 {
6190                                         /*
6191                                          * PARAM without field names is considered a constant,
6192                                          * but with 'em, it is not.  Not very consistent ...
6193                                          */
6194                                         ParamRef *n = makeNode(ParamRef);
6195                                         n->number = $1;
6196                                         n->fields = $2;
6197                                         n->indirection = $3;
6198                                         $$ = (Node *)n;
6199                                 }
6200                         | '(' a_expr ')' attrs opt_indirection
6201                                 {
6202                                         ExprFieldSelect *n = makeNode(ExprFieldSelect);
6203                                         n->arg = $2;
6204                                         n->fields = $4;
6205                                         n->indirection = $5;
6206                                         $$ = (Node *)n;
6207                                 }
6208                         | '(' a_expr ')' opt_indirection
6209                                 {
6210                                         if ($4)
6211                                         {
6212                                                 ExprFieldSelect *n = makeNode(ExprFieldSelect);
6213                                                 n->arg = $2;
6214                                                 n->fields = NIL;
6215                                                 n->indirection = $4;
6216                                                 $$ = (Node *)n;
6217                                         }
6218                                         else
6219                                                 $$ = $2;
6220                                 }
6221                         | case_expr
6222                                 { $$ = $1; }
6223                         | func_name '(' ')'
6224                                 {
6225                                         FuncCall *n = makeNode(FuncCall);
6226                                         n->funcname = $1;
6227                                         n->args = NIL;
6228                                         n->agg_star = FALSE;
6229                                         n->agg_distinct = FALSE;
6230                                         $$ = (Node *)n;
6231                                 }
6232                         | func_name '(' expr_list ')'
6233                                 {
6234                                         FuncCall *n = makeNode(FuncCall);
6235                                         n->funcname = $1;
6236                                         n->args = $3;
6237                                         n->agg_star = FALSE;
6238                                         n->agg_distinct = FALSE;
6239                                         $$ = (Node *)n;
6240                                 }
6241                         | func_name '(' ALL expr_list ')'
6242                                 {
6243                                         FuncCall *n = makeNode(FuncCall);
6244                                         n->funcname = $1;
6245                                         n->args = $4;
6246                                         n->agg_star = FALSE;
6247                                         n->agg_distinct = FALSE;
6248                                         /* Ideally we'd mark the FuncCall node to indicate
6249                                          * "must be an aggregate", but there's no provision
6250                                          * for that in FuncCall at the moment.
6251                                          */
6252                                         $$ = (Node *)n;
6253                                 }
6254                         | func_name '(' DISTINCT expr_list ')'
6255                                 {
6256                                         FuncCall *n = makeNode(FuncCall);
6257                                         n->funcname = $1;
6258                                         n->args = $4;
6259                                         n->agg_star = FALSE;
6260                                         n->agg_distinct = TRUE;
6261                                         $$ = (Node *)n;
6262                                 }
6263                         | func_name '(' '*' ')'
6264                                 {
6265                                         /*
6266                                          * For now, we transform AGGREGATE(*) into AGGREGATE(1).
6267                                          *
6268                                          * This does the right thing for COUNT(*) (in fact,
6269                                          * any certainly-non-null expression would do for COUNT),
6270                                          * and there are no other aggregates in SQL92 that accept
6271                                          * '*' as parameter.
6272                                          *
6273                                          * The FuncCall node is also marked agg_star = true,
6274                                          * so that later processing can detect what the argument
6275                                          * really was.
6276                                          */
6277                                         FuncCall *n = makeNode(FuncCall);
6278                                         A_Const *star = makeNode(A_Const);
6279
6280                                         star->val.type = T_Integer;
6281                                         star->val.val.ival = 1;
6282                                         n->funcname = $1;
6283                                         n->args = makeList1(star);
6284                                         n->agg_star = TRUE;
6285                                         n->agg_distinct = FALSE;
6286                                         $$ = (Node *)n;
6287                                 }
6288                         | CURRENT_DATE
6289                                 {
6290                                         /*
6291                                          * Translate as "'now'::text::date".
6292                                          *
6293                                          * We cannot use "'now'::date" because coerce_type() will
6294                                          * immediately reduce that to a constant representing
6295                                          * today's date.  We need to delay the conversion until
6296                                          * runtime, else the wrong things will happen when
6297                                          * CURRENT_DATE is used in a column default value or rule.
6298                                          *
6299                                          * This could be simplified if we had a way to generate
6300                                          * an expression tree representing runtime application
6301                                          * of type-input conversion functions...
6302                                          */
6303                                         A_Const *s = makeNode(A_Const);
6304                                         TypeName *d;
6305
6306                                         s->val.type = T_String;
6307                                         s->val.val.str = "now";
6308                                         s->typename = SystemTypeName("text");
6309
6310                                         d = SystemTypeName("date");
6311
6312                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6313                                 }
6314                         | CURRENT_TIME
6315                                 {
6316                                         /*
6317                                          * Translate as "'now'::text::timetz".
6318                                          * See comments for CURRENT_DATE.
6319                                          */
6320                                         A_Const *s = makeNode(A_Const);
6321                                         TypeName *d;
6322
6323                                         s->val.type = T_String;
6324                                         s->val.val.str = "now";
6325                                         s->typename = SystemTypeName("text");
6326
6327                                         d = SystemTypeName("timetz");
6328                                         /* SQL99 mandates a default precision of zero for TIME
6329                                          * fields in schemas. However, for CURRENT_TIME
6330                                          * let's preserve the microsecond precision we
6331                                          * might see from the system clock. - thomas 2001-12-07
6332                                          */
6333                                         d->typmod = 6;
6334
6335                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6336                                 }
6337                         | CURRENT_TIME '(' Iconst ')'
6338                                 {
6339                                         /*
6340                                          * Translate as "'now'::text::timetz(n)".
6341                                          * See comments for CURRENT_DATE.
6342                                          */
6343                                         A_Const *s = makeNode(A_Const);
6344                                         TypeName *d;
6345
6346                                         s->val.type = T_String;
6347                                         s->val.val.str = "now";
6348                                         s->typename = SystemTypeName("text");
6349                                         d = SystemTypeName("timetz");
6350                                         if ($3 < 0)
6351                                                 ereport(ERROR,
6352                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6353                                                                  errmsg("CURRENT_TIME(%d) precision must not be negative",
6354                                                                                 $3)));
6355                                         if ($3 > MAX_TIME_PRECISION)
6356                                         {
6357                                                 ereport(WARNING,
6358                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6359                                                                  errmsg("CURRENT_TIME(%d) precision reduced to maximum allowed, %d",
6360                                                                                 $3, MAX_TIME_PRECISION)));
6361                                                 $3 = MAX_TIME_PRECISION;
6362                                         }
6363                                         d->typmod = $3;
6364
6365                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6366                                 }
6367                         | CURRENT_TIMESTAMP
6368                                 {
6369                                         /*
6370                                          * Translate as "'now'::text::timestamptz".
6371                                          * See comments for CURRENT_DATE.
6372                                          */
6373                                         A_Const *s = makeNode(A_Const);
6374                                         TypeName *d;
6375
6376                                         s->val.type = T_String;
6377                                         s->val.val.str = "now";
6378                                         s->typename = SystemTypeName("text");
6379
6380                                         d = SystemTypeName("timestamptz");
6381                                         /* SQL99 mandates a default precision of 6 for timestamp.
6382                                          * Also, that is about as precise as we will get since
6383                                          * we are using a microsecond time interface.
6384                                          * - thomas 2001-12-07
6385                                          */
6386                                         d->typmod = 6;
6387
6388                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6389                                 }
6390                         | CURRENT_TIMESTAMP '(' Iconst ')'
6391                                 {
6392                                         /*
6393                                          * Translate as "'now'::text::timestamptz(n)".
6394                                          * See comments for CURRENT_DATE.
6395                                          */
6396                                         A_Const *s = makeNode(A_Const);
6397                                         TypeName *d;
6398
6399                                         s->val.type = T_String;
6400                                         s->val.val.str = "now";
6401                                         s->typename = SystemTypeName("text");
6402
6403                                         d = SystemTypeName("timestamptz");
6404                                         if ($3 < 0)
6405                                                 ereport(ERROR,
6406                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6407                                                                  errmsg("CURRENT_TIMESTAMP(%d) precision must not be negative",
6408                                                                                 $3)));
6409                                         if ($3 > MAX_TIMESTAMP_PRECISION)
6410                                         {
6411                                                 ereport(WARNING,
6412                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6413                                                                  errmsg("CURRENT_TIMESTAMP(%d) precision reduced to maximum allowed, %d",
6414                                                                                 $3, MAX_TIMESTAMP_PRECISION)));
6415                                                 $3 = MAX_TIMESTAMP_PRECISION;
6416                                         }
6417                                         d->typmod = $3;
6418
6419                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6420                                 }
6421                         | LOCALTIME
6422                                 {
6423                                         /*
6424                                          * Translate as "'now'::text::time".
6425                                          * See comments for CURRENT_DATE.
6426                                          */
6427                                         A_Const *s = makeNode(A_Const);
6428                                         TypeName *d;
6429
6430                                         s->val.type = T_String;
6431                                         s->val.val.str = "now";
6432                                         s->typename = SystemTypeName("text");
6433
6434                                         d = SystemTypeName("time");
6435                                         /* SQL99 mandates a default precision of zero for TIME
6436                                          * fields in schemas. However, for LOCALTIME
6437                                          * let's preserve the microsecond precision we
6438                                          * might see from the system clock. - thomas 2001-12-07
6439                                          */
6440                                         d->typmod = 6;
6441
6442                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6443                                 }
6444                         | LOCALTIME '(' Iconst ')'
6445                                 {
6446                                         /*
6447                                          * Translate as "'now'::text::time(n)".
6448                                          * See comments for CURRENT_DATE.
6449                                          */
6450                                         A_Const *s = makeNode(A_Const);
6451                                         TypeName *d;
6452
6453                                         s->val.type = T_String;
6454                                         s->val.val.str = "now";
6455                                         s->typename = SystemTypeName("text");
6456                                         d = SystemTypeName("time");
6457                                         if ($3 < 0)
6458                                                 ereport(ERROR,
6459                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6460                                                                  errmsg("LOCALTIME(%d) precision must not be negative",
6461                                                                                 $3)));
6462                                         if ($3 > MAX_TIME_PRECISION)
6463                                         {
6464                                                 ereport(WARNING,
6465                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6466                                                                  errmsg("LOCALTIME(%d) precision reduced to maximum allowed, %d",
6467                                                                                 $3, MAX_TIME_PRECISION)));
6468                                                 $3 = MAX_TIME_PRECISION;
6469                                         }
6470                                         d->typmod = $3;
6471
6472                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6473                                 }
6474                         | LOCALTIMESTAMP
6475                                 {
6476                                         /*
6477                                          * Translate as "'now'::text::timestamp".
6478                                          * See comments for CURRENT_DATE.
6479                                          */
6480                                         A_Const *s = makeNode(A_Const);
6481                                         TypeName *d;
6482
6483                                         s->val.type = T_String;
6484                                         s->val.val.str = "now";
6485                                         s->typename = SystemTypeName("text");
6486
6487                                         d = SystemTypeName("timestamp");
6488                                         /* SQL99 mandates a default precision of 6 for timestamp.
6489                                          * Also, that is about as precise as we will get since
6490                                          * we are using a microsecond time interface.
6491                                          * - thomas 2001-12-07
6492                                          */
6493                                         d->typmod = 6;
6494
6495                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6496                                 }
6497                         | LOCALTIMESTAMP '(' Iconst ')'
6498                                 {
6499                                         /*
6500                                          * Translate as "'now'::text::timestamp(n)".
6501                                          * See comments for CURRENT_DATE.
6502                                          */
6503                                         A_Const *s = makeNode(A_Const);
6504                                         TypeName *d;
6505
6506                                         s->val.type = T_String;
6507                                         s->val.val.str = "now";
6508                                         s->typename = SystemTypeName("text");
6509
6510                                         d = SystemTypeName("timestamp");
6511                                         if ($3 < 0)
6512                                                 ereport(ERROR,
6513                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6514                                                                  errmsg("LOCALTIMESTAMP(%d) precision must not be negative",
6515                                                                                 $3)));
6516                                         if ($3 > MAX_TIMESTAMP_PRECISION)
6517                                         {
6518                                                 ereport(WARNING,
6519                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6520                                                                  errmsg("LOCALTIMESTAMP(%d) precision reduced to maximum allowed, %d",
6521                                                                                 $3, MAX_TIMESTAMP_PRECISION)));
6522                                                 $3 = MAX_TIMESTAMP_PRECISION;
6523                                         }
6524                                         d->typmod = $3;
6525
6526                                         $$ = (Node *)makeTypeCast((Node *)s, d);
6527                                 }
6528                         | CURRENT_USER
6529                                 {
6530                                         FuncCall *n = makeNode(FuncCall);
6531                                         n->funcname = SystemFuncName("current_user");
6532                                         n->args = NIL;
6533                                         n->agg_star = FALSE;
6534                                         n->agg_distinct = FALSE;
6535                                         $$ = (Node *)n;
6536                                 }
6537                         | SESSION_USER
6538                                 {
6539                                         FuncCall *n = makeNode(FuncCall);
6540                                         n->funcname = SystemFuncName("session_user");
6541                                         n->args = NIL;
6542                                         n->agg_star = FALSE;
6543                                         n->agg_distinct = FALSE;
6544                                         $$ = (Node *)n;
6545                                 }
6546                         | USER
6547                                 {
6548                                         FuncCall *n = makeNode(FuncCall);
6549                                         n->funcname = SystemFuncName("current_user");
6550                                         n->args = NIL;
6551                                         n->agg_star = FALSE;
6552                                         n->agg_distinct = FALSE;
6553                                         $$ = (Node *)n;
6554                                 }
6555                         | CAST '(' a_expr AS Typename ')'
6556                                 { $$ = makeTypeCast($3, $5); }
6557                         | EXTRACT '(' extract_list ')'
6558                                 {
6559                                         FuncCall *n = makeNode(FuncCall);
6560                                         n->funcname = SystemFuncName("date_part");
6561                                         n->args = $3;
6562                                         n->agg_star = FALSE;
6563                                         n->agg_distinct = FALSE;
6564                                         $$ = (Node *)n;
6565                                 }
6566                         | OVERLAY '(' overlay_list ')'
6567                                 {
6568                                         /* overlay(A PLACING B FROM C FOR D) is converted to
6569                                          * substring(A, 1, C-1) || B || substring(A, C+1, C+D)
6570                                          * overlay(A PLACING B FROM C) is converted to
6571                                          * substring(A, 1, C-1) || B || substring(A, C+1, C+char_length(B))
6572                                          */
6573                                         FuncCall *n = makeNode(FuncCall);
6574                                         n->funcname = SystemFuncName("overlay");
6575                                         n->args = $3;
6576                                         n->agg_star = FALSE;
6577                                         n->agg_distinct = FALSE;
6578                                         $$ = (Node *)n;
6579                                 }
6580                         | POSITION '(' position_list ')'
6581                                 {
6582                                         /* position(A in B) is converted to position(B, A) */
6583                                         FuncCall *n = makeNode(FuncCall);
6584                                         n->funcname = SystemFuncName("position");
6585                                         n->args = $3;
6586                                         n->agg_star = FALSE;
6587                                         n->agg_distinct = FALSE;
6588                                         $$ = (Node *)n;
6589                                 }
6590                         | SUBSTRING '(' substr_list ')'
6591                                 {
6592                                         /* substring(A from B for C) is converted to
6593                                          * substring(A, B, C) - thomas 2000-11-28
6594                                          */
6595                                         FuncCall *n = makeNode(FuncCall);
6596                                         n->funcname = SystemFuncName("substring");
6597                                         n->args = $3;
6598                                         n->agg_star = FALSE;
6599                                         n->agg_distinct = FALSE;
6600                                         $$ = (Node *)n;
6601                                 }
6602                         | TREAT '(' a_expr AS Typename ')'
6603                                 {
6604                                         /* TREAT(expr AS target) converts expr of a particular type to target,
6605                                          * which is defined to be a subtype of the original expression.
6606                                          * In SQL99, this is intended for use with structured UDTs,
6607                                          * but let's make this a generally useful form allowing stronger
6608                                          * coersions than are handled by implicit casting.
6609                                          */
6610                                         FuncCall *n = makeNode(FuncCall);
6611                                         /* Convert SystemTypeName() to SystemFuncName() even though
6612                                          * at the moment they result in the same thing.
6613                                          */
6614                                         n->funcname = SystemFuncName(((Value *)llast($5->names))->val.str);
6615                                         n->args = makeList1($3);
6616                                         $$ = (Node *)n;
6617                                 }
6618                         | TRIM '(' BOTH trim_list ')'
6619                                 {
6620                                         /* various trim expressions are defined in SQL92
6621                                          * - thomas 1997-07-19
6622                                          */
6623                                         FuncCall *n = makeNode(FuncCall);
6624                                         n->funcname = SystemFuncName("btrim");
6625                                         n->args = $4;
6626                                         n->agg_star = FALSE;
6627                                         n->agg_distinct = FALSE;
6628                                         $$ = (Node *)n;
6629                                 }
6630                         | TRIM '(' LEADING trim_list ')'
6631                                 {
6632                                         FuncCall *n = makeNode(FuncCall);
6633                                         n->funcname = SystemFuncName("ltrim");
6634                                         n->args = $4;
6635                                         n->agg_star = FALSE;
6636                                         n->agg_distinct = FALSE;
6637                                         $$ = (Node *)n;
6638                                 }
6639                         | TRIM '(' TRAILING trim_list ')'
6640                                 {
6641                                         FuncCall *n = makeNode(FuncCall);
6642                                         n->funcname = SystemFuncName("rtrim");
6643                                         n->args = $4;
6644                                         n->agg_star = FALSE;
6645                                         n->agg_distinct = FALSE;
6646                                         $$ = (Node *)n;
6647                                 }
6648                         | TRIM '(' trim_list ')'
6649                                 {
6650                                         FuncCall *n = makeNode(FuncCall);
6651                                         n->funcname = SystemFuncName("btrim");
6652                                         n->args = $3;
6653                                         n->agg_star = FALSE;
6654                                         n->agg_distinct = FALSE;
6655                                         $$ = (Node *)n;
6656                                 }
6657                         | CONVERT '(' a_expr USING any_name ')'
6658                                 {
6659                                         FuncCall *n = makeNode(FuncCall);
6660                                         A_Const *c = makeNode(A_Const);
6661
6662                                         c->val.type = T_String;
6663                                         c->val.val.str = NameListToQuotedString($5);
6664
6665                                         n->funcname = SystemFuncName("convert_using");
6666                                         n->args = makeList2($3, c);
6667                                         n->agg_star = FALSE;
6668                                         n->agg_distinct = FALSE;
6669                                         $$ = (Node *)n;
6670                                 }
6671                         | CONVERT '(' expr_list ')'
6672                                 {
6673                                         FuncCall *n = makeNode(FuncCall);
6674                                         n->funcname = SystemFuncName("convert");
6675                                         n->args = $3;
6676                                         n->agg_star = FALSE;
6677                                         n->agg_distinct = FALSE;
6678                                         $$ = (Node *)n;
6679                                 }
6680                         | select_with_parens                    %prec UMINUS
6681                                 {
6682                                         SubLink *n = makeNode(SubLink);
6683                                         n->subLinkType = EXPR_SUBLINK;
6684                                         n->lefthand = NIL;
6685                                         n->operName = NIL;
6686                                         n->subselect = $1;
6687                                         $$ = (Node *)n;
6688                                 }
6689                         | EXISTS select_with_parens
6690                                 {
6691                                         SubLink *n = makeNode(SubLink);
6692                                         n->subLinkType = EXISTS_SUBLINK;
6693                                         n->lefthand = NIL;
6694                                         n->operName = NIL;
6695                                         n->subselect = $2;
6696                                         $$ = (Node *)n;
6697                                 }
6698                         | ARRAY select_with_parens
6699                                 {
6700                                         SubLink *n = makeNode(SubLink);
6701                                         n->subLinkType = ARRAY_SUBLINK;
6702                                         n->lefthand = NIL;
6703                                         n->operName = NIL;
6704                                         n->subselect = $2;
6705                                         $$ = (Node *)n;
6706                                 }
6707                         | ARRAY array_expr
6708                                 {       $$ = $2;        }
6709                         | row
6710                                 {
6711                                         RowExpr *r = makeNode(RowExpr);
6712                                         r->args = $1;
6713                                         r->row_typeid = InvalidOid;     /* not analyzed yet */
6714                                         $$ = (Node *)r;
6715                                 }
6716                 ;
6717
6718 /*
6719  * Supporting nonterminals for expressions.
6720  */
6721
6722 /* Explicit row production.
6723  *
6724  * SQL99 allows an optional ROW keyword, so we can now do single-element rows
6725  * without conflicting with the parenthesized a_expr production.  Without the
6726  * ROW keyword, there must be more than one a_expr inside the parens.
6727  */
6728 row:            ROW '(' expr_list ')'                                   { $$ = $3; }
6729                         | ROW '(' ')'                                                   { $$ = NIL; }
6730                         | '(' expr_list ',' a_expr ')'                  { $$ = lappend($2, $4); }
6731                 ;
6732
6733 sub_type:       ANY                                                                             { $$ = ANY_SUBLINK; }
6734                         | SOME                                                                  { $$ = ANY_SUBLINK; }
6735                         | ALL                                                                   { $$ = ALL_SUBLINK; }
6736                 ;
6737
6738 all_Op:         Op                                                                              { $$ = $1; }
6739                         | MathOp                                                                { $$ = $1; }
6740                 ;
6741
6742 MathOp:          '+'                                                                    { $$ = "+"; }
6743                         | '-'                                                                   { $$ = "-"; }
6744                         | '*'                                                                   { $$ = "*"; }
6745                         | '/'                                                                   { $$ = "/"; }
6746                         | '%'                                                                   { $$ = "%"; }
6747                         | '^'                                                                   { $$ = "^"; }
6748                         | '<'                                                                   { $$ = "<"; }
6749                         | '>'                                                                   { $$ = ">"; }
6750                         | '='                                                                   { $$ = "="; }
6751                 ;
6752
6753 qual_Op:        Op
6754                                         { $$ = makeList1(makeString($1)); }
6755                         | OPERATOR '(' any_operator ')'
6756                                         { $$ = $3; }
6757                 ;
6758
6759 qual_all_Op:
6760                         all_Op
6761                                         { $$ = makeList1(makeString($1)); }
6762                         | OPERATOR '(' any_operator ')'
6763                                         { $$ = $3; }
6764                 ;
6765
6766 subquery_Op:
6767                         all_Op
6768                                         { $$ = makeList1(makeString($1)); }
6769                         | OPERATOR '(' any_operator ')'
6770                                         { $$ = $3; }
6771                         | LIKE
6772                                         { $$ = makeList1(makeString("~~")); }
6773                         | NOT LIKE
6774                                         { $$ = makeList1(makeString("!~~")); }
6775                         | ILIKE
6776                                         { $$ = makeList1(makeString("~~*")); }
6777                         | NOT ILIKE
6778                                         { $$ = makeList1(makeString("!~~*")); }
6779 /* cannot put SIMILAR TO here, because SIMILAR TO is a hack.
6780  * the regular expression is preprocessed by a function (similar_escape),
6781  * and the ~ operator for posix regular expressions is used.
6782  *        x SIMILAR TO y     ->    x ~ similar_escape(y)
6783  * this transformation is made on the fly by the parser upwards.
6784  * however the SubLink structure which handles any/some/all stuff
6785  * is not ready for such a thing.
6786  */
6787                         ;
6788
6789 opt_indirection:
6790                         opt_indirection '[' a_expr ']'
6791                                 {
6792                                         A_Indices *ai = makeNode(A_Indices);
6793                                         ai->lidx = NULL;
6794                                         ai->uidx = $3;
6795                                         $$ = lappend($1, ai);
6796                                 }
6797                         | opt_indirection '[' a_expr ':' a_expr ']'
6798                                 {
6799                                         A_Indices *ai = makeNode(A_Indices);
6800                                         ai->lidx = $3;
6801                                         ai->uidx = $5;
6802                                         $$ = lappend($1, ai);
6803                                 }
6804                         | /*EMPTY*/
6805                                 { $$ = NIL; }
6806                 ;
6807
6808 expr_list:      a_expr
6809                                 {
6810                                         FastList *dst = (FastList *) &$$;
6811                                         makeFastList1(dst, $1);
6812                                 }
6813                         | expr_list ',' a_expr
6814                                 {
6815                                         FastList *dst = (FastList *) &$$;
6816                                         FastList *src = (FastList *) &$1;
6817                                         *dst = *src;
6818                                         FastAppend(dst, $3);
6819                                 }
6820                 ;
6821
6822 extract_list:
6823                         extract_arg FROM a_expr
6824                                 {
6825                                         A_Const *n = makeNode(A_Const);
6826                                         n->val.type = T_String;
6827                                         n->val.val.str = $1;
6828                                         $$ = makeList2((Node *) n, $3);
6829                                 }
6830                         | /*EMPTY*/                                                             { $$ = NIL; }
6831                 ;
6832
6833 type_list:  type_list ',' Typename
6834                                 {
6835                                         $$ = lappend($1, $3);
6836                                 }
6837                         | Typename
6838                                 {
6839                                         $$ = makeList1($1);
6840                                 }
6841                 ;
6842
6843 array_expr_list: array_expr
6844                                 {       $$ = makeList1($1);             }
6845                         | array_expr_list ',' array_expr
6846                                 {       $$ = lappend($1, $3);   }
6847                 ;
6848
6849 array_expr: '[' expr_list ']'
6850                                 {
6851                                         ArrayExpr *n = makeNode(ArrayExpr);
6852                                         n->elements = $2;
6853                                         $$ = (Node *)n;
6854                                 }
6855                         | '[' array_expr_list ']'
6856                                 {
6857                                         ArrayExpr *n = makeNode(ArrayExpr);
6858                                         n->elements = $2;
6859                                         $$ = (Node *)n;
6860                                 }
6861                 ;
6862
6863 /* Allow delimited string SCONST in extract_arg as an SQL extension.
6864  * - thomas 2001-04-12
6865  */
6866
6867 extract_arg:
6868                         IDENT                                                                   { $$ = $1; }
6869                         | YEAR_P                                                                { $$ = "year"; }
6870                         | MONTH_P                                                               { $$ = "month"; }
6871                         | DAY_P                                                                 { $$ = "day"; }
6872                         | HOUR_P                                                                { $$ = "hour"; }
6873                         | MINUTE_P                                                              { $$ = "minute"; }
6874                         | SECOND_P                                                              { $$ = "second"; }
6875                         | SCONST                                                                { $$ = $1; }
6876                 ;
6877
6878 /* OVERLAY() arguments
6879  * SQL99 defines the OVERLAY() function:
6880  * o overlay(text placing text from int for int)
6881  * o overlay(text placing text from int)
6882  */
6883 overlay_list:
6884                         a_expr overlay_placing substr_from substr_for
6885                                 {
6886                                         $$ = makeList4($1, $2, $3, $4);
6887                                 }
6888                         | a_expr overlay_placing substr_from
6889                                 {
6890                                         $$ = makeList3($1, $2, $3);
6891                                 }
6892                 ;
6893
6894 overlay_placing:
6895                         PLACING a_expr
6896                                 { $$ = $2; }
6897                 ;
6898
6899 /* position_list uses b_expr not a_expr to avoid conflict with general IN */
6900
6901 position_list:
6902                         b_expr IN_P b_expr                                              { $$ = makeList2($3, $1); }
6903                         | /*EMPTY*/                                                             { $$ = NIL; }
6904                 ;
6905
6906 /* SUBSTRING() arguments
6907  * SQL9x defines a specific syntax for arguments to SUBSTRING():
6908  * o substring(text from int for int)
6909  * o substring(text from int) get entire string from starting point "int"
6910  * o substring(text from pattern) get entire string matching pattern
6911  * o substring(text for int) get first "int" characters of string
6912  * We also want to implement generic substring functions which accept
6913  * the usual generic list of arguments. So we will accept both styles
6914  * here, and convert the SQL9x style to the generic list for further
6915  * processing. - thomas 2000-11-28
6916  */
6917 substr_list:
6918                         a_expr substr_from substr_for
6919                                 {
6920                                         $$ = makeList3($1, $2, $3);
6921                                 }
6922                         | a_expr substr_for substr_from
6923                                 {
6924                                         $$ = makeList3($1, $3, $2);
6925                                 }
6926                         | a_expr substr_from
6927                                 {
6928                                         $$ = makeList2($1, $2);
6929                                 }
6930                         | a_expr substr_for
6931                                 {
6932                                         A_Const *n = makeNode(A_Const);
6933                                         n->val.type = T_Integer;
6934                                         n->val.val.ival = 1;
6935                                         $$ = makeList3($1, (Node *)n, $2);
6936                                 }
6937                         | expr_list
6938                                 {
6939                                         $$ = $1;
6940                                 }
6941                         | /*EMPTY*/
6942                                 { $$ = NIL; }
6943                 ;
6944
6945 substr_from:
6946                         FROM a_expr                                                             { $$ = $2; }
6947                 ;
6948
6949 substr_for: FOR a_expr                                                          { $$ = $2; }
6950                 ;
6951
6952 trim_list:      a_expr FROM expr_list                                   { $$ = lappend($3, $1); }
6953                         | FROM expr_list                                                { $$ = $2; }
6954                         | expr_list                                                             { $$ = $1; }
6955                 ;
6956
6957 in_expr:        select_with_parens
6958                                 {
6959                                         SubLink *n = makeNode(SubLink);
6960                                         n->subselect = $1;
6961                                         /* other fields will be filled later */
6962                                         $$ = (Node *)n;
6963                                 }
6964                         | '(' expr_list ')'                                             { $$ = (Node *)$2; }
6965                 ;
6966
6967 /* Case clause
6968  * Define SQL92-style case clause.
6969  * Allow all four forms described in the standard:
6970  * - Full specification
6971  *      CASE WHEN a = b THEN c ... ELSE d END
6972  * - Implicit argument
6973  *      CASE a WHEN b THEN c ... ELSE d END
6974  * - Conditional NULL
6975  *      NULLIF(x,y)
6976  *      same as CASE WHEN x = y THEN NULL ELSE x END
6977  * - Conditional substitution from list, use first non-null argument
6978  *      COALESCE(a,b,...)
6979  * same as CASE WHEN a IS NOT NULL THEN a WHEN b IS NOT NULL THEN b ... END
6980  * - thomas 1998-11-09
6981  *
6982  * NULLIF and COALESCE have become first class nodes to
6983  * prevent double evaluation of arguments.
6984  * - Kris Jurka 2003-02-11
6985  */
6986 case_expr:      CASE case_arg when_clause_list case_default END_P
6987                                 {
6988                                         CaseExpr *c = makeNode(CaseExpr);
6989                                         c->casetype = InvalidOid; /* not analyzed yet */
6990                                         c->arg = (Expr *) $2;
6991                                         c->args = $3;
6992                                         c->defresult = (Expr *) $4;
6993                                         $$ = (Node *)c;
6994                                 }
6995                         | NULLIF '(' a_expr ',' a_expr ')'
6996                                 {
6997                                         $$ = (Node *) makeSimpleA_Expr(AEXPR_NULLIF, "=", $3, $5);
6998                                 }
6999                         | COALESCE '(' expr_list ')'
7000                                 {
7001                                         CoalesceExpr *c = makeNode(CoalesceExpr);
7002                                         c->args = $3;
7003                                         $$ = (Node *)c;
7004                                 }
7005                 ;
7006
7007 when_clause_list:
7008                         /* There must be at least one */
7009                         when_clause                                                             { $$ = makeList1($1); }
7010                         | when_clause_list when_clause                  { $$ = lappend($1, $2); }
7011                 ;
7012
7013 when_clause:
7014                         WHEN a_expr THEN a_expr
7015                                 {
7016                                         CaseWhen *w = makeNode(CaseWhen);
7017                                         w->expr = (Expr *) $2;
7018                                         w->result = (Expr *) $4;
7019                                         $$ = (Node *)w;
7020                                 }
7021                 ;
7022
7023 case_default:
7024                         ELSE a_expr                                                             { $$ = $2; }
7025                         | /*EMPTY*/                                                             { $$ = NULL; }
7026                 ;
7027
7028 case_arg:       a_expr                                                                  { $$ = $1; }
7029                         | /*EMPTY*/                                                             { $$ = NULL; }
7030                 ;
7031
7032 /*
7033  * columnref starts with relation_name not ColId, so that OLD and NEW
7034  * references can be accepted.  Note that when there are more than two
7035  * dotted names, the first name is not actually a relation name...
7036  */
7037 columnref:      relation_name opt_indirection
7038                                 {
7039                                         $$ = makeNode(ColumnRef);
7040                                         $$->fields = makeList1(makeString($1));
7041                                         $$->indirection = $2;
7042                                 }
7043                         | dotted_name opt_indirection
7044                                 {
7045                                         $$ = makeNode(ColumnRef);
7046                                         $$->fields = $1;
7047                                         $$->indirection = $2;
7048                                 }
7049                 ;
7050
7051 dotted_name:
7052                         relation_name attrs
7053                                         { $$ = lcons(makeString($1), $2); }
7054                 ;
7055
7056 attrs:          '.' attr_name
7057                                         { $$ = makeList1(makeString($2)); }
7058                         | '.' '*'
7059                                         { $$ = makeList1(makeString("*")); }
7060                         | '.' attr_name attrs
7061                                         { $$ = lcons(makeString($2), $3); }
7062                 ;
7063
7064
7065 /*****************************************************************************
7066  *
7067  *      target lists
7068  *
7069  *****************************************************************************/
7070
7071 /* Target lists as found in SELECT ... and INSERT VALUES ( ... ) */
7072
7073 target_list:
7074                         target_el                                                               { $$ = makeList1($1); }
7075                         | target_list ',' target_el                             { $$ = lappend($1, $3); }
7076                 ;
7077
7078 /* AS is not optional because shift/red conflict with unary ops */
7079 target_el:      a_expr AS ColLabel
7080                                 {
7081                                         $$ = makeNode(ResTarget);
7082                                         $$->name = $3;
7083                                         $$->indirection = NIL;
7084                                         $$->val = (Node *)$1;
7085                                 }
7086                         | a_expr
7087                                 {
7088                                         $$ = makeNode(ResTarget);
7089                                         $$->name = NULL;
7090                                         $$->indirection = NIL;
7091                                         $$->val = (Node *)$1;
7092                                 }
7093                         | '*'
7094                                 {
7095                                         ColumnRef *n = makeNode(ColumnRef);
7096                                         n->fields = makeList1(makeString("*"));
7097                                         n->indirection = NIL;
7098                                         $$ = makeNode(ResTarget);
7099                                         $$->name = NULL;
7100                                         $$->indirection = NIL;
7101                                         $$->val = (Node *)n;
7102                                 }
7103                 ;
7104
7105 /* Target list as found in UPDATE table SET ...
7106 | '(' row_ ')' = '(' row_ ')'
7107 {
7108         $$ = NULL;
7109 }
7110  */
7111 update_target_list:
7112                         update_target_el                                                { $$ = makeList1($1); }
7113                         | update_target_list ',' update_target_el { $$ = lappend($1,$3); }
7114                 ;
7115
7116 update_target_el:
7117                         ColId opt_indirection '=' a_expr
7118                                 {
7119                                         $$ = makeNode(ResTarget);
7120                                         $$->name = $1;
7121                                         $$->indirection = $2;
7122                                         $$->val = (Node *) $4;
7123                                 }
7124                         | ColId opt_indirection '=' DEFAULT
7125                                 {
7126                                         $$ = makeNode(ResTarget);
7127                                         $$->name = $1;
7128                                         $$->indirection = $2;
7129                                         $$->val = (Node *) makeNode(SetToDefault);
7130                                 }
7131
7132                 ;
7133
7134 insert_target_list:
7135                         insert_target_el                                                { $$ = makeList1($1); }
7136                         | insert_target_list ',' insert_target_el { $$ = lappend($1, $3); }
7137                 ;
7138
7139 insert_target_el:
7140                         target_el                                                               { $$ = $1; }
7141                         | DEFAULT
7142                                 {
7143                                         $$ = makeNode(ResTarget);
7144                                         $$->name = NULL;
7145                                         $$->indirection = NIL;
7146                                         $$->val = (Node *) makeNode(SetToDefault);
7147                                 }
7148                 ;
7149
7150
7151 /*****************************************************************************
7152  *
7153  *      Names and constants
7154  *
7155  *****************************************************************************/
7156
7157 relation_name:
7158                         SpecialRuleRelation                                             { $$ = $1; }
7159                         | ColId                                                                 { $$ = $1; }
7160                 ;
7161
7162 qualified_name_list:
7163                         qualified_name                                                  { $$ = makeList1($1); }
7164                         | qualified_name_list ',' qualified_name { $$ = lappend($1, $3); }
7165                 ;
7166
7167 qualified_name:
7168                         relation_name
7169                                 {
7170                                         $$ = makeNode(RangeVar);
7171                                         $$->catalogname = NULL;
7172                                         $$->schemaname = NULL;
7173                                         $$->relname = $1;
7174                                 }
7175                         | dotted_name
7176                                 {
7177                                         $$ = makeNode(RangeVar);
7178                                         switch (length($1))
7179                                         {
7180                                                 case 2:
7181                                                         $$->catalogname = NULL;
7182                                                         $$->schemaname = strVal(linitial($1));
7183                                                         $$->relname = strVal(lsecond($1));
7184                                                         break;
7185                                                 case 3:
7186                                                         $$->catalogname = strVal(linitial($1));
7187                                                         $$->schemaname = strVal(lsecond($1));
7188                                                         $$->relname = strVal(lthird($1));
7189                                                         break;
7190                                                 default:
7191                                                         ereport(ERROR,
7192                                                                         (errcode(ERRCODE_SYNTAX_ERROR),
7193                                                                          errmsg("improper qualified name (too many dotted names): %s",
7194                                                                                         NameListToString($1))));
7195                                                         break;
7196                                         }
7197                                 }
7198                 ;
7199
7200 name_list:      name
7201                                         { $$ = makeList1(makeString($1)); }
7202                         | name_list ',' name
7203                                         { $$ = lappend($1, makeString($3)); }
7204                 ;
7205
7206
7207 name:           ColId                                                                   { $$ = $1; };
7208
7209 database_name:
7210                         ColId                                                                   { $$ = $1; };
7211
7212 access_method:
7213                         ColId                                                                   { $$ = $1; };
7214
7215 attr_name:      ColId                                                                   { $$ = $1; };
7216
7217 index_name: ColId                                                                       { $$ = $1; };
7218
7219 file_name:      Sconst                                                                  { $$ = $1; };
7220
7221 func_name:      function_name
7222                                         { $$ = makeList1(makeString($1)); }
7223                         | dotted_name                                                   { $$ = $1; }
7224                 ;
7225
7226
7227 /*
7228  * Constants
7229  */
7230 AexprConst: Iconst
7231                                 {
7232                                         A_Const *n = makeNode(A_Const);
7233                                         n->val.type = T_Integer;
7234                                         n->val.val.ival = $1;
7235                                         $$ = (Node *)n;
7236                                 }
7237                         | FCONST
7238                                 {
7239                                         A_Const *n = makeNode(A_Const);
7240                                         n->val.type = T_Float;
7241                                         n->val.val.str = $1;
7242                                         $$ = (Node *)n;
7243                                 }
7244                         | Sconst
7245                                 {
7246                                         A_Const *n = makeNode(A_Const);
7247                                         n->val.type = T_String;
7248                                         n->val.val.str = $1;
7249                                         $$ = (Node *)n;
7250                                 }
7251                         | BCONST
7252                                 {
7253                                         A_Const *n = makeNode(A_Const);
7254                                         n->val.type = T_BitString;
7255                                         n->val.val.str = $1;
7256                                         $$ = (Node *)n;
7257                                 }
7258                         | XCONST
7259                                 {
7260                                         /* This is a bit constant per SQL99:
7261                                          * Without Feature F511, "BIT data type",
7262                                          * a <general literal> shall not be a
7263                                          * <bit string literal> or a <hex string literal>.
7264                                          */
7265                                         A_Const *n = makeNode(A_Const);
7266                                         n->val.type = T_BitString;
7267                                         n->val.val.str = $1;
7268                                         $$ = (Node *)n;
7269                                 }
7270                         | ConstTypename Sconst
7271                                 {
7272                                         A_Const *n = makeNode(A_Const);
7273                                         n->typename = $1;
7274                                         n->val.type = T_String;
7275                                         n->val.val.str = $2;
7276                                         $$ = (Node *)n;
7277                                 }
7278                         | ConstInterval Sconst opt_interval
7279                                 {
7280                                         A_Const *n = makeNode(A_Const);
7281                                         n->typename = $1;
7282                                         n->val.type = T_String;
7283                                         n->val.val.str = $2;
7284                                         /* precision is not specified, but fields may be... */
7285                                         if ($3 != INTERVAL_FULL_RANGE)
7286                                                 n->typename->typmod = INTERVAL_TYPMOD(INTERVAL_FULL_PRECISION, $3);
7287                                         $$ = (Node *)n;
7288                                 }
7289                         | ConstInterval '(' Iconst ')' Sconst opt_interval
7290                                 {
7291                                         A_Const *n = makeNode(A_Const);
7292                                         n->typename = $1;
7293                                         n->val.type = T_String;
7294                                         n->val.val.str = $5;
7295                                         /* precision specified, and fields may be... */
7296                                         if ($3 < 0)
7297                                                 ereport(ERROR,
7298                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7299                                                                  errmsg("INTERVAL(%d) precision must not be negative",
7300                                                                                 $3)));
7301                                         if ($3 > MAX_INTERVAL_PRECISION)
7302                                         {
7303                                                 ereport(WARNING,
7304                                                                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
7305                                                                  errmsg("INTERVAL(%d) precision reduced to maximum allowed, %d",
7306                                                                                 $3, MAX_INTERVAL_PRECISION)));
7307                                                 $3 = MAX_INTERVAL_PRECISION;
7308                                         }
7309                                         n->typename->typmod = INTERVAL_TYPMOD($3, $6);
7310                                         $$ = (Node *)n;
7311                                 }
7312                         | PARAM opt_indirection
7313                                 {
7314                                         ParamRef *n = makeNode(ParamRef);
7315                                         n->number = $1;
7316                                         n->fields = NIL;
7317                                         n->indirection = $2;
7318                                         $$ = (Node *)n;
7319                                 }
7320                         | TRUE_P
7321                                 {
7322                                         $$ = (Node *)makeBoolAConst(TRUE);
7323                                 }
7324                         | FALSE_P
7325                                 {
7326                                         $$ = (Node *)makeBoolAConst(FALSE);
7327                                 }
7328                         | NULL_P
7329                                 {
7330                                         A_Const *n = makeNode(A_Const);
7331                                         n->val.type = T_Null;
7332                                         $$ = (Node *)n;
7333                                 }
7334                 ;
7335
7336 Iconst:         ICONST                                                                  { $$ = $1; };
7337 Sconst:         SCONST                                                                  { $$ = $1; };
7338 UserId:         ColId                                                                   { $$ = $1; };
7339
7340 /*
7341  * Name classification hierarchy.
7342  *
7343  * IDENT is the lexeme returned by the lexer for identifiers that match
7344  * no known keyword.  In most cases, we can accept certain keywords as
7345  * names, not only IDENTs.      We prefer to accept as many such keywords
7346  * as possible to minimize the impact of "reserved words" on programmers.
7347  * So, we divide names into several possible classes.  The classification
7348  * is chosen in part to make keywords acceptable as names wherever possible.
7349  */
7350
7351 /* Column identifier --- names that can be column, table, etc names.
7352  */
7353 ColId:          IDENT                                                                   { $$ = $1; }
7354                         | unreserved_keyword                                    { $$ = pstrdup($1); }
7355                         | col_name_keyword                                              { $$ = pstrdup($1); }
7356                 ;
7357
7358 /* Type identifier --- names that can be type names.
7359  */
7360 type_name:      IDENT                                                                   { $$ = $1; }
7361                         | unreserved_keyword                                    { $$ = pstrdup($1); }
7362                 ;
7363
7364 /* Function identifier --- names that can be function names.
7365  */
7366 function_name:
7367                         IDENT                                                                   { $$ = $1; }
7368                         | unreserved_keyword                                    { $$ = pstrdup($1); }
7369                         | func_name_keyword                                             { $$ = pstrdup($1); }
7370                 ;
7371
7372 /* Column label --- allowed labels in "AS" clauses.
7373  * This presently includes *all* Postgres keywords.
7374  */
7375 ColLabel:       IDENT                                                                   { $$ = $1; }
7376                         | unreserved_keyword                                    { $$ = pstrdup($1); }
7377                         | col_name_keyword                                              { $$ = pstrdup($1); }
7378                         | func_name_keyword                                             { $$ = pstrdup($1); }
7379                         | reserved_keyword                                              { $$ = pstrdup($1); }
7380                 ;
7381
7382
7383 /*
7384  * Keyword classification lists.  Generally, every keyword present in
7385  * the Postgres grammar should appear in exactly one of these lists.
7386  *
7387  * Put a new keyword into the first list that it can go into without causing
7388  * shift or reduce conflicts.  The earlier lists define "less reserved"
7389  * categories of keywords.
7390  */
7391
7392 /* "Unreserved" keywords --- available for use as any kind of name.
7393  */
7394 unreserved_keyword:
7395                           ABORT_P
7396                         | ABSOLUTE_P
7397                         | ACCESS
7398                         | ACTION
7399                         | ADD
7400                         | AFTER
7401                         | AGGREGATE
7402                         | ALTER
7403                         | ASSERTION
7404                         | ASSIGNMENT
7405                         | AT
7406                         | BACKWARD
7407                         | BEFORE
7408                         | BEGIN_P
7409                         | BY
7410                         | CACHE
7411                         | CALLED
7412                         | CASCADE
7413                         | CHAIN
7414                         | CHARACTERISTICS
7415                         | CHECKPOINT
7416                         | CLASS
7417                         | CLOSE
7418                         | CLUSTER
7419                         | COMMENT
7420                         | COMMIT
7421                         | COMMITTED
7422                         | CONSTRAINTS
7423                         | CONVERSION_P
7424                         | COPY
7425                         | CREATEDB
7426                         | CREATEUSER
7427                         | CSV
7428                         | CURSOR
7429                         | CYCLE
7430                         | DATABASE
7431                         | DAY_P
7432                         | DEALLOCATE
7433                         | DECLARE
7434                         | DEFAULTS
7435                         | DEFERRED
7436                         | DEFINER
7437                         | DELETE_P
7438                         | DELIMITER
7439                         | DELIMITERS
7440                         | DOMAIN_P
7441                         | DOUBLE_P
7442                         | DROP
7443                         | EACH
7444                         | ENCODING
7445                         | ENCRYPTED
7446                         | ESCAPE
7447                         | EXCLUDING
7448                         | EXCLUSIVE
7449                         | EXECUTE
7450                         | EXPLAIN
7451                         | EXTERNAL
7452                         | FETCH
7453                         | FIRST_P
7454                         | FORCE
7455                         | FORWARD
7456                         | FUNCTION
7457                         | GLOBAL
7458                         | HANDLER
7459                         | HOLD
7460                         | HOUR_P
7461                         | IMMEDIATE
7462                         | IMMUTABLE
7463                         | IMPLICIT_P
7464                         | INCLUDING
7465                         | INCREMENT
7466                         | INDEX
7467                         | INHERITS
7468                         | INPUT_P
7469                         | INSENSITIVE
7470                         | INSERT
7471                         | INSTEAD
7472                         | INVOKER
7473                         | ISOLATION
7474                         | KEY
7475                         | LANCOMPILER
7476                         | LANGUAGE
7477                         | LARGE_P
7478                         | LAST_P
7479                         | LEVEL
7480                         | LISTEN
7481                         | LOAD
7482                         | LOCAL
7483                         | LOCATION
7484                         | LOCK_P
7485                         | MATCH
7486                         | MAXVALUE
7487                         | MINUTE_P
7488                         | MINVALUE
7489                         | MODE
7490                         | MONTH_P
7491                         | MOVE
7492                         | NAMES
7493                         | NEXT
7494                         | NO
7495                         | NOCREATEDB
7496                         | NOCREATEUSER
7497                         | NOTHING
7498                         | NOTIFY
7499                         | OBJECT_P
7500                         | OF
7501                         | OIDS
7502                         | OPERATOR
7503                         | OPTION
7504                         | OWNER
7505                         | PARTIAL
7506                         | PASSWORD
7507                         | PATH_P
7508                         | PENDANT
7509                         | PREPARE
7510                         | PRESERVE
7511                         | PRIOR
7512                         | PRIVILEGES
7513                         | PROCEDURAL
7514                         | PROCEDURE
7515                         | QUOTE
7516                         | READ
7517                         | RECHECK
7518                         | REINDEX
7519                         | RELATIVE_P
7520                         | RENAME
7521                         | REPEATABLE
7522                         | REPLACE
7523                         | RESET
7524                         | RESTART
7525                         | RESTRICT
7526                         | RETURNS
7527                         | REVOKE
7528                         | ROLLBACK
7529                         | ROWS
7530                         | RULE
7531                         | SCHEMA
7532                         | SCROLL
7533                         | SECOND_P
7534                         | SECURITY
7535                         | SEQUENCE
7536                         | SERIALIZABLE
7537                         | SESSION
7538                         | SET
7539                         | SHARE
7540                         | SHOW
7541                         | SIMPLE
7542                         | STABLE
7543                         | START
7544                         | STATEMENT
7545                         | STATISTICS
7546                         | STDIN
7547                         | STDOUT
7548                         | STORAGE
7549                         | SYSID
7550                         | STRICT_P
7551                         | TEMP
7552                         | TEMPLATE
7553                         | TEMPORARY
7554                         | TOAST
7555                         | TRANSACTION
7556                         | TRIGGER
7557                         | TRUNCATE
7558                         | TRUSTED
7559                         | TYPE_P
7560                         | UNCOMMITTED
7561                         | UNENCRYPTED
7562                         | UNKNOWN
7563                         | UNLISTEN
7564                         | UNTIL
7565                         | UPDATE
7566                         | USAGE
7567                         | VACUUM
7568                         | VALID
7569                         | VALIDATOR
7570                         | VALUES
7571                         | VARYING
7572                         | VERSION
7573                         | VIEW
7574                         | VOLATILE
7575                         | WITH
7576                         | WITHOUT
7577                         | WORK
7578                         | WRITE
7579                         | YEAR_P
7580                         | ZONE
7581                 ;
7582
7583 /* Column identifier --- keywords that can be column, table, etc names.
7584  *
7585  * Many of these keywords will in fact be recognized as type or function
7586  * names too; but they have special productions for the purpose, and so
7587  * can't be treated as "generic" type or function names.
7588  *
7589  * The type names appearing here are not usable as function names
7590  * because they can be followed by '(' in typename productions, which
7591  * looks too much like a function call for an LR(1) parser.
7592  */
7593 col_name_keyword:
7594                           BIGINT
7595                         | BIT
7596                         | BOOLEAN_P
7597                         | CHAR_P
7598                         | CHARACTER
7599                         | COALESCE
7600                         | CONVERT
7601                         | DEC
7602                         | DECIMAL_P
7603                         | EXISTS
7604                         | EXTRACT
7605                         | FLOAT_P
7606                         | INOUT
7607                         | INT_P
7608                         | INTEGER
7609                         | INTERVAL
7610                         | NATIONAL
7611                         | NCHAR
7612                         | NONE
7613                         | NULLIF
7614                         | NUMERIC
7615                         | OUT_P
7616                         | OVERLAY
7617                         | POSITION
7618                         | PRECISION
7619                         | REAL
7620                         | ROW
7621                         | SETOF
7622                         | SMALLINT
7623                         | SUBSTRING
7624                         | TIME
7625                         | TIMESTAMP
7626                         | TREAT
7627                         | TRIM
7628                         | VARCHAR
7629                 ;
7630
7631 /* Function identifier --- keywords that can be function names.
7632  *
7633  * Most of these are keywords that are used as operators in expressions;
7634  * in general such keywords can't be column names because they would be
7635  * ambiguous with variables, but they are unambiguous as function identifiers.
7636  *
7637  * Do not include POSITION, SUBSTRING, etc here since they have explicit
7638  * productions in a_expr to support the goofy SQL9x argument syntax.
7639  * - thomas 2000-11-28
7640  */
7641 func_name_keyword:
7642                           AUTHORIZATION
7643                         | BETWEEN
7644                         | BINARY
7645                         | CROSS
7646                         | FREEZE
7647                         | FULL
7648                         | ILIKE
7649                         | INNER_P
7650                         | IS
7651                         | ISNULL
7652                         | JOIN
7653                         | LEFT
7654                         | LIKE
7655                         | NATURAL
7656                         | NOTNULL
7657                         | OUTER_P
7658                         | OVERLAPS
7659                         | RIGHT
7660                         | SIMILAR
7661                         | VERBOSE
7662                 ;
7663
7664 /* Reserved keyword --- these keywords are usable only as a ColLabel.
7665  *
7666  * Keywords appear here if they could not be distinguished from variable,
7667  * type, or function names in some contexts.  Don't put things here unless
7668  * forced to.
7669  */
7670 reserved_keyword:
7671                           ALL
7672                         | ANALYSE
7673                         | ANALYZE
7674                         | AND
7675                         | ANY
7676                         | ARRAY
7677                         | AS
7678                         | ASC
7679                         | BOTH
7680                         | CASE
7681                         | CAST
7682                         | CHECK
7683                         | COLLATE
7684                         | COLUMN
7685                         | CONSTRAINT
7686                         | CREATE
7687                         | CURRENT_DATE
7688                         | CURRENT_TIME
7689                         | CURRENT_TIMESTAMP
7690                         | CURRENT_USER
7691                         | DEFAULT
7692                         | DEFERRABLE
7693                         | DESC
7694                         | DISTINCT
7695                         | DO
7696                         | ELSE
7697                         | END_P
7698                         | EXCEPT
7699                         | FALSE_P
7700                         | FOR
7701                         | FOREIGN
7702                         | FROM
7703                         | GRANT
7704                         | GROUP_P
7705                         | HAVING
7706                         | IN_P
7707                         | INITIALLY
7708                         | INTERSECT
7709                         | INTO
7710                         | LEADING
7711                         | LIMIT
7712                         | LOCALTIME
7713                         | LOCALTIMESTAMP
7714                         | NEW
7715                         | NOT
7716                         | NOWAIT
7717                         | NULL_P
7718                         | OFF
7719                         | OFFSET
7720                         | OLD
7721                         | ON
7722                         | ONLY
7723                         | OR
7724                         | ORDER
7725                         | PLACING
7726                         | PRIMARY
7727                         | REFERENCES
7728                         | SELECT
7729                         | SESSION_USER
7730                         | SOME
7731                         | TABLE
7732                         | THEN
7733                         | TO
7734                         | TRAILING
7735                         | TRUE_P
7736                         | UNION
7737                         | UNIQUE
7738                         | USER
7739                         | USING
7740                         | WHEN
7741                         | WHERE
7742                 ;
7743
7744
7745 SpecialRuleRelation:
7746                         OLD
7747                                 {
7748                                         if (QueryIsRule)
7749                                                 $$ = "*OLD*";
7750                                         else
7751                                                 ereport(ERROR,
7752                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
7753                                                                  errmsg("OLD used in query that is not in a rule")));
7754                                 }
7755                         | NEW
7756                                 {
7757                                         if (QueryIsRule)
7758                                                 $$ = "*NEW*";
7759                                         else
7760                                                 ereport(ERROR,
7761                                                                 (errcode(ERRCODE_SYNTAX_ERROR),
7762                                                                  errmsg("NEW used in query that is not in a rule")));
7763                                 }
7764                 ;
7765
7766 %%
7767
7768 static Node *
7769 makeTypeCast(Node *arg, TypeName *typename)
7770 {
7771         /*
7772          * Simply generate a TypeCast node.
7773          *
7774          * Earlier we would determine whether an A_Const would
7775          * be acceptable, however Domains require coerce_type()
7776          * to process them -- applying constraints as required.
7777          */
7778         TypeCast *n = makeNode(TypeCast);
7779         n->arg = arg;
7780         n->typename = typename;
7781         return (Node *) n;
7782 }
7783
7784 static Node *
7785 makeStringConst(char *str, TypeName *typename)
7786 {
7787         A_Const *n = makeNode(A_Const);
7788
7789         n->val.type = T_String;
7790         n->val.val.str = str;
7791         n->typename = typename;
7792
7793         return (Node *)n;
7794 }
7795
7796 static Node *
7797 makeIntConst(int val)
7798 {
7799         A_Const *n = makeNode(A_Const);
7800         n->val.type = T_Integer;
7801         n->val.val.ival = val;
7802         n->typename = SystemTypeName("int4");
7803
7804         return (Node *)n;
7805 }
7806
7807 static Node *
7808 makeFloatConst(char *str)
7809 {
7810         A_Const *n = makeNode(A_Const);
7811
7812         n->val.type = T_Float;
7813         n->val.val.str = str;
7814         n->typename = SystemTypeName("float8");
7815
7816         return (Node *)n;
7817 }
7818
7819 static Node *
7820 makeAConst(Value *v)
7821 {
7822         Node *n;
7823
7824         switch (v->type)
7825         {
7826                 case T_Float:
7827                         n = makeFloatConst(v->val.str);
7828                         break;
7829
7830                 case T_Integer:
7831                         n = makeIntConst(v->val.ival);
7832                         break;
7833
7834                 case T_String:
7835                 default:
7836                         n = makeStringConst(v->val.str, NULL);
7837                         break;
7838         }
7839
7840         return n;
7841 }
7842
7843 /* makeDefElem()
7844  * Create a DefElem node and set contents.
7845  * Could be moved to nodes/makefuncs.c if this is useful elsewhere.
7846  */
7847 static DefElem *
7848 makeDefElem(char *name, Node *arg)
7849 {
7850         DefElem *f = makeNode(DefElem);
7851         f->defname = name;
7852         f->arg = arg;
7853         return f;
7854 }
7855
7856 /* makeBoolAConst()
7857  * Create an A_Const node and initialize to a boolean constant.
7858  */
7859 static A_Const *
7860 makeBoolAConst(bool state)
7861 {
7862         A_Const *n = makeNode(A_Const);
7863         n->val.type = T_String;
7864         n->val.val.str = (state? "t": "f");
7865         n->typename = SystemTypeName("bool");
7866         return n;
7867 }
7868
7869 /* makeRowNullTest()
7870  * Generate separate operator nodes for a single row descriptor test.
7871  *
7872  * Eventually this should be eliminated in favor of making the NullTest
7873  * node type capable of handling it directly.
7874  */
7875 static Node *
7876 makeRowNullTest(NullTestType test, RowExpr *row)
7877 {
7878         Node            *result = NULL;
7879         ListCell        *arg;
7880
7881         foreach(arg, row->args)
7882         {
7883                 NullTest *n;
7884
7885                 n = makeNode(NullTest);
7886                 n->arg = (Expr *) lfirst(arg);
7887                 n->nulltesttype = test;
7888
7889                 if (result == NULL)
7890                         result = (Node *) n;
7891                 else if (test == IS_NOT_NULL)
7892                         result = (Node *) makeA_Expr(AEXPR_OR, NIL, result, (Node *)n);
7893                 else
7894                         result = (Node *) makeA_Expr(AEXPR_AND, NIL, result, (Node *)n);
7895         }
7896
7897         if (result == NULL)
7898         {
7899                 /* zero-length rows?  Generate constant TRUE or FALSE */
7900                 result = (Node *) makeBoolAConst(test == IS_NULL);
7901         }
7902
7903         return result;
7904 }
7905
7906 /* makeOverlaps()
7907  * Create and populate a FuncCall node to support the OVERLAPS operator.
7908  */
7909 static FuncCall *
7910 makeOverlaps(List *largs, List *rargs)
7911 {
7912         FuncCall *n = makeNode(FuncCall);
7913         n->funcname = SystemFuncName("overlaps");
7914         if (length(largs) == 1)
7915                 largs = lappend(largs, largs);
7916         else if (length(largs) != 2)
7917                 ereport(ERROR,
7918                                 (errcode(ERRCODE_SYNTAX_ERROR),
7919                                  errmsg("wrong number of parameters on left side of OVERLAPS expression")));
7920         if (length(rargs) == 1)
7921                 rargs = lappend(rargs, rargs);
7922         else if (length(rargs) != 2)
7923                 ereport(ERROR,
7924                                 (errcode(ERRCODE_SYNTAX_ERROR),
7925                                  errmsg("wrong number of parameters on right side of OVERLAPS expression")));
7926         n->args = nconc(largs, rargs);
7927         n->agg_star = FALSE;
7928         n->agg_distinct = FALSE;
7929         return n;
7930 }
7931
7932 /* extractArgTypes()
7933  * Given a list of FunctionParameter nodes, extract a list of just the
7934  * argument types (TypeNames).  Most of the productions using func_args
7935  * don't currently want the full FunctionParameter data, so we use this
7936  * rather than having two sets of productions.
7937  */
7938 static List *
7939 extractArgTypes(List *parameters)
7940 {
7941         List       *result = NIL;
7942         ListCell   *i;
7943
7944         foreach(i, parameters)
7945         {
7946                 FunctionParameter *p = (FunctionParameter *) lfirst(i);
7947
7948                 result = lappend(result, p->argType);
7949         }
7950         return result;
7951 }
7952
7953 /* findLeftmostSelect()
7954  * Find the leftmost component SelectStmt in a set-operation parsetree.
7955  */
7956 static SelectStmt *
7957 findLeftmostSelect(SelectStmt *node)
7958 {
7959         while (node && node->op != SETOP_NONE)
7960                 node = node->larg;
7961         Assert(node && IsA(node, SelectStmt) && node->larg == NULL);
7962         return node;
7963 }
7964
7965 /* insertSelectOptions()
7966  * Insert ORDER BY, etc into an already-constructed SelectStmt.
7967  *
7968  * This routine is just to avoid duplicating code in SelectStmt productions.
7969  */
7970 static void
7971 insertSelectOptions(SelectStmt *stmt,
7972                                         List *sortClause, List *forUpdate,
7973                                         Node *limitOffset, Node *limitCount)
7974 {
7975         /*
7976          * Tests here are to reject constructs like
7977          *      (SELECT foo ORDER BY bar) ORDER BY baz
7978          */
7979         if (sortClause)
7980         {
7981                 if (stmt->sortClause)
7982                         ereport(ERROR,
7983                                         (errcode(ERRCODE_SYNTAX_ERROR),
7984                                          errmsg("multiple ORDER BY clauses not allowed")));
7985                 stmt->sortClause = sortClause;
7986         }
7987         if (forUpdate)
7988         {
7989                 if (stmt->forUpdate)
7990                         ereport(ERROR,
7991                                         (errcode(ERRCODE_SYNTAX_ERROR),
7992                                          errmsg("multiple FOR UPDATE clauses not allowed")));
7993                 stmt->forUpdate = forUpdate;
7994         }
7995         if (limitOffset)
7996         {
7997                 if (stmt->limitOffset)
7998                         ereport(ERROR,
7999                                         (errcode(ERRCODE_SYNTAX_ERROR),
8000                                          errmsg("multiple OFFSET clauses not allowed")));
8001                 stmt->limitOffset = limitOffset;
8002         }
8003         if (limitCount)
8004         {
8005                 if (stmt->limitCount)
8006                         ereport(ERROR,
8007                                         (errcode(ERRCODE_SYNTAX_ERROR),
8008                                          errmsg("multiple LIMIT clauses not allowed")));
8009                 stmt->limitCount = limitCount;
8010         }
8011 }
8012
8013 static Node *
8014 makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg)
8015 {
8016         SelectStmt *n = makeNode(SelectStmt);
8017
8018         n->op = op;
8019         n->all = all;
8020         n->larg = (SelectStmt *) larg;
8021         n->rarg = (SelectStmt *) rarg;
8022         return (Node *) n;
8023 }
8024
8025 /* SystemFuncName()
8026  * Build a properly-qualified reference to a built-in function.
8027  */
8028 List *
8029 SystemFuncName(char *name)
8030 {
8031         return makeList2(makeString("pg_catalog"), makeString(name));
8032 }
8033
8034 /* SystemTypeName()
8035  * Build a properly-qualified reference to a built-in type.
8036  *
8037  * typmod is defaulted, but may be changed afterwards by caller.
8038  */
8039 TypeName *
8040 SystemTypeName(char *name)
8041 {
8042         TypeName   *n = makeNode(TypeName);
8043
8044         n->names = makeList2(makeString("pg_catalog"), makeString(name));
8045         n->typmod = -1;
8046         return n;
8047 }
8048
8049 /* parser_init()
8050  * Initialize to parse one query string
8051  */
8052 void
8053 parser_init(void)
8054 {
8055         QueryIsRule = FALSE;
8056 }
8057
8058 /* exprIsNullConstant()
8059  * Test whether an a_expr is a plain NULL constant or not.
8060  */
8061 bool
8062 exprIsNullConstant(Node *arg)
8063 {
8064         if (arg && IsA(arg, A_Const))
8065         {
8066                 A_Const *con = (A_Const *) arg;
8067
8068                 if (con->val.type == T_Null &&
8069                         con->typename == NULL)
8070                         return TRUE;
8071         }
8072         return FALSE;
8073 }
8074
8075 /* doNegate()
8076  * Handle negation of a numeric constant.
8077  *
8078  * Formerly, we did this here because the optimizer couldn't cope with
8079  * indexquals that looked like "var = -4" --- it wants "var = const"
8080  * and a unary minus operator applied to a constant didn't qualify.
8081  * As of Postgres 7.0, that problem doesn't exist anymore because there
8082  * is a constant-subexpression simplifier in the optimizer.  However,
8083  * there's still a good reason for doing this here, which is that we can
8084  * postpone committing to a particular internal representation for simple
8085  * negative constants.  It's better to leave "-123.456" in string form
8086  * until we know what the desired type is.
8087  */
8088 static Node *
8089 doNegate(Node *n)
8090 {
8091         if (IsA(n, A_Const))
8092         {
8093                 A_Const *con = (A_Const *)n;
8094
8095                 if (con->val.type == T_Integer)
8096                 {
8097                         con->val.val.ival = -con->val.val.ival;
8098                         return n;
8099                 }
8100                 if (con->val.type == T_Float)
8101                 {
8102                         doNegateFloat(&con->val);
8103                         return n;
8104                 }
8105         }
8106
8107         return (Node *) makeSimpleA_Expr(AEXPR_OP, "-", NULL, n);
8108 }
8109
8110 static void
8111 doNegateFloat(Value *v)
8112 {
8113         char   *oldval = v->val.str;
8114
8115         Assert(IsA(v, Float));
8116         if (*oldval == '+')
8117                 oldval++;
8118         if (*oldval == '-')
8119                 v->val.str = oldval+1;  /* just strip the '-' */
8120         else
8121         {
8122                 char   *newval = (char *) palloc(strlen(oldval) + 2);
8123
8124                 *newval = '-';
8125                 strcpy(newval+1, oldval);
8126                 v->val.str = newval;
8127         }
8128 }
8129
8130 #include "scan.c"