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

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