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