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