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

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