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

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