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