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

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