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