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

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