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