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

   1 %{
   2
   3 /*#define YYDEBUG 1*/
   4 /*-------------------------------------------------------------------------
   5  *
   6  * gram.y
   7  *        POSTGRES SQL YACC rules/actions
   8  *
   9  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  10  * Portions Copyright (c) 1994, Regents of the University of California
  11  *
  12  *
  13  * IDENTIFICATION
  14  *        $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.324 2002/06/17 05:40:32 momjian Exp $
  15  *
  16  * HISTORY
  17  *        AUTHOR                        DATE                    MAJOR EVENT
  18  *        Andrew Yu                     Sept, 1994              POSTQUEL to SQL conversion
  19  *        Andrew Yu                     Oct, 1994               lispy code conversion
  20  *
  21  * NOTES
  22  *        CAPITALS are used to represent terminal symbols.
  23  *        non-capitals are used to represent non-terminals.
  24  *        SQL92-specific syntax is separated from plain SQL/Postgres syntax
  25  *        to help isolate the non-extensible portions of the parser.
  26  *
  27  *        In general, nothing in this file should initiate database accesses
  28  *        nor depend on changeable state (such as SET variables).  If you do
  29  *        database accesses, your code will fail when we have aborted the
  30  *        current transaction and are just parsing commands to find the next
  31  *        ROLLBACK or COMMIT.  If you make use of SET variables, then you
  32  *        will do the wrong thing in multi-query strings like this:
  33  *                      SET SQL_inheritance TO off; SELECT * FROM foo;
  34  *        because the entire string is parsed by gram.y before the SET gets
  35  *        executed.  Anything that depends on the database or changeable state
  36  *        should be handled inside parse_analyze() so that it happens at the
  37  *        right time not the wrong time.  The handling of SQL_inheritance is
  38  *        a good example.
  39  *
  40  * WARNINGS
  41  *        If you use a list, make sure the datum is a node so that the printing
  42  *        routines work.
  43  *
  44  *        Sometimes we assign constants to makeStrings. Make sure we don't free
  45  *        those.
  46  *
  47  *-------------------------------------------------------------------------
  48  */
  49 #include "postgres.h"
  50
  51 #include <ctype.h>
  52
  53 #include "access/htup.h"
  54 #include "catalog/index.h"
  55 #include "catalog/namespace.h"
  56 #include "catalog/pg_type.h"
  57 #include "nodes/makefuncs.h"
  58 #include "nodes/params.h"
  59 #include "nodes/parsenodes.h"
  60 #include "parser/gramparse.h"
  61 #include "storage/lmgr.h"
  62 #include "utils/numeric.h"
  63 #include "utils/datetime.h"
  64 #include "utils/date.h"
  65
  66 #ifdef MULTIBYTE
  67 #include "mb/pg_wchar.h"
  68 #else
  69 #define GetStandardEncoding()   0               /* PG_SQL_ASCII */
  70 #define GetStandardEncodingName()       "SQL_ASCII"
  71 #endif
  72
  73 extern List *parsetree;                 /* final parse result is delivered here */
  74
  75 static bool QueryIsRule = FALSE;
  76 static Oid      *param_type_info;
  77 static int      pfunc_num_args;
  78
  79
  80 /*
  81  * If you need access to certain yacc-generated variables and find that
  82  * they're static by default, uncomment the next line.  (this is not a
  83  * problem, yet.)
  84  */
  85 /*#define __YYSCLASS*/
  86
  87 static Node *makeTypeCast(Node *arg, TypeName *typename);
  88 static Node *makeStringConst(char *str, TypeName *typename);
  89 static Node *makeIntConst(int val);
  90 static Node *makeFloatConst(char *str);
  91 static Node *makeAConst(Value *v);
  92 static Node *makeRowExpr(List *opr, List *largs, List *rargs);
  93 static SelectStmt *findLeftmostSelect(SelectStmt *node);
  94 static void insertSelectOptions(SelectStmt *stmt,
  95                                                                 List *sortClause, List *forUpdate,
  96                                                                 Node *limitOffset, Node *limitCount);
  97 static Node *makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg);
  98 static Node *doNegate(Node *n);
  99 static void doNegateFloat(Value *v);
 100
 101 #define MASK(b) (1 << (b))
 102
 103 %}
 104
 105
 106 %union
 107 {
 108         int                                     ival;
 109         char                            chr;
 110         char                            *str;
 111         const char                      *keyword;
 112         bool                            boolean;
 113         JoinType                        jtype;
 114         List                            *list;
 115         Node                            *node;
 116         Value                           *value;
 117         ColumnRef                       *columnref;
 118
 119         TypeName                        *typnam;
 120         DefElem                         *defelt;
 121         SortGroupBy                     *sortgroupby;
 122         JoinExpr                        *jexpr;
 123         IndexElem                       *ielem;
 124         Alias                           *alias;
 125         RangeVar                        *range;
 126         A_Indices                       *aind;
 127         ResTarget                       *target;
 128         PrivTarget                      *privtarget;
 129
 130         InsertStmt                      *istmt;
 131         VariableSetStmt         *vsetstmt;
 132 }
 133
 134 %type <node>    stmt, schema_stmt,
 135                 AlterDatabaseSetStmt, AlterGroupStmt, AlterSchemaStmt, AlterTableStmt,
 136                 AlterUserStmt, AlterUserSetStmt, AnalyzeStmt,
 137                 ClosePortalStmt, ClusterStmt, CommentStmt, ConstraintsSetStmt,
 138                 CopyStmt, CreateAsStmt, CreateDomainStmt, CreateGroupStmt, CreatePLangStmt,
 139                 CreateSchemaStmt, CreateSeqStmt, CreateStmt, CreateAssertStmt, CreateTrigStmt,
 140                 CreateUserStmt, CreatedbStmt, CursorStmt, DefineStmt, DeleteStmt,
 141                 DropGroupStmt, DropPLangStmt, DropSchemaStmt, DropStmt, DropAssertStmt, DropTrigStmt,
 142                 DropRuleStmt, DropUserStmt, DropdbStmt, ExplainStmt, FetchStmt,
 143                 GrantStmt, IndexStmt, InsertStmt, ListenStmt, LoadStmt, LockStmt,
 144                 NotifyStmt, OptimizableStmt, CreateFunctionStmt, ReindexStmt,
 145                 RemoveAggrStmt, RemoveFuncStmt, RemoveOperStmt,
 146                 RenameStmt, RevokeStmt, RuleActionStmt, RuleActionStmtOrEmpty,
 147                 RuleStmt, SelectStmt, TransactionStmt, TruncateStmt,
 148                 UnlistenStmt, UpdateStmt, VacuumStmt, VariableResetStmt,
 149                 VariableSetStmt, VariableShowStmt, ViewStmt, CheckPointStmt
 150
 151 %type <node>    select_no_parens, select_with_parens, select_clause,
 152                                 simple_select
 153
 154 %type <node>    alter_column_default
 155 %type <ival>    drop_behavior, opt_drop_behavior
 156
 157 %type <list>    createdb_opt_list, createdb_opt_item
 158 %type <boolean> opt_equal
 159
 160 %type <ival>    opt_lock, lock_type
 161 %type <boolean> opt_force, opt_or_replace
 162
 163 %type <list>    user_list
 164
 165 %type <list>    OptGroupList
 166 %type <defelt>  OptGroupElem
 167
 168 %type <list>    OptUserList
 169 %type <defelt>  OptUserElem
 170
 171 %type <str>             OptSchemaName
 172 %type <list>    OptSchemaEltList
 173
 174 %type <boolean> TriggerActionTime, TriggerForSpec, opt_trusted, opt_procedural
 175 %type <str>             opt_lancompiler
 176
 177 %type <str>             TriggerEvents
 178 %type <value>   TriggerFuncArg
 179
 180 %type <str>             relation_name, copy_file_name, copy_delimiter, copy_null,
 181                 database_name, access_method_clause, access_method, attr_name,
 182                 index_name, name, function_name, file_name
 183
 184 %type <list>    func_name, handler_name, qual_Op, qual_all_Op, OptUseOp,
 185                 opt_class, opt_validator
 186
 187 %type <range>   qualified_name, OptConstrFromTable
 188
 189 %type <str>             opt_id,
 190                 all_Op, MathOp, opt_name, SpecialRuleRelation
 191
 192 %type <str>             opt_level, opt_encoding
 193 %type <node>    grantee
 194 %type <list>    grantee_list
 195 %type <ival>    privilege
 196 %type <list>    privileges, privilege_list
 197 %type <privtarget> privilege_target
 198 %type <node>    function_with_argtypes
 199 %type <list>    function_with_argtypes_list
 200 %type <chr>     TriggerOneEvent
 201
 202 %type <list>    stmtblock, stmtmulti,
 203                 OptTableElementList, OptInherit, definition, opt_distinct,
 204                 opt_definition, func_args, func_args_list, func_as, createfunc_opt_list
 205                 oper_argtypes, RuleActionList, RuleActionMulti,
 206                 opt_column_list, columnList, opt_name_list,
 207                 sort_clause, sortby_list, index_params, index_list, name_list,
 208                 from_clause, from_list, opt_array_bounds, qualified_name_list,
 209                 any_name, any_name_list, any_operator, expr_list, dotted_name, attrs,
 210                 target_list, update_target_list, insert_column_list,
 211                 insert_target_list,
 212                 def_list, opt_indirection, group_clause, TriggerFuncArgs,
 213                 select_limit, opt_select_limit
 214
 215 %type <range>   into_clause, OptTempTableName
 216
 217 %type <defelt>  createfunc_opt_item
 218 %type <typnam>  func_arg, func_return, func_type, aggr_argtype
 219
 220 %type <boolean> opt_arg, TriggerForOpt, TriggerForType, OptTemp, OptWithOids
 221
 222 %type <list>    for_update_clause, opt_for_update_clause, update_list
 223 %type <boolean> opt_all
 224 %type <boolean> opt_table
 225 %type <boolean> opt_chain, opt_trans
 226
 227 %type <node>    join_outer, join_qual
 228 %type <jtype>   join_type
 229
 230 %type <list>    extract_list, overlay_list, position_list
 231 %type <list>    substr_list, trim_list
 232 %type <ival>    opt_interval
 233 %type <node>    overlay_placing, substr_from, substr_for
 234
 235 %type <boolean> opt_binary, opt_using, opt_instead, opt_cursor, opt_with
 236 %type <boolean> opt_with_copy, index_opt_unique, opt_verbose, opt_full
 237 %type <boolean> opt_freeze, analyze_keyword
 238
 239 %type <ival>    copy_dirn, direction, reindex_type, drop_type,
 240                                 opt_column, event, comment_type
 241
 242 %type <ival>    fetch_how_many
 243
 244 %type <node>    select_limit_value, select_offset_value
 245
 246 %type <list>    OptSeqList
 247 %type <defelt>  OptSeqElem
 248
 249 %type <istmt>   insert_rest
 250
 251 %type <vsetstmt>        set_rest
 252
 253 %type <node>    OptTableElement, ConstraintElem
 254 %type <node>    columnDef
 255 %type <defelt>  def_elem
 256 %type <node>    def_arg, columnElem, where_clause, insert_column_item,
 257                                 a_expr, b_expr, c_expr, AexprConst,
 258                                 in_expr, having_clause, func_table
 259 %type <list>    row_descriptor, row_list, in_expr_nodes
 260 %type <node>    row_expr
 261 %type <node>    case_expr, case_arg, when_clause, case_default
 262 %type <list>    when_clause_list
 263 %type <ival>    sub_type
 264 %type <list>    OptCreateAs, CreateAsList
 265 %type <node>    CreateAsElement
 266 %type <value>   NumericOnly, FloatOnly, IntegerOnly
 267 %type <columnref>       columnref
 268 %type <alias>   alias_clause
 269 %type <sortgroupby>             sortby
 270 %type <ielem>   index_elem, func_index
 271 %type <node>    table_ref
 272 %type <jexpr>   joined_table
 273 %type <range>   relation_expr
 274 %type <target>  target_el, insert_target_el, update_target_el
 275
 276 %type <typnam>  Typename, SimpleTypename, ConstTypename,
 277                                 GenericType, Numeric, opt_float, Character,
 278                                 ConstDatetime, ConstInterval, Bit
 279 %type <str>             character
 280 %type <str>             extract_arg
 281 %type <str>             opt_charset, opt_collate
 282 %type <ival>    opt_numeric, opt_decimal
 283 %type <boolean> opt_varying, opt_timezone
 284
 285 %type <ival>    Iconst
 286 %type <str>             Sconst, comment_text
 287 %type <str>             UserId, opt_boolean, ColId_or_Sconst
 288 %type <list>    var_list, var_list_or_default
 289 %type <str>             ColId, ColLabel, type_name
 290 %type <node>    var_value, zone_value
 291
 292 %type <keyword> unreserved_keyword, func_name_keyword
 293 %type <keyword> col_name_keyword, reserved_keyword
 294
 295 %type <node>    TableConstraint
 296 %type <list>    ColQualList
 297 %type <node>    ColConstraint, ColConstraintElem, ConstraintAttr
 298 %type <ival>    key_actions, key_delete, key_update, key_reference
 299 %type <str>             key_match
 300 %type <ival>    ConstraintAttributeSpec, ConstraintDeferrabilitySpec,
 301                                 ConstraintTimeSpec
 302
 303 %type <list>    constraints_set_list
 304 %type <boolean> constraints_set_mode
 305
 306 %type <boolean> opt_as
 307
 308
 309 /*
 310  * If you make any token changes, update the keyword table in
 311  * parser/keywords.c and add new keywords to the appropriate one of
 312  * the reserved-or-not-so-reserved keyword lists, below.
 313  */
 314
 315 /* ordinary key words in alphabetical order */
 316 %token <keyword> ABORT_TRANS, ABSOLUTE, ACCESS, ACTION, ADD, AFTER,
 317         AGGREGATE, ALL, ALTER, ANALYSE, ANALYZE, AND, ANY, AS, ASC, ASSERTION,
 318         AT, AUTHORIZATION,
 319
 320         BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
 321         BOOLEAN, BY,
 322
 323         CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR_P, CHARACTER,
 324         CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
 325         COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
 326         CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
 327         CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
 328
 329         DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
 330         DEFINER, DELETE_P, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
 331
 332         EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
 333         EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
 334
 335         FALSE_P, FETCH, FLOAT_P, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
 336         FULL, FUNCTION,
 337
 338         GET, GLOBAL, GRANT, GROUP_P,
 339         HANDLER, HAVING, HOUR_P,
 340
 341         ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN_P, INCREMENT, INDEX, INHERITS,
 342         INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
 343         INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
 344
 345         JOIN,
 346         KEY,
 347
 348         LANCOMPILER, LANGUAGE, LEADING, LEFT, LEVEL, LIKE, LIMIT, LISTEN,
 349         LOAD, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATION, LOCK_P,
 350
 351         MATCH, MAXVALUE, MINUTE_P, MINVALUE, MODE, MONTH_P, MOVE,
 352
 353         NAMES, NATIONAL, NATURAL, NCHAR, NEW, NEXT, NO, NOCREATEDB,
 354         NOCREATEUSER, NONE, NOT, NOTHING, NOTIFY, NOTNULL, NULL_P, NULLIF,
 355         NUMERIC,
 356
 357         OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
 358         OUT_P, OUTER_P, OVERLAPS, OVERLAY, OWNER,
 359
 360         PARTIAL, PASSWORD, PATH_P, PENDANT, PLACING, POSITION, PRECISION, PRIMARY,
 361         PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
 362
 363         READ, REAL, REFERENCES, REINDEX, RELATIVE, RENAME, REPLACE, RESET,
 364         RESTRICT, RETURNS, REVOKE, RIGHT, ROLLBACK, ROW, RULE,
 365
 366         SCHEMA, SCROLL, SECOND_P, SECURITY, SELECT, SEQUENCE, SERIALIZABLE,
 367         SESSION, SESSION_USER, SET, SETOF, SHARE, SHOW, SIMILAR, SMALLINT, SOME,
 368         STABLE, START, STATEMENT, STATISTICS, STDIN, STDOUT, STORAGE, STRICT,
 369         SUBSTRING, SYSID,
 370
 371         TABLE, TEMP, TEMPLATE, TEMPORARY, THEN, TIME, TIMESTAMP, TO, TOAST,
 372         TRAILING, TRANSACTION, TRIGGER, TRIM, TRUE_P, TRUNCATE, TRUSTED, TYPE_P,
 373
 374         UNENCRYPTED, UNION, UNIQUE, UNKNOWN, UNLISTEN, UNTIL, UPDATE, USAGE,
 375         USER, USING,
 376
 377         VACUUM, VALID, VALIDATOR, VALUES, VARCHAR, VARYING, VERBOSE, VERSION, VIEW, VOLATILE,
 378         WHEN, WHERE, WITH, WITHOUT, WORK,
 379         YEAR_P,
 380         ZONE
 381
 382 /* The grammar thinks these are keywords, but they are not in the keywords.c
 383  * list and so can never be entered directly.  The filter in parser.c
 384  * creates these tokens when required.
 385  */
 386 %token                  UNIONJOIN
 387
 388 /* Special keywords, not in the query language - see the "lex" file */
 389 %token <str>    IDENT, FCONST, SCONST, BITCONST, Op
 390 %token <ival>   ICONST, PARAM
 391
 392 /* these are not real. they are here so that they get generated as #define's*/
 393 %token                  OP
 394
 395 /* precedence: lowest to highest */
 396 %left           UNION EXCEPT
 397 %left           INTERSECT
 398 %left           JOIN UNIONJOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
 399 %left           OR
 400 %left           AND
 401 %right          NOT
 402 %right          '='
 403 %nonassoc       '<' '>'
 404 %nonassoc       LIKE ILIKE SIMILAR
 405 %nonassoc       ESCAPE
 406 %nonassoc       OVERLAPS
 407 %nonassoc       BETWEEN
 408 %nonassoc       IN_P
 409 %left           POSTFIXOP               /* dummy for postfix Op rules */
 410 %left           Op OPERATOR             /* multi-character ops and user-defined operators */
 411 %nonassoc       NOTNULL
 412 %nonassoc       ISNULL
 413 %nonassoc       IS NULL_P TRUE_P FALSE_P UNKNOWN        /* sets precedence for IS NULL, etc */
 414 %left           '+' '-'
 415 %left           '*' '/' '%'
 416 %left           '^'
 417 /* Unary Operators */
 418 %left           AT ZONE                 /* sets precedence for AT TIME ZONE */
 419 %right          UMINUS
 420 %left           '[' ']'
 421 %left           '(' ')'
 422 %left           COLLATE
 423 %left           TYPECAST
 424 %left           '.'
 425 %%
 426
 427 /*
 428  *      Handle comment-only lines, and ;; SELECT * FROM pg_class ;;;
 429  *      psql already handles such cases, but other interfaces don't.
 430  *      bjm 1999/10/05
 431  */
 432 stmtblock:  stmtmulti
 433                                 { parsetree = $1; }
 434                 ;
 435
 436 /* the thrashing around here is to discard "empty" statements... */
 437 stmtmulti:  stmtmulti ';' stmt
 438                                 { if ($3 != (Node *)NULL)
 439                                         $$ = lappend($1, $3);
 440                                   else
 441                                         $$ = $1;
 442                                 }
 443                 | stmt
 444                                 { if ($1 != (Node *)NULL)
 445                                         $$ = makeList1($1);
 446                                   else
 447                                         $$ = NIL;
 448                                 }
 449                 ;
 450
 451 stmt : AlterDatabaseSetStmt
 452                 | AlterGroupStmt
 453                 | AlterSchemaStmt
 454                 | AlterTableStmt
 455                 | AlterUserStmt
 456                 | AlterUserSetStmt
 457                 | ClosePortalStmt
 458                 | CopyStmt
 459                 | CreateStmt
 460                 | CreateAsStmt
 461                 | CreateDomainStmt
 462                 | CreateFunctionStmt
 463                 | CreateSchemaStmt
 464                 | CreateGroupStmt
 465                 | CreateSeqStmt
 466                 | CreatePLangStmt
 467                 | CreateAssertStmt
 468                 | CreateTrigStmt
 469                 | CreateUserStmt
 470                 | ClusterStmt
 471                 | DefineStmt
 472                 | DropStmt
 473                 | DropSchemaStmt
 474                 | TruncateStmt
 475                 | CommentStmt
 476                 | DropGroupStmt
 477                 | DropPLangStmt
 478                 | DropAssertStmt
 479                 | DropTrigStmt
 480                 | DropRuleStmt
 481                 | DropUserStmt
 482                 | ExplainStmt
 483                 | FetchStmt
 484                 | GrantStmt
 485                 | IndexStmt
 486                 | ListenStmt
 487                 | UnlistenStmt
 488                 | LockStmt
 489                 | NotifyStmt
 490                 | ReindexStmt
 491                 | RemoveAggrStmt
 492                 | RemoveOperStmt
 493                 | RemoveFuncStmt
 494                 | RenameStmt
 495                 | RevokeStmt
 496                 | OptimizableStmt
 497                 | RuleStmt
 498                 | TransactionStmt
 499                 | ViewStmt
 500                 | LoadStmt
 501                 | CreatedbStmt
 502                 | DropdbStmt
 503                 | VacuumStmt
 504                 | AnalyzeStmt
 505                 | VariableSetStmt
 506                 | VariableShowStmt
 507                 | VariableResetStmt
 508                 | ConstraintsSetStmt
 509                 | CheckPointStmt
 510                 | /*EMPTY*/
 511                         { $$ = (Node *)NULL; }
 512                 ;
 513
 514 /*****************************************************************************
 515  *
 516  * Create a new Postgres DBMS user
 517  *
 518  *
 519  *****************************************************************************/
 520
 521 CreateUserStmt:  CREATE USER UserId opt_with OptUserList
 522                                 {
 523                                         CreateUserStmt *n = makeNode(CreateUserStmt);
 524                                         n->user = $3;
 525                                         n->options = $5;
 526                                         $$ = (Node *)n;
 527                                 }
 528                 ;
 529
 530
 531 opt_with:       WITH                                                            { $$ = TRUE; }
 532                 | /*EMPTY*/                                                             { $$ = TRUE; }
 533                 ;
 534
 535 /*****************************************************************************
 536  *
 537  * Alter a postgresql DBMS user
 538  *
 539  *
 540  *****************************************************************************/
 541
 542 AlterUserStmt:  ALTER USER UserId opt_with OptUserList
 543                                  {
 544                                         AlterUserStmt *n = makeNode(AlterUserStmt);
 545                                         n->user = $3;
 546                                         n->options = $5;
 547                                         $$ = (Node *)n;
 548                                  }
 549                 ;
 550
 551
 552 AlterUserSetStmt: ALTER USER UserId SET set_rest
 553                                 {
 554                                         AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
 555                                         n->user = $3;
 556                                         n->variable = $5->name;
 557                                         n->value = $5->args;
 558                                         $$ = (Node *)n;
 559                                 }
 560                                 | ALTER USER UserId VariableResetStmt
 561                                 {
 562                                         AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
 563                                         n->user = $3;
 564                                         n->variable = ((VariableResetStmt *)$4)->name;
 565                                         n->value = NIL;
 566                                         $$ = (Node *)n;
 567                                 }
 568                 ;
 569
 570
 571 /*****************************************************************************
 572  *
 573  * Drop a postgresql DBMS user
 574  *
 575  *
 576  *****************************************************************************/
 577
 578 DropUserStmt:  DROP USER user_list
 579                                 {
 580                                         DropUserStmt *n = makeNode(DropUserStmt);
 581                                         n->users = $3;
 582                                         $$ = (Node *)n;
 583                                 }
 584                 ;
 585
 586 /*
 587  * Options for CREATE USER and ALTER USER
 588  */
 589 OptUserList: OptUserList OptUserElem            { $$ = lappend($1, $2); }
 590                         | /* EMPTY */                                   { $$ = NIL; }
 591                 ;
 592
 593 OptUserElem:  PASSWORD Sconst
 594                                 {
 595                                         $$ = makeNode(DefElem);
 596                                         $$->defname = "password";
 597                                         $$->arg = (Node *)makeString($2);
 598                                 }
 599                         | ENCRYPTED PASSWORD Sconst
 600                                 {
 601                                         $$ = makeNode(DefElem);
 602                                         $$->defname = "encryptedPassword";
 603                                         $$->arg = (Node *)makeString($3);
 604                                 }
 605                         | UNENCRYPTED PASSWORD Sconst
 606                                 {
 607                                         $$ = makeNode(DefElem);
 608                                         $$->defname = "unencryptedPassword";
 609                                         $$->arg = (Node *)makeString($3);
 610                                 }
 611                         | SYSID Iconst
 612                                 {
 613                                         $$ = makeNode(DefElem);
 614                                         $$->defname = "sysid";
 615                                         $$->arg = (Node *)makeInteger($2);
 616                                 }
 617                         | CREATEDB
 618                                 {
 619                                         $$ = makeNode(DefElem);
 620                                         $$->defname = "createdb";
 621                                         $$->arg = (Node *)makeInteger(TRUE);
 622                                 }
 623                         | NOCREATEDB
 624                                 {
 625                                         $$ = makeNode(DefElem);
 626                                         $$->defname = "createdb";
 627                                         $$->arg = (Node *)makeInteger(FALSE);
 628                                 }
 629                         | CREATEUSER
 630                                 {
 631                                         $$ = makeNode(DefElem);
 632                                         $$->defname = "createuser";
 633                                         $$->arg = (Node *)makeInteger(TRUE);
 634                                 }
 635                         | NOCREATEUSER
 636                                 {
 637                                         $$ = makeNode(DefElem);
 638                                         $$->defname = "createuser";
 639                                         $$->arg = (Node *)makeInteger(FALSE);
 640                                 }
 641                         | IN_P GROUP_P user_list
 642                                 {
 643                                         $$ = makeNode(DefElem);
 644                                         $$->defname = "groupElts";
 645                                         $$->arg = (Node *)$3;
 646                                 }
 647                         | VALID UNTIL Sconst
 648                                 {
 649                                         $$ = makeNode(DefElem);
 650                                         $$->defname = "validUntil";
 651                                         $$->arg = (Node *)makeString($3);
 652                                 }
 653                 ;
 654
 655 user_list:  user_list ',' UserId
 656                                 {
 657                                         $$ = lappend($1, makeString($3));
 658                                 }
 659                         | UserId
 660                                 {
 661                                         $$ = makeList1(makeString($1));
 662                                 }
 663                 ;
 664
 665
 666
 667 /*****************************************************************************
 668  *
 669  * Create a postgresql group
 670  *
 671  *
 672  *****************************************************************************/
 673
 674 CreateGroupStmt:  CREATE GROUP_P UserId opt_with OptGroupList
 675                                 {
 676                                         CreateGroupStmt *n = makeNode(CreateGroupStmt);
 677                                         n->name = $3;
 678                                         n->options = $5;
 679                                         $$ = (Node *)n;
 680                                 }
 681                 ;
 682
 683 /*
 684  * Options for CREATE GROUP
 685  */
 686 OptGroupList: OptGroupList OptGroupElem         { $$ = lappend($1, $2); }
 687                         | /* EMPTY */                                   { $$ = NIL; }
 688                 ;
 689
 690 OptGroupElem:  USER user_list
 691                                 {
 692                                         $$ = makeNode(DefElem);
 693                                         $$->defname = "userElts";
 694                                         $$->arg = (Node *)$2;
 695                                 }
 696                         | SYSID Iconst
 697                                 {
 698                                         $$ = makeNode(DefElem);
 699                                         $$->defname = "sysid";
 700                                         $$->arg = (Node *)makeInteger($2);
 701                                 }
 702                 ;
 703
 704
 705 /*****************************************************************************
 706  *
 707  * Alter a postgresql group
 708  *
 709  *
 710  *****************************************************************************/
 711
 712 AlterGroupStmt:  ALTER GROUP_P UserId ADD USER user_list
 713                                 {
 714                                         AlterGroupStmt *n = makeNode(AlterGroupStmt);
 715                                         n->name = $3;
 716                                         n->action = +1;
 717                                         n->listUsers = $6;
 718                                         $$ = (Node *)n;
 719                                 }
 720                         | ALTER GROUP_P UserId DROP USER user_list
 721                                 {
 722                                         AlterGroupStmt *n = makeNode(AlterGroupStmt);
 723                                         n->name = $3;
 724                                         n->action = -1;
 725                                         n->listUsers = $6;
 726                                         $$ = (Node *)n;
 727                                 }
 728                         ;
 729
 730
 731 /*****************************************************************************
 732  *
 733  * Drop a postgresql group
 734  *
 735  *
 736  *****************************************************************************/
 737
 738 DropGroupStmt: DROP GROUP_P UserId
 739                                 {
 740                                         DropGroupStmt *n = makeNode(DropGroupStmt);
 741                                         n->name = $3;
 742                                         $$ = (Node *)n;
 743                                 }
 744                         ;
 745
 746
 747 /*****************************************************************************
 748  *
 749  * Manipulate a schema
 750  *
 751  *
 752  *****************************************************************************/
 753
 754 CreateSchemaStmt:  CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
 755                                 {
 756                                         CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
 757                                         /* One can omit the schema name or the authorization id... */
 758                                         if ($3 != NULL)
 759                                                 n->schemaname = $3;
 760                                         else
 761                                                 n->schemaname = $5;
 762                                         n->authid = $5;
 763                                         n->schemaElts = $6;
 764                                         $$ = (Node *)n;
 765                                 }
 766                 | CREATE SCHEMA ColId OptSchemaEltList
 767                                 {
 768                                         CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
 769                                         /* ...but not both */
 770                                         n->schemaname = $3;
 771                                         n->authid = NULL;
 772                                         n->schemaElts = $4;
 773                                         $$ = (Node *)n;
 774                                 }
 775                 ;
 776
 777 AlterSchemaStmt:  ALTER SCHEMA ColId
 778                                 {
 779                                         elog(ERROR, "ALTER SCHEMA not yet supported");
 780                                 }
 781                 ;
 782
 783 DropSchemaStmt:  DROP SCHEMA ColId
 784                                 {
 785                                         elog(ERROR, "DROP SCHEMA not yet supported");
 786                                 }
 787                 ;
 788
 789 OptSchemaName: ColId                                                            { $$ = $1; }
 790                 | /* EMPTY */                                                           { $$ = NULL; }
 791                 ;
 792
 793 OptSchemaEltList: OptSchemaEltList schema_stmt          { $$ = lappend($1, $2); }
 794                 | /* EMPTY */                                                           { $$ = NIL; }
 795                 ;
 796
 797 /*
 798  *      schema_stmt are the ones that can show up inside a CREATE SCHEMA
 799  *      statement (in addition to by themselves).
 800  */
 801 schema_stmt: CreateStmt
 802                 | GrantStmt
 803                 | ViewStmt
 804                 ;
 805
 806
 807 /*****************************************************************************
 808  *
 809  * Set PG internal variable
 810  *        SET name TO 'var_value'
 811  * Include SQL92 syntax (thomas 1997-10-22):
 812  *    SET TIME ZONE 'var_value'
 813  *
 814  *****************************************************************************/
 815
 816 VariableSetStmt:  SET set_rest
 817                                 {
 818                                         VariableSetStmt *n = $2;
 819                                         n->is_local = false;
 820                                         $$ = (Node *) n;
 821                                 }
 822                 | SET LOCAL set_rest
 823                                 {
 824                                         VariableSetStmt *n = $3;
 825                                         n->is_local = true;
 826                                         $$ = (Node *) n;
 827                                 }
 828                 | SET SESSION set_rest
 829                                 {
 830                                         VariableSetStmt *n = $3;
 831                                         n->is_local = false;
 832                                         $$ = (Node *) n;
 833                                 }
 834                 ;
 835
 836 set_rest:  ColId TO var_list_or_default
 837                                 {
 838                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 839                                         n->name = $1;
 840                                         n->args = $3;
 841                                         $$ = n;
 842                                 }
 843                 | ColId '=' var_list_or_default
 844                                 {
 845                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 846                                         n->name = $1;
 847                                         n->args = $3;
 848                                         $$ = n;
 849                                 }
 850                 | TIME ZONE zone_value
 851                                 {
 852                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 853                                         n->name = "timezone";
 854                                         if ($3 != NULL)
 855                                                 n->args = makeList1($3);
 856                                         $$ = n;
 857                                 }
 858                 | TRANSACTION ISOLATION LEVEL opt_level
 859                                 {
 860                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 861                                         n->name = "TRANSACTION ISOLATION LEVEL";
 862                                         n->args = makeList1(makeStringConst($4, NULL));
 863                                         $$ = n;
 864                                 }
 865         | SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL opt_level
 866                                 {
 867                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 868                                         n->name = "default_transaction_isolation";
 869                                         n->args = makeList1(makeStringConst($7, NULL));
 870                                         $$ = n;
 871                                 }
 872                 | NAMES opt_encoding
 873                                 {
 874                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 875                                         n->name = "client_encoding";
 876                                         if ($2 != NULL)
 877                                                 n->args = makeList1(makeStringConst($2, NULL));
 878                                         $$ = n;
 879                                 }
 880                 | SESSION AUTHORIZATION ColId_or_Sconst
 881                                 {
 882                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 883                                         n->name = "session_authorization";
 884                                         n->args = makeList1(makeStringConst($3, NULL));
 885                                         $$ = n;
 886                                 }
 887                 | SESSION AUTHORIZATION DEFAULT
 888                                 {
 889                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 890                                         n->name = "session_authorization";
 891                                         n->args = NIL;
 892                                         $$ = n;
 893                                 }
 894                 ;
 895
 896 var_list_or_default:  var_list
 897                                 { $$ = $1; }
 898                 | DEFAULT
 899                                 { $$ = NIL; }
 900                 ;
 901
 902 var_list:  var_value
 903                                 {       $$ = makeList1($1); }
 904                 | var_list ',' var_value
 905                                 {       $$ = lappend($1, $3); }
 906                 ;
 907
 908 var_value:  opt_boolean
 909                                 { $$ = makeStringConst($1, NULL); }
 910                 | ColId_or_Sconst
 911                                 { $$ = makeStringConst($1, NULL); }
 912                 | NumericOnly
 913                                 { $$ = makeAConst($1); }
 914                 ;
 915
 916 opt_level:  READ COMMITTED                                      { $$ = "read committed"; }
 917                 | SERIALIZABLE                                          { $$ = "serializable"; }
 918                 ;
 919
 920 opt_boolean:  TRUE_P                                            { $$ = "true"; }
 921                 | FALSE_P                                                       { $$ = "false"; }
 922                 | ON                                                            { $$ = "on"; }
 923                 | OFF                                                           { $$ = "off"; }
 924                 ;
 925
 926 /* Timezone values can be:
 927  * - a string such as 'pst8pdt'
 928  * - an identifier such as "pst8pdt"
 929  * - an integer or floating point number
 930  * - a time interval per SQL99
 931  * ColId gives reduce/reduce errors against ConstInterval and LOCAL,
 932  * so use IDENT and reject anything which is a reserved word.
 933  */
 934 zone_value:  Sconst
 935                         {
 936                                 $$ = makeStringConst($1, NULL);
 937                         }
 938                 | IDENT
 939                         {
 940                                 $$ = makeStringConst($1, NULL);
 941                         }
 942                 | ConstInterval Sconst opt_interval
 943                         {
 944                                 A_Const *n = (A_Const *) makeStringConst($2, $1);
 945                                 if ($3 != -1)
 946                                 {
 947                                         if (($3 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
 948                                                 elog(ERROR, "Time zone interval must be HOUR or HOUR TO MINUTE");
 949                                         n->typename->typmod = ((($3 & 0x7FFF) << 16) | 0xFFFF);
 950                                 }
 951                                 $$ = (Node *)n;
 952                         }
 953                 | ConstInterval '(' Iconst ')' Sconst opt_interval
 954                         {
 955                                 A_Const *n = (A_Const *) makeStringConst($5, $1);
 956                                 if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
 957                                         elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
 958                                                  $3, 0, MAX_INTERVAL_PRECISION);
 959                                 if ($6 != -1)
 960                                 {
 961                                         if (($6 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
 962                                                 elog(ERROR, "Time zone interval must be HOUR or HOUR TO MINUTE");
 963                                         n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
 964                                 }
 965                                 else
 966                                 {
 967                                         n->typename->typmod = ((0x7FFF << 16) | $3);
 968                                 }
 969
 970                                 $$ = (Node *)n;
 971                         }
 972                 | NumericOnly                                           { $$ = makeAConst($1); }
 973                 | DEFAULT                                                       { $$ = NULL; }
 974                 | LOCAL                                                         { $$ = NULL; }
 975                 ;
 976
 977 opt_encoding:  Sconst                                           { $$ = $1; }
 978         | DEFAULT                                                       { $$ = NULL; }
 979         | /*EMPTY*/                                                     { $$ = NULL; }
 980         ;
 981
 982 ColId_or_Sconst: ColId                                          { $$ = $1; }
 983                 | SCONST                                                        { $$ = $1; }
 984                 ;
 985
 986
 987 VariableShowStmt:  SHOW ColId
 988                                 {
 989                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 990                                         n->name = $2;
 991                                         $$ = (Node *) n;
 992                                 }
 993                 | SHOW TIME ZONE
 994                                 {
 995                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 996                                         n->name = "timezone";
 997                                         $$ = (Node *) n;
 998                                 }
 999                 | SHOW TRANSACTION ISOLATION LEVEL
1000                                 {
1001                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1002                                         n->name = "TRANSACTION ISOLATION LEVEL";
1003                                         $$ = (Node *) n;
1004                                 }
1005                 | SHOW SESSION AUTHORIZATION
1006                                 {
1007                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1008                                         n->name = "session_authorization";
1009                                         $$ = (Node *) n;
1010                                 }
1011                 | SHOW ALL
1012                                 {
1013                                         VariableShowStmt *n = makeNode(VariableShowStmt);
1014                                         n->name = "all";
1015                                         $$ = (Node *) n;
1016                                 }
1017                 ;
1018
1019 VariableResetStmt:      RESET ColId
1020                                 {
1021                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1022                                         n->name = $2;
1023                                         $$ = (Node *) n;
1024                                 }
1025                 | RESET TIME ZONE
1026                                 {
1027                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1028                                         n->name = "timezone";
1029                                         $$ = (Node *) n;
1030                                 }
1031                 | RESET TRANSACTION ISOLATION LEVEL
1032                                 {
1033                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1034                                         n->name = "TRANSACTION ISOLATION LEVEL";
1035                                         $$ = (Node *) n;
1036                                 }
1037                 | RESET SESSION AUTHORIZATION
1038                                 {
1039                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1040                                         n->name = "session_authorization";
1041                                         $$ = (Node *) n;
1042                                 }
1043                 | RESET ALL
1044                                 {
1045                                         VariableResetStmt *n = makeNode(VariableResetStmt);
1046                                         n->name = "all";
1047                                         $$ = (Node *) n;
1048                                 }
1049                 ;
1050
1051
1052 ConstraintsSetStmt:     SET CONSTRAINTS constraints_set_list constraints_set_mode
1053                                 {
1054                                         ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt);
1055                                         n->constraints = $3;
1056                                         n->deferred    = $4;
1057                                         $$ = (Node *) n;
1058                                 }
1059                 ;
1060
1061 constraints_set_list:   ALL                                     { $$ = NIL; }
1062                 | name_list                                                     { $$ = $1; }
1063                 ;
1064
1065 constraints_set_mode:   DEFERRED                        { $$ = TRUE; }
1066                 | IMMEDIATE                                                     { $$ = FALSE; }
1067                 ;
1068
1069
1070 /*
1071  * Checkpoint statement
1072  */
1073 CheckPointStmt: CHECKPOINT
1074                                 {
1075                                         CheckPointStmt *n = makeNode(CheckPointStmt);
1076                                         $$ = (Node *)n;
1077                                 }
1078                         ;
1079
1080 /*****************************************************************************
1081  *
1082  *      ALTER TABLE variations
1083  *
1084  *****************************************************************************/
1085
1086 AlterTableStmt:
1087 /* ALTER TABLE <relation> ADD [COLUMN] <coldef> */
1088                 ALTER TABLE relation_expr ADD opt_column columnDef
1089                                 {
1090                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1091                                         n->subtype = 'A';
1092                                         n->relation = $3;
1093                                         n->def = $6;
1094                                         $$ = (Node *)n;
1095                                 }
1096 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
1097                 | ALTER TABLE relation_expr ALTER opt_column ColId alter_column_default
1098                                 {
1099                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1100                                         n->subtype = 'T';
1101                                         n->relation = $3;
1102                                         n->name = $6;
1103                                         n->def = $7;
1104                                         $$ = (Node *)n;
1105                                 }
1106 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> DROP NOT NULL */
1107                 | ALTER TABLE relation_expr ALTER opt_column ColId DROP NOT NULL_P
1108                                 {
1109                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1110                                         n->subtype = 'N';
1111                                         n->relation = $3;
1112                                         n->name = $6;
1113                                         $$ = (Node *)n;
1114                                 }
1115 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET NOT NULL */
1116                 | ALTER TABLE relation_expr ALTER opt_column ColId SET NOT NULL_P
1117                                 {
1118                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1119                                         n->subtype = 'O';
1120                                         n->relation = $3;
1121                                         n->name = $6;
1122                                         $$ = (Node *)n;
1123                                 }
1124 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STATISTICS <Iconst> */
1125                 | ALTER TABLE relation_expr ALTER opt_column ColId SET STATISTICS Iconst
1126                                 {
1127                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1128                                         n->subtype = 'S';
1129                                         n->relation = $3;
1130                                         n->name = $6;
1131                                         n->def = (Node *) makeInteger($9);
1132                                         $$ = (Node *)n;
1133                                 }
1134 /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
1135         | ALTER TABLE relation_expr ALTER opt_column ColId SET STORAGE ColId
1136                 {
1137                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1138                                         n->subtype = 'M';
1139                                         n->relation = $3;
1140                                         n->name = $6;
1141                                         n->def = (Node *) makeString($9);
1142                                         $$ = (Node *)n;
1143                                 }
1144 /* ALTER TABLE <relation> DROP [COLUMN] <colname> {RESTRICT|CASCADE} */
1145                 | ALTER TABLE relation_expr DROP opt_column ColId drop_behavior
1146                                 {
1147                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1148                                         n->subtype = 'D';
1149                                         n->relation = $3;
1150                                         n->name = $6;
1151                                         n->behavior = $7;
1152                                         $$ = (Node *)n;
1153                                 }
1154 /* ALTER TABLE <relation> ADD CONSTRAINT ... */
1155                 | ALTER TABLE relation_expr ADD TableConstraint
1156                                 {
1157                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1158                                         n->subtype = 'C';
1159                                         n->relation = $3;
1160                                         n->def = $5;
1161                                         $$ = (Node *)n;
1162                                 }
1163 /* ALTER TABLE <relation> DROP CONSTRAINT <name> {RESTRICT|CASCADE} */
1164                 | ALTER TABLE relation_expr DROP CONSTRAINT name drop_behavior
1165                                 {
1166                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1167                                         n->subtype = 'X';
1168                                         n->relation = $3;
1169                                         n->name = $6;
1170                                         n->behavior = $7;
1171                                         $$ = (Node *)n;
1172                                 }
1173 /* ALTER TABLE <name> CREATE TOAST TABLE */
1174                 | ALTER TABLE qualified_name CREATE TOAST TABLE
1175                                 {
1176                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1177                                         n->subtype = 'E';
1178                                         $3->inhOpt = INH_NO;
1179                                         n->relation = $3;
1180                                         $$ = (Node *)n;
1181                                 }
1182 /* ALTER TABLE <name> OWNER TO UserId */
1183                 | ALTER TABLE qualified_name OWNER TO UserId
1184                                 {
1185                                         AlterTableStmt *n = makeNode(AlterTableStmt);
1186                                         n->subtype = 'U';
1187                                         $3->inhOpt = INH_NO;
1188                                         n->relation = $3;
1189                                         n->name = $6;
1190                                         $$ = (Node *)n;
1191                                 }
1192                 ;
1193
1194 alter_column_default:
1195                 SET DEFAULT a_expr
1196                         {
1197                                 /* Treat SET DEFAULT NULL the same as DROP DEFAULT */
1198                                 if (exprIsNullConstant($3))
1199                                         $$ = NULL;
1200                                 else
1201                                         $$ = $3;
1202                         }
1203                 | DROP DEFAULT                                  { $$ = NULL; }
1204         ;
1205
1206 drop_behavior: CASCADE                                  { $$ = CASCADE; }
1207                 | RESTRICT                                              { $$ = RESTRICT; }
1208         ;
1209
1210 opt_drop_behavior: CASCADE                              { $$ = CASCADE; }
1211                 | RESTRICT                                              { $$ = RESTRICT; }
1212                 | /* EMPTY */                                   { $$ = RESTRICT; /* default */ }
1213                 ;
1214
1215
1216
1217 /*****************************************************************************
1218  *
1219  *              QUERY :
1220  *                              close <optname>
1221  *
1222  *****************************************************************************/
1223
1224 ClosePortalStmt:  CLOSE opt_id
1225                                 {
1226                                         ClosePortalStmt *n = makeNode(ClosePortalStmt);
1227                                         n->portalname = $2;
1228                                         $$ = (Node *)n;
1229                                 }
1230                 ;
1231
1232 opt_id:  ColId                                                                  { $$ = $1; }
1233                 | /*EMPTY*/                                                             { $$ = NULL; }
1234                 ;
1235
1236
1237 /*****************************************************************************
1238  *
1239  *              QUERY :
1240  *                              COPY [BINARY] <relname> FROM/TO
1241  *                              [USING DELIMITERS <delimiter>]
1242  *
1243  *****************************************************************************/
1244
1245 CopyStmt:  COPY opt_binary qualified_name opt_with_copy copy_dirn copy_file_name copy_delimiter copy_null
1246                                 {
1247                                         CopyStmt *n = makeNode(CopyStmt);
1248                                         n->binary = $2;
1249                                         n->relation = $3;
1250                                         n->oids = $4;
1251                                         n->direction = $5;
1252                                         n->filename = $6;
1253                                         n->delimiter = $7;
1254                                         n->null_print = $8;
1255                                         $$ = (Node *)n;
1256                                 }
1257                 ;
1258
1259 copy_dirn:      TO
1260                                 { $$ = TO; }
1261                 | FROM
1262                                 { $$ = FROM; }
1263                 ;
1264
1265 /*
1266  * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
1267  * used depends on the direction. (It really doesn't make sense to copy from
1268  * stdout. We silently correct the "typo".               - AY 9/94
1269  */
1270 copy_file_name:  Sconst                                                 { $$ = $1; }
1271                 | STDIN                                                                 { $$ = NULL; }
1272                 | STDOUT                                                                { $$ = NULL; }
1273                 ;
1274
1275 opt_binary:  BINARY                                                             { $$ = TRUE; }
1276                 | /*EMPTY*/                                                             { $$ = FALSE; }
1277                 ;
1278
1279 opt_with_copy:  WITH OIDS                                               { $$ = TRUE; }
1280                 | /*EMPTY*/                                                             { $$ = FALSE; }
1281                 ;
1282
1283 /*
1284  * the default copy delimiter is tab but the user can configure it
1285  */
1286 copy_delimiter:  opt_using DELIMITERS Sconst    { $$ = $3; }
1287                 | /*EMPTY*/                                                             { $$ = "\t"; }
1288                 ;
1289
1290 opt_using:      USING                                                           { $$ = TRUE; }
1291                 | /*EMPTY*/                                                             { $$ = TRUE; }
1292                 ;
1293
1294 copy_null:  WITH NULL_P AS Sconst                               { $$ = $4; }
1295                 | /*EMPTY*/                                                             { $$ = "\\N"; }
1296                 ;
1297
1298 /*****************************************************************************
1299  *
1300  *              QUERY :
1301  *                              CREATE relname
1302  *
1303  *****************************************************************************/
1304
1305 CreateStmt:  CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptInherit OptWithOids
1306                                 {
1307                                         CreateStmt *n = makeNode(CreateStmt);
1308                                         $4->istemp = $2;
1309                                         n->relation = $4;
1310                                         n->tableElts = $6;
1311                                         n->inhRelations = $8;
1312                                         n->constraints = NIL;
1313                                         n->hasoids = $9;
1314                                         $$ = (Node *)n;
1315                                 }
1316                 ;
1317
1318 /*
1319  * Redundancy here is needed to avoid shift/reduce conflicts,
1320  * since TEMP is not a reserved word.  See also OptTempTableName.
1321  */
1322 OptTemp:      TEMPORARY                                         { $$ = TRUE; }
1323                         | TEMP                                                  { $$ = TRUE; }
1324                         | LOCAL TEMPORARY                               { $$ = TRUE; }
1325                         | LOCAL TEMP                                    { $$ = TRUE; }
1326                         | GLOBAL TEMPORARY
1327                                 {
1328                                         elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
1329                                         $$ = TRUE;
1330                                 }
1331                         | GLOBAL TEMP
1332                                 {
1333                                         elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
1334                                         $$ = TRUE;
1335                                 }
1336                         | /*EMPTY*/                                             { $$ = FALSE; }
1337                 ;
1338
1339 OptTableElementList:  OptTableElementList ',' OptTableElement
1340                                 {
1341                                         if ($3 != NULL)
1342                                                 $$ = lappend($1, $3);
1343                                         else
1344                                                 $$ = $1;
1345                                 }
1346                         | OptTableElement
1347                                 {
1348                                         if ($1 != NULL)
1349                                                 $$ = makeList1($1);
1350                                         else
1351                                                 $$ = NIL;
1352                                 }
1353                         | /*EMPTY*/                                                     { $$ = NIL; }
1354                 ;
1355
1356 OptTableElement:  columnDef                                             { $$ = $1; }
1357                         | TableConstraint                                       { $$ = $1; }
1358                 ;
1359
1360 columnDef:  ColId Typename ColQualList opt_collate
1361                                 {
1362                                         ColumnDef *n = makeNode(ColumnDef);
1363                                         n->colname = $1;
1364                                         n->typename = $2;
1365                                         n->constraints = $3;
1366
1367                                         if ($4 != NULL)
1368                                                 elog(NOTICE, "CREATE TABLE / COLLATE %s not yet implemented"
1369                                                          "; clause ignored", $4);
1370
1371                                         $$ = (Node *)n;
1372                                 }
1373                 ;
1374
1375 ColQualList:  ColQualList ColConstraint         { $$ = lappend($1, $2); }
1376                         | /*EMPTY*/                                             { $$ = NIL; }
1377                 ;
1378
1379 ColConstraint:
1380                 CONSTRAINT name ColConstraintElem
1381                                 {
1382                                         switch (nodeTag($3))
1383                                         {
1384                                                 case T_Constraint:
1385                                                         {
1386                                                                 Constraint *n = (Constraint *)$3;
1387                                                                 n->name = $2;
1388                                                         }
1389                                                         break;
1390                                                 case T_FkConstraint:
1391                                                         {
1392                                                                 FkConstraint *n = (FkConstraint *)$3;
1393                                                                 n->constr_name = $2;
1394                                                         }
1395                                                         break;
1396                                                 default:
1397                                                         break;
1398                                         }
1399                                         $$ = $3;
1400                                 }
1401                 | ColConstraintElem
1402                                 { $$ = $1; }
1403                 | ConstraintAttr
1404                                 { $$ = $1; }
1405                 ;
1406
1407 /* DEFAULT NULL is already the default for Postgres.
1408  * But define it here and carry it forward into the system
1409  * to make it explicit.
1410  * - thomas 1998-09-13
1411  *
1412  * WITH NULL and NULL are not SQL92-standard syntax elements,
1413  * so leave them out. Use DEFAULT NULL to explicitly indicate
1414  * that a column may have that value. WITH NULL leads to
1415  * shift/reduce conflicts with WITH TIME ZONE anyway.
1416  * - thomas 1999-01-08
1417  *
1418  * DEFAULT expression must be b_expr not a_expr to prevent shift/reduce
1419  * conflict on NOT (since NOT might start a subsequent NOT NULL constraint,
1420  * or be part of a_expr NOT LIKE or similar constructs).
1421  */
1422 ColConstraintElem:
1423                           NOT NULL_P
1424                                 {
1425                                         Constraint *n = makeNode(Constraint);
1426                                         n->contype = CONSTR_NOTNULL;
1427                                         n->name = NULL;
1428                                         n->raw_expr = NULL;
1429                                         n->cooked_expr = NULL;
1430                                         n->keys = NULL;
1431                                         $$ = (Node *)n;
1432                                 }
1433                         | NULL_P
1434                                 {
1435                                         Constraint *n = makeNode(Constraint);
1436                                         n->contype = CONSTR_NULL;
1437                                         n->name = NULL;
1438                                         n->raw_expr = NULL;
1439                                         n->cooked_expr = NULL;
1440                                         n->keys = NULL;
1441                                         $$ = (Node *)n;
1442                                 }
1443                         | UNIQUE
1444                                 {
1445                                         Constraint *n = makeNode(Constraint);
1446                                         n->contype = CONSTR_UNIQUE;
1447                                         n->name = NULL;
1448                                         n->raw_expr = NULL;
1449                                         n->cooked_expr = NULL;
1450                                         n->keys = NULL;
1451                                         $$ = (Node *)n;
1452                                 }
1453                         | PRIMARY KEY
1454                                 {
1455                                         Constraint *n = makeNode(Constraint);
1456                                         n->contype = CONSTR_PRIMARY;
1457                                         n->name = NULL;
1458                                         n->raw_expr = NULL;
1459                                         n->cooked_expr = NULL;
1460                                         n->keys = NULL;
1461                                         $$ = (Node *)n;
1462                                 }
1463                         | CHECK '(' a_expr ')'
1464                                 {
1465                                         Constraint *n = makeNode(Constraint);
1466                                         n->contype = CONSTR_CHECK;
1467                                         n->name = NULL;
1468                                         n->raw_expr = $3;
1469                                         n->cooked_expr = NULL;
1470                                         n->keys = NULL;
1471                                         $$ = (Node *)n;
1472                                 }
1473                         | DEFAULT b_expr
1474                                 {
1475                                         Constraint *n = makeNode(Constraint);
1476                                         n->contype = CONSTR_DEFAULT;
1477                                         n->name = NULL;
1478                                         if (exprIsNullConstant($2))
1479                                         {
1480                                                 /* DEFAULT NULL should be reported as empty expr */
1481                                                 n->raw_expr = NULL;
1482                                         }
1483                                         else
1484                                         {
1485                                                 n->raw_expr = $2;
1486                                         }
1487                                         n->cooked_expr = NULL;
1488                                         n->keys = NULL;
1489                                         $$ = (Node *)n;
1490                                 }
1491                         | REFERENCES qualified_name opt_column_list key_match key_actions
1492                                 {
1493                                         FkConstraint *n = makeNode(FkConstraint);
1494                                         n->constr_name          = NULL;
1495                                         n->pktable                      = $2;
1496                                         n->fk_attrs                     = NIL;
1497                                         n->pk_attrs                     = $3;
1498                                         n->match_type           = $4;
1499                                         n->actions                      = $5;
1500                                         n->deferrable           = FALSE;
1501                                         n->initdeferred         = FALSE;
1502                                         $$ = (Node *)n;
1503                                 }
1504                 ;
1505
1506 /*
1507  * ConstraintAttr represents constraint attributes, which we parse as if
1508  * they were independent constraint clauses, in order to avoid shift/reduce
1509  * conflicts (since NOT might start either an independent NOT NULL clause
1510  * or an attribute).  analyze.c is responsible for attaching the attribute
1511  * information to the preceding "real" constraint node, and for complaining
1512  * if attribute clauses appear in the wrong place or wrong combinations.
1513  *
1514  * See also ConstraintAttributeSpec, which can be used in places where
1515  * there is no parsing conflict.
1516  */
1517 ConstraintAttr: DEFERRABLE
1518                                 {
1519                                         Constraint *n = makeNode(Constraint);
1520                                         n->contype = CONSTR_ATTR_DEFERRABLE;
1521                                         $$ = (Node *)n;
1522                                 }
1523                         | NOT DEFERRABLE
1524                                 {
1525                                         Constraint *n = makeNode(Constraint);
1526                                         n->contype = CONSTR_ATTR_NOT_DEFERRABLE;
1527                                         $$ = (Node *)n;
1528                                 }
1529                         | INITIALLY DEFERRED
1530                                 {
1531                                         Constraint *n = makeNode(Constraint);
1532                                         n->contype = CONSTR_ATTR_DEFERRED;
1533                                         $$ = (Node *)n;
1534                                 }
1535                         | INITIALLY IMMEDIATE
1536                                 {
1537                                         Constraint *n = makeNode(Constraint);
1538                                         n->contype = CONSTR_ATTR_IMMEDIATE;
1539                                         $$ = (Node *)n;
1540                                 }
1541                 ;
1542
1543
1544 /* ConstraintElem specifies constraint syntax which is not embedded into
1545  *  a column definition. ColConstraintElem specifies the embedded form.
1546  * - thomas 1997-12-03
1547  */
1548 TableConstraint:  CONSTRAINT name ConstraintElem
1549                                 {
1550                                         switch (nodeTag($3))
1551                                         {
1552                                                 case T_Constraint:
1553                                                         {
1554                                                                 Constraint *n = (Constraint *)$3;
1555                                                                 n->name = $2;
1556                                                         }
1557                                                         break;
1558                                                 case T_FkConstraint:
1559                                                         {
1560                                                                 FkConstraint *n = (FkConstraint *)$3;
1561                                                                 n->constr_name = $2;
1562                                                         }
1563                                                         break;
1564                                                 default:
1565                                                         break;
1566                                         }
1567                                         $$ = $3;
1568                                 }
1569                 | ConstraintElem
1570                                 { $$ = $1; }
1571                 ;
1572
1573 ConstraintElem:  CHECK '(' a_expr ')'
1574                                 {
1575                                         Constraint *n = makeNode(Constraint);
1576                                         n->contype = CONSTR_CHECK;
1577                                         n->name = NULL;
1578                                         n->raw_expr = $3;
1579                                         n->cooked_expr = NULL;
1580                                         $$ = (Node *)n;
1581                                 }
1582                 | UNIQUE '(' columnList ')'
1583                                 {
1584                                         Constraint *n = makeNode(Constraint);
1585                                         n->contype = CONSTR_UNIQUE;
1586                                         n->name = NULL;
1587                                         n->raw_expr = NULL;
1588                                         n->cooked_expr = NULL;
1589                                         n->keys = $3;
1590                                         $$ = (Node *)n;
1591                                 }
1592                 | PRIMARY KEY '(' columnList ')'
1593                                 {
1594                                         Constraint *n = makeNode(Constraint);
1595                                         n->contype = CONSTR_PRIMARY;
1596                                         n->name = NULL;
1597                                         n->raw_expr = NULL;
1598                                         n->cooked_expr = NULL;
1599                                         n->keys = $4;
1600                                         $$ = (Node *)n;
1601                                 }
1602                 | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name opt_column_list
1603                                 key_match key_actions ConstraintAttributeSpec
1604                                 {
1605                                         FkConstraint *n = makeNode(FkConstraint);
1606                                         n->constr_name          = NULL;
1607                                         n->pktable                      = $7;
1608                                         n->fk_attrs                     = $4;
1609                                         n->pk_attrs                     = $8;
1610                                         n->match_type           = $9;
1611                                         n->actions                      = $10;
1612                                         n->deferrable           = ($11 & 1) != 0;
1613                                         n->initdeferred         = ($11 & 2) != 0;
1614                                         $$ = (Node *)n;
1615                                 }
1616                 ;
1617
1618 opt_column_list:  '(' columnList ')'                    { $$ = $2; }
1619                 | /*EMPTY*/                                                             { $$ = NIL; }
1620                 ;
1621
1622 columnList:  columnList ',' columnElem
1623                                 { $$ = lappend($1, $3); }
1624                 | columnElem
1625                                 { $$ = makeList1($1); }
1626                 ;
1627
1628 columnElem:  ColId
1629                                 {
1630                                         Ident *id = makeNode(Ident);
1631                                         id->name = $1;
1632                                         $$ = (Node *)id;
1633                                 }
1634                 ;
1635
1636 key_match:  MATCH FULL
1637                         {
1638                                 $$ = "FULL";
1639                         }
1640                 | MATCH PARTIAL
1641                         {
1642                                 elog(ERROR, "FOREIGN KEY/MATCH PARTIAL not yet implemented");
1643                                 $$ = "PARTIAL";
1644                         }
1645                 | /*EMPTY*/
1646                         {
1647                                 $$ = "UNSPECIFIED";
1648                         }
1649                 ;
1650
1651 key_actions:  key_delete                                { $$ = $1; }
1652                 | key_update                                    { $$ = $1; }
1653                 | key_delete key_update                 { $$ = $1 | $2; }
1654                 | key_update key_delete                 { $$ = $1 | $2; }
1655                 | /*EMPTY*/                                             { $$ = 0; }
1656                 ;
1657
1658 key_delete:  ON DELETE_P key_reference  { $$ = $3 << FKCONSTR_ON_DELETE_SHIFT; }
1659                 ;
1660
1661 key_update:  ON UPDATE key_reference    { $$ = $3 << FKCONSTR_ON_UPDATE_SHIFT; }
1662                 ;
1663
1664 key_reference:  NO ACTION                               { $$ = FKCONSTR_ON_KEY_NOACTION; }
1665                 | RESTRICT                                              { $$ = FKCONSTR_ON_KEY_RESTRICT; }
1666                 | CASCADE                                               { $$ = FKCONSTR_ON_KEY_CASCADE; }
1667                 | SET NULL_P                                    { $$ = FKCONSTR_ON_KEY_SETNULL; }
1668                 | SET DEFAULT                                   { $$ = FKCONSTR_ON_KEY_SETDEFAULT; }
1669                 ;
1670
1671 OptInherit:  INHERITS '(' qualified_name_list ')'       { $$ = $3; }
1672                 | /*EMPTY*/                                                                     { $$ = NIL; }
1673                 ;
1674
1675 OptWithOids:  WITH OIDS                                         { $$ = TRUE; }
1676                         | WITHOUT OIDS                                  { $$ = FALSE; }
1677                         | /*EMPTY*/                                             { $$ = TRUE; }
1678                 ;
1679
1680
1681 /*
1682  * Note: CREATE TABLE ... AS SELECT ... is just another spelling for
1683  * SELECT ... INTO.
1684  */
1685
1686 CreateAsStmt:  CREATE OptTemp TABLE qualified_name OptCreateAs AS SelectStmt
1687                                 {
1688                                         /*
1689                                          * When the SelectStmt is a set-operation tree, we must
1690                                          * stuff the INTO information into the leftmost component
1691                                          * Select, because that's where analyze.c will expect
1692                                          * to find it.  Similarly, the output column names must
1693                                          * be attached to that Select's target list.
1694                                          */
1695                                         SelectStmt *n = findLeftmostSelect((SelectStmt *) $7);
1696                                         if (n->into != NULL)
1697                                                 elog(ERROR, "CREATE TABLE AS may not specify INTO");
1698                                         $4->istemp = $2;
1699                                         n->into = $4;
1700                                         n->intoColNames = $5;
1701                                         $$ = $7;
1702                                 }
1703                 ;
1704
1705 OptCreateAs:  '(' CreateAsList ')'                              { $$ = $2; }
1706                         | /*EMPTY*/                                                     { $$ = NIL; }
1707                 ;
1708
1709 CreateAsList:  CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
1710                         | CreateAsElement                                       { $$ = makeList1($1); }
1711                 ;
1712
1713 CreateAsElement:  ColId
1714                                 {
1715                                         ColumnDef *n = makeNode(ColumnDef);
1716                                         n->colname = $1;
1717                                         n->typename = NULL;
1718                                         n->raw_default = NULL;
1719                                         n->cooked_default = NULL;
1720                                         n->is_not_null = FALSE;
1721                                         n->constraints = NULL;
1722                                         $$ = (Node *)n;
1723                                 }
1724                 ;
1725
1726
1727 /*****************************************************************************
1728  *
1729  *              QUERY :
1730  *                              CREATE SEQUENCE seqname
1731  *
1732  *****************************************************************************/
1733
1734 CreateSeqStmt:  CREATE OptTemp SEQUENCE qualified_name OptSeqList
1735                                 {
1736                                         CreateSeqStmt *n = makeNode(CreateSeqStmt);
1737                                         $4->istemp = $2;
1738                                         n->sequence = $4;
1739                                         n->options = $5;
1740                                         $$ = (Node *)n;
1741                                 }
1742                 ;
1743
1744 OptSeqList:  OptSeqList OptSeqElem
1745                                 { $$ = lappend($1, $2); }
1746                         |       { $$ = NIL; }
1747                 ;
1748
1749 OptSeqElem:  CACHE NumericOnly
1750                                 {
1751                                         $$ = makeNode(DefElem);
1752                                         $$->defname = "cache";
1753                                         $$->arg = (Node *)$2;
1754                                 }
1755                         | CYCLE
1756                                 {
1757                                         $$ = makeNode(DefElem);
1758                                         $$->defname = "cycle";
1759                                         $$->arg = (Node *)NULL;
1760                                 }
1761                         | INCREMENT NumericOnly
1762                                 {
1763                                         $$ = makeNode(DefElem);
1764                                         $$->defname = "increment";
1765                                         $$->arg = (Node *)$2;
1766                                 }
1767                         | MAXVALUE NumericOnly
1768                                 {
1769                                         $$ = makeNode(DefElem);
1770                                         $$->defname = "maxvalue";
1771                                         $$->arg = (Node *)$2;
1772                                 }
1773                         | MINVALUE NumericOnly
1774                                 {
1775                                         $$ = makeNode(DefElem);
1776                                         $$->defname = "minvalue";
1777                                         $$->arg = (Node *)$2;
1778                                 }
1779                         | START NumericOnly
1780                                 {
1781                                         $$ = makeNode(DefElem);
1782                                         $$->defname = "start";
1783                                         $$->arg = (Node *)$2;
1784                                 }
1785                 ;
1786
1787 NumericOnly:  FloatOnly                                 { $$ = $1; }
1788                         | IntegerOnly                           { $$ = $1; }
1789                 ;
1790
1791 FloatOnly:  FCONST
1792                                 {
1793                                         $$ = makeFloat($1);
1794                                 }
1795                         | '-' FCONST
1796                                 {
1797                                         $$ = makeFloat($2);
1798                                         doNegateFloat($$);
1799                                 }
1800                 ;
1801
1802 IntegerOnly:  Iconst
1803                                 {
1804                                         $$ = makeInteger($1);
1805                                 }
1806                         | '-' Iconst
1807                                 {
1808                                         $$ = makeInteger($2);
1809                                         $$->val.ival = - $$->val.ival;
1810                                 }
1811                 ;
1812
1813 /*****************************************************************************
1814  *
1815  *              QUERIES :
1816  *                              CREATE PROCEDURAL LANGUAGE ...
1817  *                              DROP PROCEDURAL LANGUAGE ...
1818  *
1819  *****************************************************************************/
1820
1821 CreatePLangStmt:  CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
1822                         HANDLER handler_name opt_validator opt_lancompiler
1823                         {
1824                                 CreatePLangStmt *n = makeNode(CreatePLangStmt);
1825                                 n->plname = $5;
1826                                 n->plhandler = $7;
1827                                 n->plvalidator = $8;
1828                                 n->plcompiler = $9;
1829                                 n->pltrusted = $2;
1830                                 $$ = (Node *)n;
1831                         }
1832                 ;
1833
1834 opt_trusted:  TRUSTED                   { $$ = TRUE; }
1835                         | /*EMPTY*/                     { $$ = FALSE; }
1836                 ;
1837
1838 /* This ought to be just func_name, but that causes reduce/reduce conflicts
1839  * (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
1840  * Work around by using name and dotted_name separately.
1841  */
1842 handler_name: name
1843                                 { $$ = makeList1(makeString($1)); }
1844                         | dotted_name
1845                                 { $$ = $1; }
1846                 ;
1847
1848 opt_lancompiler: LANCOMPILER Sconst { $$ = $2; }
1849                         | /*EMPTY*/                     { $$ = ""; }
1850                 ;
1851
1852 opt_validator: VALIDATOR handler_name { $$ = $2; }
1853                         | /*EMPTY*/ { $$ = NULL; }
1854                 ;
1855
1856 DropPLangStmt:  DROP opt_procedural LANGUAGE ColId_or_Sconst
1857                         {
1858                                 DropPLangStmt *n = makeNode(DropPLangStmt);
1859                                 n->plname = $4;
1860                                 $$ = (Node *)n;
1861                         }
1862                 ;
1863
1864 opt_procedural: PROCEDURAL              { $$ = TRUE; }
1865                         | /*EMPTY*/                     { $$ = TRUE; }
1866                 ;
1867
1868 /*****************************************************************************
1869  *
1870  *              QUERIES :
1871  *                              CREATE TRIGGER ...
1872  *                              DROP TRIGGER ...
1873  *
1874  *****************************************************************************/
1875
1876 CreateTrigStmt:  CREATE TRIGGER name TriggerActionTime TriggerEvents ON
1877                                 qualified_name TriggerForSpec EXECUTE PROCEDURE
1878                                 func_name '(' TriggerFuncArgs ')'
1879                                 {
1880                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
1881                                         n->trigname = $3;
1882                                         n->relation = $7;
1883                                         n->funcname = $11;
1884                                         n->args = $13;
1885                                         n->before = $4;
1886                                         n->row = $8;
1887                                         memcpy (n->actions, $5, 4);
1888                                         n->lang = NULL;         /* unused */
1889                                         n->text = NULL;         /* unused */
1890                                         n->attr = NULL;         /* unused */
1891                                         n->when = NULL;         /* unused */
1892
1893                                         n->isconstraint  = FALSE;
1894                                         n->deferrable    = FALSE;
1895                                         n->initdeferred  = FALSE;
1896                                         n->constrrel = NULL;
1897                                         $$ = (Node *)n;
1898                                 }
1899                 | CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
1900                                 qualified_name OptConstrFromTable
1901                                 ConstraintAttributeSpec
1902                                 FOR EACH ROW EXECUTE PROCEDURE
1903                                 func_name '(' TriggerFuncArgs ')'
1904                                 {
1905                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
1906                                         n->trigname = $4;
1907                                         n->relation = $8;
1908                                         n->funcname = $16;
1909                                         n->args = $18;
1910                                         n->before = FALSE;
1911                                         n->row = TRUE;
1912                                         memcpy (n->actions, $6, 4);
1913                                         n->lang = NULL;         /* unused */
1914                                         n->text = NULL;         /* unused */
1915                                         n->attr = NULL;         /* unused */
1916                                         n->when = NULL;         /* unused */
1917
1918                                         n->isconstraint  = TRUE;
1919                                         n->deferrable = ($10 & 1) != 0;
1920                                         n->initdeferred = ($10 & 2) != 0;
1921
1922                                         n->constrrel = $9;
1923                                         $$ = (Node *)n;
1924                                 }
1925                 ;
1926
1927 TriggerActionTime:  BEFORE                                              { $$ = TRUE; }
1928                         | AFTER                                                         { $$ = FALSE; }
1929                 ;
1930
1931 TriggerEvents:  TriggerOneEvent
1932                                 {
1933                                         char *e = palloc (4);
1934                                         e[0] = $1; e[1] = 0; $$ = e;
1935                                 }
1936                         | TriggerOneEvent OR TriggerOneEvent
1937                                 {
1938                                         char *e = palloc (4);
1939                                         e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
1940                                 }
1941                         | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
1942                                 {
1943                                         char *e = palloc (4);
1944                                         e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
1945                                         $$ = e;
1946                                 }
1947                 ;
1948
1949 TriggerOneEvent:  INSERT                                        { $$ = 'i'; }
1950                         | DELETE_P                                              { $$ = 'd'; }
1951                         | UPDATE                                                { $$ = 'u'; }
1952                 ;
1953
1954 TriggerForSpec:  FOR TriggerForOpt TriggerForType
1955                                 {
1956                                         $$ = $3;
1957                                 }
1958                 ;
1959
1960 TriggerForOpt:  EACH                                            { $$ = TRUE; }
1961                         | /*EMPTY*/                                             { $$ = FALSE; }
1962                 ;
1963
1964 TriggerForType:  ROW                                            { $$ = TRUE; }
1965                         | STATEMENT                                             { $$ = FALSE; }
1966                 ;
1967
1968 TriggerFuncArgs:  TriggerFuncArg
1969                                 { $$ = makeList1($1); }
1970                         | TriggerFuncArgs ',' TriggerFuncArg
1971                                 { $$ = lappend($1, $3); }
1972                         | /*EMPTY*/
1973                                 { $$ = NIL; }
1974                 ;
1975
1976 TriggerFuncArg:  ICONST
1977                                 {
1978                                         char buf[64];
1979                                         sprintf (buf, "%d", $1);
1980                                         $$ = makeString(pstrdup(buf));
1981                                 }
1982                         | FCONST
1983                                 {
1984                                         $$ = makeString($1);
1985                                 }
1986                         | Sconst
1987                                 {
1988                                         $$ = makeString($1);
1989                                 }
1990                         | BITCONST
1991                                 {
1992                                         $$ = makeString($1);
1993                                 }
1994                         | ColId
1995                                 {
1996                                         $$ = makeString($1);
1997                                 }
1998                 ;
1999
2000 OptConstrFromTable:                     /* Empty */
2001                                 {
2002                                         $$ = NULL;
2003                                 }
2004                 | FROM qualified_name
2005                                 {
2006                                         $$ = $2;
2007                                 }
2008                 ;
2009
2010 ConstraintAttributeSpec:  ConstraintDeferrabilitySpec
2011                         { $$ = $1; }
2012                 | ConstraintDeferrabilitySpec ConstraintTimeSpec
2013                         {
2014                                 if ($1 == 0 && $2 != 0)
2015                                         elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
2016                                 $$ = $1 | $2;
2017                         }
2018                 | ConstraintTimeSpec
2019                         {
2020                                 if ($1 != 0)
2021                                         $$ = 3;
2022                                 else
2023                                         $$ = 0;
2024                         }
2025                 | ConstraintTimeSpec ConstraintDeferrabilitySpec
2026                         {
2027                                 if ($2 == 0 && $1 != 0)
2028                                         elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
2029                                 $$ = $1 | $2;
2030                         }
2031                 | /* Empty */
2032                         { $$ = 0; }
2033                 ;
2034
2035 ConstraintDeferrabilitySpec: NOT DEFERRABLE
2036                         { $$ = 0; }
2037                 | DEFERRABLE
2038                         { $$ = 1; }
2039                 ;
2040
2041 ConstraintTimeSpec: INITIALLY IMMEDIATE
2042                         { $$ = 0; }
2043                 | INITIALLY DEFERRED
2044                         { $$ = 2; }
2045                 ;
2046
2047
2048 DropTrigStmt:  DROP TRIGGER name ON qualified_name
2049                                 {
2050                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
2051                                         n->relation = $5;
2052                                         n->property = $3;
2053                                         n->removeType = DROP_TRIGGER;
2054                                         $$ = (Node *) n;
2055                                 }
2056                 ;
2057
2058
2059 /*****************************************************************************
2060  *
2061  *              QUERIES :
2062  *                              CREATE ASSERTION ...
2063  *                              DROP ASSERTION ...
2064  *
2065  *****************************************************************************/
2066
2067 CreateAssertStmt:  CREATE ASSERTION name
2068                         CHECK '(' a_expr ')' ConstraintAttributeSpec
2069                                 {
2070                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
2071                                         n->trigname = $3;
2072                                         n->args = makeList1($6);
2073                                         n->isconstraint  = TRUE;
2074                                         n->deferrable = ($8 & 1) != 0;
2075                                         n->initdeferred = ($8 & 2) != 0;
2076
2077                                         elog(ERROR, "CREATE ASSERTION is not yet supported");
2078
2079                                         $$ = (Node *)n;
2080                                 }
2081                 ;
2082
2083 DropAssertStmt:  DROP ASSERTION name
2084                                 {
2085                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
2086                                         n->relation = NULL;
2087                                         n->property = $3;
2088                                         n->removeType = DROP_TRIGGER;
2089                                         elog(ERROR, "DROP ASSERTION is not yet supported");
2090                                         $$ = (Node *) n;
2091                                 }
2092                 ;
2093
2094
2095 /*****************************************************************************
2096  *
2097  *              QUERY :
2098  *                              define (aggregate,operator,type)
2099  *
2100  *****************************************************************************/
2101
2102 DefineStmt:  CREATE AGGREGATE func_name definition
2103                                 {
2104                                         DefineStmt *n = makeNode(DefineStmt);
2105                                         n->defType = AGGREGATE;
2106                                         n->defnames = $3;
2107                                         n->definition = $4;
2108                                         $$ = (Node *)n;
2109                                 }
2110                 | CREATE OPERATOR any_operator definition
2111                                 {
2112                                         DefineStmt *n = makeNode(DefineStmt);
2113                                         n->defType = OPERATOR;
2114                                         n->defnames = $3;
2115                                         n->definition = $4;
2116                                         $$ = (Node *)n;
2117                                 }
2118                 | CREATE TYPE_P any_name definition
2119                                 {
2120                                         DefineStmt *n = makeNode(DefineStmt);
2121                                         n->defType = TYPE_P;
2122                                         n->defnames = $3;
2123                                         n->definition = $4;
2124                                         $$ = (Node *)n;
2125                                 }
2126                 | CREATE CHARACTER SET opt_as any_name GET definition opt_collate
2127                                 {
2128                                         DefineStmt *n = makeNode(DefineStmt);
2129                                         n->defType = CHARACTER;
2130                                         n->defnames = $5;
2131                                         n->definition = $7;
2132                                         $$ = (Node *)n;
2133                                 }
2134                 ;
2135
2136 definition:  '(' def_list ')'                           { $$ = $2; }
2137                 ;
2138
2139 def_list:  def_elem                                                     { $$ = makeList1($1); }
2140                 | def_list ',' def_elem                         { $$ = lappend($1, $3); }
2141                 ;
2142
2143 def_elem:  ColLabel '=' def_arg
2144                                 {
2145                                         $$ = makeNode(DefElem);
2146                                         $$->defname = $1;
2147                                         $$->arg = (Node *)$3;
2148                                 }
2149                 | ColLabel
2150                                 {
2151                                         $$ = makeNode(DefElem);
2152                                         $$->defname = $1;
2153                                         $$->arg = (Node *)NULL;
2154                                 }
2155                 ;
2156
2157 /* Note: any simple identifier will be returned as a type name! */
2158 def_arg:  func_return                                   {  $$ = (Node *)$1; }
2159                 | all_Op                                                {  $$ = (Node *)makeString($1); }
2160                 | NumericOnly                                   {  $$ = (Node *)$1; }
2161                 | Sconst                                                {  $$ = (Node *)makeString($1); }
2162                 ;
2163
2164
2165 /*****************************************************************************
2166  *
2167  *              QUERY:
2168  *
2169  *              DROP itemtype itemname [, itemname ...]
2170  *
2171  *****************************************************************************/
2172
2173 DropStmt:  DROP drop_type any_name_list opt_drop_behavior
2174                                 {
2175                                         DropStmt *n = makeNode(DropStmt);
2176                                         n->removeType = $2;
2177                                         n->objects = $3;
2178                                         n->behavior = $4;
2179                                         $$ = (Node *)n;
2180                                 }
2181                 ;
2182
2183 drop_type: TABLE                                                                { $$ = DROP_TABLE; }
2184                 | SEQUENCE                                                              { $$ = DROP_SEQUENCE; }
2185                 | VIEW                                                                  { $$ = DROP_VIEW; }
2186                 | INDEX                                                                 { $$ = DROP_INDEX; }
2187                 | TYPE_P                                                                { $$ = DROP_TYPE; }
2188                 | DOMAIN_P                                                              { $$ = DROP_DOMAIN; }
2189                 ;
2190
2191 any_name_list:  any_name
2192                         { $$ = makeList1($1); }
2193                 | any_name_list ',' any_name
2194                         { $$ = lappend($1, $3); }
2195                 ;
2196
2197 any_name: ColId
2198                         { $$ = makeList1(makeString($1)); }
2199                 | dotted_name
2200                         { $$ = $1; }
2201                 ;
2202
2203 /*****************************************************************************
2204  *
2205  *              QUERY:
2206  *                              truncate table relname
2207  *
2208  *****************************************************************************/
2209
2210 TruncateStmt:  TRUNCATE opt_table qualified_name
2211                                 {
2212                                         TruncateStmt *n = makeNode(TruncateStmt);
2213                                         n->relation = $3;
2214                                         $$ = (Node *)n;
2215                                 }
2216                         ;
2217
2218 /*****************************************************************************
2219  *
2220  *  The COMMENT ON statement can take different forms based upon the type of
2221  *  the object associated with the comment. The form of the statement is:
2222  *
2223  *  COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW ]
2224  *               <objname> | AGGREGATE <aggname> (<aggtype>) | FUNCTION
2225  *               <funcname> (arg1, arg2, ...) | OPERATOR <op>
2226  *               (leftoperand_typ rightoperand_typ) | TRIGGER <triggername> ON
2227  *               <relname> | RULE <rulename> ON <relname> ] IS 'text'
2228  *
2229  *****************************************************************************/
2230
2231 CommentStmt:    COMMENT ON comment_type any_name IS comment_text
2232                         {
2233                                 CommentStmt *n = makeNode(CommentStmt);
2234                                 n->objtype = $3;
2235                                 n->objname = $4;
2236                                 n->objargs = NIL;
2237                                 n->comment = $6;
2238                                 $$ = (Node *) n;
2239                         }
2240                 | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')' IS comment_text
2241                         {
2242                                 CommentStmt *n = makeNode(CommentStmt);
2243                                 n->objtype = AGGREGATE;
2244                                 n->objname = $4;
2245                                 n->objargs = makeList1($6);
2246                                 n->comment = $9;
2247                                 $$ = (Node *) n;
2248                         }
2249                 | COMMENT ON FUNCTION func_name func_args IS comment_text
2250                         {
2251                                 CommentStmt *n = makeNode(CommentStmt);
2252                                 n->objtype = FUNCTION;
2253                                 n->objname = $4;
2254                                 n->objargs = $5;
2255                                 n->comment = $7;
2256                                 $$ = (Node *) n;
2257                         }
2258                 | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')' IS comment_text
2259                         {
2260                                 CommentStmt *n = makeNode(CommentStmt);
2261                                 n->objtype = OPERATOR;
2262                                 n->objname = $4;
2263                                 n->objargs = $6;
2264                                 n->comment = $9;
2265                                 $$ = (Node *) n;
2266                         }
2267                 | COMMENT ON TRIGGER name ON any_name IS comment_text
2268                         {
2269                                 CommentStmt *n = makeNode(CommentStmt);
2270                                 n->objtype = TRIGGER;
2271                                 n->objname = lappend($6, makeString($4));
2272                                 n->objargs = NIL;
2273                                 n->comment = $8;
2274                                 $$ = (Node *) n;
2275                         }
2276                 | COMMENT ON RULE name ON any_name IS comment_text
2277                         {
2278                                 CommentStmt *n = makeNode(CommentStmt);
2279                                 n->objtype = RULE;
2280                                 n->objname = lappend($6, makeString($4));
2281                                 n->objargs = NIL;
2282                                 n->comment = $8;
2283                                 $$ = (Node *) n;
2284                         }
2285                 | COMMENT ON RULE name IS comment_text
2286                         {
2287                                 /* Obsolete syntax supported for awhile for compatibility */
2288                                 CommentStmt *n = makeNode(CommentStmt);
2289                                 n->objtype = RULE;
2290                                 n->objname = makeList1(makeString($4));
2291                                 n->objargs = NIL;
2292                                 n->comment = $6;
2293                                 $$ = (Node *) n;
2294                         }
2295                 ;
2296
2297 comment_type:   COLUMN { $$ = COLUMN; }
2298                 | DATABASE { $$ = DATABASE; }
2299                 | SCHEMA { $$ = SCHEMA; }
2300                 | INDEX { $$ = INDEX; }
2301                 | SEQUENCE { $$ = SEQUENCE; }
2302                 | TABLE { $$ = TABLE; }
2303                 | DOMAIN_P { $$ = TYPE_P; }
2304                 | TYPE_P { $$ = TYPE_P; }
2305                 | VIEW { $$ = VIEW; }
2306                 ;
2307
2308 comment_text:   Sconst { $$ = $1; }
2309                 | NULL_P { $$ = NULL; }
2310                 ;
2311
2312 /*****************************************************************************
2313  *
2314  *              QUERY:
2315  *                      fetch/move [forward | backward] [ # | all ] [ in <portalname> ]
2316  *                      fetch [ forward | backward | absolute | relative ]
2317  *                            [ # | all | next | prior ] [ [ in | from ] <portalname> ]
2318  *
2319  *****************************************************************************/
2320
2321 FetchStmt:  FETCH direction fetch_how_many from_in name
2322                                 {
2323                                         FetchStmt *n = makeNode(FetchStmt);
2324                                         if ($2 == RELATIVE)
2325                                         {
2326                                                 if ($3 == 0)
2327                                                         elog(ERROR,"FETCH / RELATIVE at current position is not supported");
2328                                                 $2 = FORWARD;
2329                                         }
2330                                         if ($3 < 0)
2331                                         {
2332                                                 $3 = -$3;
2333                                                 $2 = (($2 == FORWARD)? BACKWARD: FORWARD);
2334                                         }
2335                                         n->direction = $2;
2336                                         n->howMany = $3;
2337                                         n->portalname = $5;
2338                                         n->ismove = FALSE;
2339                                         $$ = (Node *)n;
2340                                 }
2341                 | FETCH fetch_how_many from_in name
2342                                 {
2343                                         FetchStmt *n = makeNode(FetchStmt);
2344                                         if ($2 < 0)
2345                                         {
2346                                                 n->howMany = -$2;
2347                                                 n->direction = BACKWARD;
2348                                         }
2349                                         else
2350                                         {
2351                                                 n->direction = FORWARD;
2352                                                 n->howMany = $2;
2353                                         }
2354                                         n->portalname = $4;
2355                                         n->ismove = FALSE;
2356                                         $$ = (Node *)n;
2357                                 }
2358                 | FETCH direction from_in name
2359                                 {
2360                                         FetchStmt *n = makeNode(FetchStmt);
2361                                         if ($2 == RELATIVE)
2362                                         {
2363                                                 $2 = FORWARD;
2364                                         }
2365                                         n->direction = $2;
2366                                         n->howMany = 1;
2367                                         n->portalname = $4;
2368                                         n->ismove = FALSE;
2369                                         $$ = (Node *)n;
2370                                 }
2371                 | FETCH from_in name
2372                                 {
2373                                         FetchStmt *n = makeNode(FetchStmt);
2374                                         n->direction = FORWARD;
2375                                         n->howMany = 1;
2376                                         n->portalname = $3;
2377                                         n->ismove = FALSE;
2378                                         $$ = (Node *)n;
2379                                 }
2380                 | FETCH name
2381                                 {
2382                                         FetchStmt *n = makeNode(FetchStmt);
2383                                         n->direction = FORWARD;
2384                                         n->howMany = 1;
2385                                         n->portalname = $2;
2386                                         n->ismove = FALSE;
2387                                         $$ = (Node *)n;
2388                                 }
2389
2390                 | MOVE direction fetch_how_many from_in name
2391                                 {
2392                                         FetchStmt *n = makeNode(FetchStmt);
2393                                         if ($3 < 0)
2394                                         {
2395                                                 $3 = -$3;
2396                                                 $2 = (($2 == FORWARD)? BACKWARD: FORWARD);
2397                                         }
2398                                         n->direction = $2;
2399                                         n->howMany = $3;
2400                                         n->portalname = $5;
2401                                         n->ismove = TRUE;
2402                                         $$ = (Node *)n;
2403                                 }
2404                 | MOVE fetch_how_many from_in name
2405                                 {
2406                                         FetchStmt *n = makeNode(FetchStmt);
2407                                         if ($2 < 0)
2408                                         {
2409                                                 n->howMany = -$2;
2410                                                 n->direction = BACKWARD;
2411                                         }
2412                                         else
2413                                         {
2414                                                 n->direction = FORWARD;
2415                                                 n->howMany = $2;
2416                                         }
2417                                         n->portalname = $4;
2418                                         n->ismove = TRUE;
2419                                         $$ = (Node *)n;
2420                                 }
2421                 | MOVE direction from_in name
2422                                 {
2423                                         FetchStmt *n = makeNode(FetchStmt);
2424                                         n->direction = $2;
2425                                         n->howMany = 1;
2426                                         n->portalname = $4;
2427                                         n->ismove = TRUE;
2428                                         $$ = (Node *)n;
2429                                 }
2430                 |       MOVE from_in name
2431                                 {
2432                                         FetchStmt *n = makeNode(FetchStmt);
2433                                         n->direction = FORWARD;
2434                                         n->howMany = 1;
2435                                         n->portalname = $3;
2436                                         n->ismove = TRUE;
2437                                         $$ = (Node *)n;
2438                                 }
2439                 | MOVE name
2440                                 {
2441                                         FetchStmt *n = makeNode(FetchStmt);
2442                                         n->direction = FORWARD;
2443                                         n->howMany = 1;
2444                                         n->portalname = $2;
2445                                         n->ismove = TRUE;
2446                                         $$ = (Node *)n;
2447                                 }
2448                 ;
2449
2450 direction:      FORWARD                                 { $$ = FORWARD; }
2451                 | BACKWARD                                              { $$ = BACKWARD; }
2452                 | RELATIVE                                              { $$ = RELATIVE; }
2453                 | ABSOLUTE
2454                         {
2455                                 elog(NOTICE,"FETCH / ABSOLUTE not supported, using RELATIVE");
2456                                 $$ = RELATIVE;
2457                         }
2458                 ;
2459
2460 fetch_how_many:  Iconst                                 { $$ = $1; }
2461                 | '-' Iconst                                    { $$ = - $2; }
2462                 | ALL                                                   { $$ = 0; /* 0 means fetch all tuples*/ }
2463                 | NEXT                                                  { $$ = 1; }
2464                 | PRIOR                                                 { $$ = -1; }
2465                 ;
2466
2467 from_in:  IN_P                                                  { }
2468         | FROM                                                          { }
2469         ;
2470
2471
2472 /*****************************************************************************
2473  *
2474  * GRANT and REVOKE statements
2475  *
2476  *****************************************************************************/
2477
2478 GrantStmt:  GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option
2479                                 {
2480                                         GrantStmt *n = makeNode(GrantStmt);
2481                                         n->is_grant = true;
2482                                         n->privileges = $2;
2483                                         n->objtype = ($4)->objtype;
2484                                         n->objects = ($4)->objs;
2485                                         n->grantees = $6;
2486                                         $$ = (Node*)n;
2487                                 }
2488                 ;
2489
2490 RevokeStmt:  REVOKE opt_revoke_grant_option privileges ON privilege_target FROM grantee_list
2491                                 {
2492                                         GrantStmt *n = makeNode(GrantStmt);
2493                                         n->is_grant = false;
2494                                         n->privileges = $3;
2495                                         n->objtype = ($5)->objtype;
2496                                         n->objects = ($5)->objs;
2497                                         n->grantees = $7;
2498                                         $$ = (Node *)n;
2499                                 }
2500                 ;
2501
2502
2503 /* either ALL [PRIVILEGES] or a list of individual privileges */
2504 privileges: privilege_list { $$ = $1; }
2505                 | ALL { $$ = makeListi1(ACL_ALL_RIGHTS); }
2506                 | ALL PRIVILEGES { $$ = makeListi1(ACL_ALL_RIGHTS); }
2507                 ;
2508
2509 privilege_list: privilege { $$ = makeListi1($1); }
2510                 | privilege_list ',' privilege { $$ = lappendi($1, $3); }
2511                 ;
2512
2513 /* Not all of these privilege types apply to all objects, but that
2514  * gets sorted out later.
2515  */
2516 privilege: SELECT    { $$ = ACL_SELECT; }
2517                 | INSERT     { $$ = ACL_INSERT; }
2518                 | UPDATE     { $$ = ACL_UPDATE; }
2519                 | DELETE_P   { $$ = ACL_DELETE; }
2520                 | RULE       { $$ = ACL_RULE; }
2521                 | REFERENCES { $$ = ACL_REFERENCES; }
2522                 | TRIGGER    { $$ = ACL_TRIGGER; }
2523                 | EXECUTE    { $$ = ACL_EXECUTE; }
2524                 | USAGE      { $$ = ACL_USAGE; }
2525                 | CREATE     { $$ = ACL_CREATE; }
2526                 | TEMPORARY  { $$ = ACL_CREATE_TEMP; }
2527                 | TEMP       { $$ = ACL_CREATE_TEMP; }
2528                 ;
2529
2530
2531 /* Don't bother trying to fold the first two rules into one using
2532    opt_table.  You're going to get conflicts. */
2533 privilege_target: qualified_name_list
2534                                 {
2535                                         PrivTarget *n = makeNode(PrivTarget);
2536                                         n->objtype = ACL_OBJECT_RELATION;
2537                                         n->objs = $1;
2538                                         $$ = n;
2539                                 }
2540                         | TABLE qualified_name_list
2541                                 {
2542                                         PrivTarget *n = makeNode(PrivTarget);
2543                                         n->objtype = ACL_OBJECT_RELATION;
2544                                         n->objs = $2;
2545                                         $$ = n;
2546                                 }
2547                         | FUNCTION function_with_argtypes_list
2548                                 {
2549                                         PrivTarget *n = makeNode(PrivTarget);
2550                                         n->objtype = ACL_OBJECT_FUNCTION;
2551                                         n->objs = $2;
2552                                         $$ = n;
2553                                 }
2554                         | DATABASE name_list
2555                                 {
2556                                         PrivTarget *n = makeNode(PrivTarget);
2557                                         n->objtype = ACL_OBJECT_DATABASE;
2558                                         n->objs = $2;
2559                                         $$ = n;
2560                                 }
2561                         | LANGUAGE name_list
2562                                 {
2563                                         PrivTarget *n = makeNode(PrivTarget);
2564                                         n->objtype = ACL_OBJECT_LANGUAGE;
2565                                         n->objs = $2;
2566                                         $$ = n;
2567                                 }
2568                         | SCHEMA name_list
2569                                 {
2570                                         PrivTarget *n = makeNode(PrivTarget);
2571                                         n->objtype = ACL_OBJECT_NAMESPACE;
2572                                         n->objs = $2;
2573                                         $$ = n;
2574                                 }
2575                 ;
2576
2577
2578 grantee_list: grantee                                   { $$ = makeList1($1); }
2579                 | grantee_list ',' grantee              { $$ = lappend($1, $3); }
2580                 ;
2581
2582 grantee:  ColId
2583                                 {
2584                                         PrivGrantee *n = makeNode(PrivGrantee);
2585                                         /* This hack lets us avoid reserving PUBLIC as a keyword */
2586                                         if (strcmp($1, "public") == 0)
2587                                                 n->username = NULL;
2588                                         else
2589                                                 n->username = $1;
2590                                         n->groupname = NULL;
2591                                         $$ = (Node *)n;
2592                                 }
2593                 | GROUP_P ColId
2594                                 {
2595                                         PrivGrantee *n = makeNode(PrivGrantee);
2596                                         /* Treat GROUP PUBLIC as a synonym for PUBLIC */
2597                                         if (strcmp($2, "public") == 0)
2598                                                 n->groupname = NULL;
2599                                         else
2600                                                 n->groupname = $2;
2601                                         n->username = NULL;
2602                                         $$ = (Node *)n;
2603                                 }
2604                 ;
2605
2606
2607 opt_grant_grant_option: WITH GRANT OPTION
2608                                 {
2609                                         elog(ERROR, "grant options are not implemented");
2610                                 }
2611                 | /*EMPTY*/
2612                 ;
2613
2614 opt_revoke_grant_option: GRANT OPTION FOR
2615                                 {
2616                                         elog(ERROR, "grant options are not implemented");
2617                                 }
2618                 | /*EMPTY*/
2619                 ;
2620
2621
2622 function_with_argtypes_list: function_with_argtypes
2623                                 { $$ = makeList1($1); }
2624                 | function_with_argtypes_list ',' function_with_argtypes
2625                                 { $$ = lappend($1, $3); }
2626                 ;
2627
2628 function_with_argtypes: func_name func_args
2629                                 {
2630                                         FuncWithArgs *n = makeNode(FuncWithArgs);
2631                                         n->funcname = $1;
2632                                         n->funcargs = $2;
2633                                         $$ = (Node *)n;
2634                                 }
2635                 ;
2636
2637
2638 /*****************************************************************************
2639  *
2640  *              QUERY:
2641  *                              create index <indexname> on <relname>
2642  *                                [ using <access> ] "(" (<col> with <op>)+ ")"
2643  *                                [ where <predicate> ]
2644  *
2645  *****************************************************************************/
2646
2647 IndexStmt:      CREATE index_opt_unique INDEX index_name ON qualified_name
2648                         access_method_clause '(' index_params ')' where_clause
2649                                 {
2650                                         IndexStmt *n = makeNode(IndexStmt);
2651                                         n->unique = $2;
2652                                         n->idxname = $4;
2653                                         n->relation = $6;
2654                                         n->accessMethod = $7;
2655                                         n->indexParams = $9;
2656                                         n->whereClause = $11;
2657                                         $$ = (Node *)n;
2658                                 }
2659                 ;
2660
2661 index_opt_unique:  UNIQUE                                               { $$ = TRUE; }
2662                 | /*EMPTY*/                                                             { $$ = FALSE; }
2663                 ;
2664
2665 access_method_clause:  USING access_method              { $$ = $2; }
2666                 /* If btree changes as our default, update pg_get_indexdef() */
2667                 | /*EMPTY*/                                                             { $$ = DEFAULT_INDEX_TYPE; }
2668                 ;
2669
2670 index_params:  index_list                                               { $$ = $1; }
2671                 | func_index                                                    { $$ = makeList1($1); }
2672                 ;
2673
2674 index_list:  index_list ',' index_elem                  { $$ = lappend($1, $3); }
2675                 | index_elem                                                    { $$ = makeList1($1); }
2676                 ;
2677
2678 func_index:  func_name '(' name_list ')' opt_class
2679                                 {
2680                                         $$ = makeNode(IndexElem);
2681                                         $$->name = NULL;
2682                                         $$->funcname = $1;
2683                                         $$->args = $3;
2684                                         $$->opclass = $5;
2685                                 }
2686                   ;
2687
2688 index_elem:  attr_name opt_class
2689                                 {
2690                                         $$ = makeNode(IndexElem);
2691                                         $$->name = $1;
2692                                         $$->funcname = NIL;
2693                                         $$->args = NIL;
2694                                         $$->opclass = $2;
2695                                 }
2696                 ;
2697
2698 opt_class:  any_name
2699                                 {
2700                                         /*
2701                                          * Release 7.0 removed network_ops, timespan_ops, and
2702                                          * datetime_ops, so we suppress it from being passed to
2703                                          * the parser so the default *_ops is used.  This can be
2704                                          * removed in some later release.  bjm 2000/02/07
2705                                          *
2706                                          * Release 7.1 removes lztext_ops, so suppress that too
2707                                          * for a while.  tgl 2000/07/30
2708                                          *
2709                                          * Release 7.2 renames timestamp_ops to timestamptz_ops,
2710                                          * so suppress that too for awhile.  I'm starting to
2711                                          * think we need a better approach.  tgl 2000/10/01
2712                                          */
2713                                         if (length($1) == 1)
2714                                         {
2715                                                 char   *claname = strVal(lfirst($1));
2716
2717                                                 if (strcmp(claname, "network_ops") != 0 &&
2718                                                         strcmp(claname, "timespan_ops") != 0 &&
2719                                                         strcmp(claname, "datetime_ops") != 0 &&
2720                                                         strcmp(claname, "lztext_ops") != 0 &&
2721                                                         strcmp(claname, "timestamp_ops") != 0)
2722                                                         $$ = $1;
2723                                                 else
2724                                                         $$ = NIL;
2725                                         }
2726                                         else
2727                                                 $$ = $1;
2728                                 }
2729                 | USING any_name                                                { $$ = $2; }
2730                 | /*EMPTY*/                                                             { $$ = NIL; }
2731                 ;
2732
2733 /*****************************************************************************
2734  *
2735  *              QUERY:
2736  *                              execute recipe <recipeName>
2737  *
2738  *****************************************************************************/
2739
2740 /* NOT USED
2741 RecipeStmt:  EXECUTE RECIPE recipe_name
2742                                 {
2743                                         RecipeStmt *n = makeNode(RecipeStmt);
2744                                         n->recipeName = $3;
2745                                         $$ = (Node *)n;
2746                                 }
2747                 ;
2748 */
2749
2750 /*****************************************************************************
2751  *
2752  *              QUERY:
2753  *                              create [or replace] function <fname>
2754  *                                              [(<type-1> { , <type-n>})]
2755  *                                              returns <type-r>
2756  *                                              as <filename or code in language as appropriate>
2757  *                                              language <lang> [with parameters]
2758  *
2759  *****************************************************************************/
2760
2761 CreateFunctionStmt:     CREATE opt_or_replace FUNCTION func_name func_args
2762                          RETURNS func_return createfunc_opt_list opt_definition
2763                                 {
2764                                         CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
2765                                         n->replace = $2;
2766                                         n->funcname = $4;
2767                                         n->argTypes = $5;
2768                                         n->returnType = $7;
2769                                         n->options = $8;
2770                                         n->withClause = $9;
2771                                         $$ = (Node *)n;
2772                                 };
2773
2774 opt_or_replace:  OR REPLACE                                             { $$ = TRUE; }
2775                 | /*EMPTY*/                                                             { $$ = FALSE; }
2776                 ;
2777
2778 func_args:  '(' func_args_list ')'                              { $$ = $2; }
2779                 | '(' ')'                                                               { $$ = NIL; }
2780                 ;
2781
2782 func_args_list:  func_arg
2783                                 {       $$ = makeList1($1); }
2784                 | func_args_list ',' func_arg
2785                                 {       $$ = lappend($1, $3); }
2786                 ;
2787
2788 func_arg:  opt_arg func_type
2789                                 {
2790                                         /* We can catch over-specified arguments here if we want to,
2791                                          * but for now better to silently swallow typmod, etc.
2792                                          * - thomas 2000-03-22
2793                                          */
2794                                         $$ = $2;
2795                                 }
2796                 | func_type
2797                                 {
2798                                         $$ = $1;
2799                                 }
2800                 ;
2801
2802 opt_arg:  IN_P
2803                                 {
2804                                         $$ = FALSE;
2805                                 }
2806                 | OUT_P
2807                                 {
2808                                         elog(ERROR, "CREATE FUNCTION / OUT parameters are not supported");
2809                                         $$ = TRUE;
2810                                 }
2811                 | INOUT
2812                                 {
2813                                         elog(ERROR, "CREATE FUNCTION / INOUT parameters are not supported");
2814                                         $$ = FALSE;
2815                                 }
2816                 ;
2817
2818 func_return:  func_type
2819                                 {
2820                                         /* We can catch over-specified arguments here if we want to,
2821                                          * but for now better to silently swallow typmod, etc.
2822                                          * - thomas 2000-03-22
2823                                          */
2824                                         $$ = $1;
2825                                 }
2826                 ;
2827
2828 /*
2829  * We would like to make the second production here be ColId attrs etc,
2830  * but that causes reduce/reduce conflicts.  type_name is next best choice.
2831  */
2832 func_type:      Typename
2833                                 {
2834                                         $$ = $1;
2835                                 }
2836                 | type_name attrs '%' TYPE_P
2837                                 {
2838                                         $$ = makeNode(TypeName);
2839                                         $$->names = lcons(makeString($1), $2);
2840                                         $$->pct_type = true;
2841                                         $$->typmod = -1;
2842                                 }
2843                 ;
2844
2845
2846 createfunc_opt_list: createfunc_opt_item
2847                 { $$ = makeList1($1); }
2848         | createfunc_opt_list createfunc_opt_item
2849                 { $$ = lappend($1, $2); }
2850         ;
2851
2852 createfunc_opt_item: AS func_as
2853                                 {
2854                                         $$ = makeNode(DefElem);
2855                                         $$->defname = "as";
2856                                         $$->arg = (Node *)$2;
2857                                 }
2858                 | LANGUAGE ColId_or_Sconst
2859                                 {
2860                                         $$ = makeNode(DefElem);
2861                                         $$->defname = "language";
2862                                         $$->arg = (Node *)makeString($2);
2863                                 }
2864                 | IMMUTABLE
2865                                 {
2866                                         $$ = makeNode(DefElem);
2867                                         $$->defname = "volatility";
2868                                         $$->arg = (Node *)makeString("immutable");
2869                                 }
2870                 | STABLE
2871                                 {
2872                                         $$ = makeNode(DefElem);
2873                                         $$->defname = "volatility";
2874                                         $$->arg = (Node *)makeString("stable");
2875                                 }
2876                 | VOLATILE
2877                                 {
2878                                         $$ = makeNode(DefElem);
2879                                         $$->defname = "volatility";
2880                                         $$->arg = (Node *)makeString("volatile");
2881                                 }
2882                 | CALLED ON NULL_P INPUT
2883                                 {
2884                                         $$ = makeNode(DefElem);
2885                                         $$->defname = "strict";
2886                                         $$->arg = (Node *)makeInteger(FALSE);
2887                                 }
2888                 | RETURNS NULL_P ON NULL_P INPUT
2889                                 {
2890                                         $$ = makeNode(DefElem);
2891                                         $$->defname = "strict";
2892                                         $$->arg = (Node *)makeInteger(TRUE);
2893                                 }
2894                 | STRICT
2895                                 {
2896                                         $$ = makeNode(DefElem);
2897                                         $$->defname = "strict";
2898                                         $$->arg = (Node *)makeInteger(TRUE);
2899                                 }
2900                 | EXTERNAL SECURITY DEFINER
2901                                 {
2902                                         $$ = makeNode(DefElem);
2903                                         $$->defname = "security";
2904                                         $$->arg = (Node *)makeInteger(TRUE);
2905                                 }
2906                 | EXTERNAL SECURITY INVOKER
2907                                 {
2908                                         $$ = makeNode(DefElem);
2909                                         $$->defname = "security";
2910                                         $$->arg = (Node *)makeInteger(FALSE);
2911                                 }
2912                 | SECURITY DEFINER
2913                                 {
2914                                         $$ = makeNode(DefElem);
2915                                         $$->defname = "security";
2916                                         $$->arg = (Node *)makeInteger(TRUE);
2917                                 }
2918                 | SECURITY INVOKER
2919                                 {
2920                                         $$ = makeNode(DefElem);
2921                                         $$->defname = "security";
2922                                         $$->arg = (Node *)makeInteger(FALSE);
2923                                 }
2924                 | IMPLICIT CAST
2925                                 {
2926                                         $$ = makeNode(DefElem);
2927                                         $$->defname = "implicit";
2928                                         $$->arg = (Node *)makeInteger(TRUE);
2929                                 }
2930                 ;
2931
2932 func_as: Sconst
2933                                 {   $$ = makeList1(makeString($1)); }
2934                 | Sconst ',' Sconst
2935                                 {       $$ = makeList2(makeString($1), makeString($3)); }
2936                 ;
2937
2938 opt_definition:  WITH definition                                { $$ = $2; }
2939                 | /*EMPTY*/                                                             { $$ = NIL; }
2940                 ;
2941
2942
2943 /*****************************************************************************
2944  *
2945  *              QUERY:
2946  *
2947  *              DROP FUNCTION funcname (arg1, arg2, ...)
2948  *              DROP AGGREGATE aggname (aggtype)
2949  *              DROP OPERATOR opname (leftoperand_typ rightoperand_typ)
2950  *
2951  *****************************************************************************/
2952
2953 RemoveFuncStmt:  DROP FUNCTION func_name func_args
2954                                 {
2955                                         RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
2956                                         n->funcname = $3;
2957                                         n->args = $4;
2958                                         $$ = (Node *)n;
2959                                 }
2960                 ;
2961
2962 RemoveAggrStmt:  DROP AGGREGATE func_name '(' aggr_argtype ')'
2963                                 {
2964                                                 RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
2965                                                 n->aggname = $3;
2966                                                 n->aggtype = $5;
2967                                                 $$ = (Node *)n;
2968                                 }
2969                 ;
2970
2971 aggr_argtype:  Typename                                                 { $$ = $1; }
2972                 | '*'                                                                   { $$ = NULL; }
2973                 ;
2974
2975 RemoveOperStmt:  DROP OPERATOR any_operator '(' oper_argtypes ')'
2976                                 {
2977                                         RemoveOperStmt *n = makeNode(RemoveOperStmt);
2978                                         n->opname = $3;
2979                                         n->args = $5;
2980                                         $$ = (Node *)n;
2981                                 }
2982                 ;
2983
2984 oper_argtypes:  Typename
2985                                 {
2986                                    elog(ERROR,"parser: argument type missing (use NONE for unary operators)");
2987                                 }
2988                 | Typename ',' Typename
2989                                 { $$ = makeList2($1, $3); }
2990                 | NONE ',' Typename                     /* left unary */
2991                                 { $$ = makeList2(NULL, $3); }
2992                 | Typename ',' NONE                     /* right unary */
2993                                 { $$ = makeList2($1, NULL); }
2994                 ;
2995
2996 any_operator: all_Op
2997                         { $$ = makeList1(makeString($1)); }
2998                 | ColId '.' any_operator
2999                         { $$ = lcons(makeString($1), $3); }
3000                 ;
3001
3002
3003 /*****************************************************************************
3004  *
3005  *              QUERY:
3006  *
3007  *              REINDEX type <typename> [FORCE] [ALL]
3008  *
3009  *****************************************************************************/
3010
3011 ReindexStmt:  REINDEX reindex_type qualified_name opt_force
3012                                 {
3013                                         ReindexStmt *n = makeNode(ReindexStmt);
3014                                         n->reindexType = $2;
3015                                         n->relation = $3;
3016                                         n->name = NULL;
3017                                         n->force = $4;
3018                                         $$ = (Node *)n;
3019                                 }
3020                 | REINDEX DATABASE name opt_force
3021                                 {
3022                                         ReindexStmt *n = makeNode(ReindexStmt);
3023                                         n->reindexType = DATABASE;
3024                                         n->name = $3;
3025                                         n->relation = NULL;
3026                                         n->force = $4;
3027                                         $$ = (Node *)n;
3028                                 }
3029                 ;
3030
3031 reindex_type:  INDEX                                                            {  $$ = INDEX; }
3032                 | TABLE                                                                         {  $$ = TABLE; }
3033                 ;
3034
3035 opt_force:      FORCE                                                                   {  $$ = TRUE; }
3036                 | /* EMPTY */                                                           {  $$ = FALSE; }
3037                 ;
3038
3039
3040 /*****************************************************************************
3041  *
3042  *              QUERY:
3043  *                              rename <attrname1> in <relname> [*] to <attrname2>
3044  *                              rename <relname1> to <relname2>
3045  *
3046  *****************************************************************************/
3047
3048 RenameStmt:  ALTER TABLE relation_expr RENAME opt_column opt_name TO name
3049                                 {
3050                                         RenameStmt *n = makeNode(RenameStmt);
3051                                         n->relation = $3;
3052                                         n->oldname = $6;
3053                                         n->newname = $8;
3054                                         if ($6 == NULL)
3055                                                 n->renameType = RENAME_TABLE;
3056                                         else
3057                                                 n->renameType = RENAME_COLUMN;
3058                                         $$ = (Node *)n;
3059                                 }
3060                 | ALTER TRIGGER name ON relation_expr RENAME TO name
3061                                 {
3062                                         RenameStmt *n = makeNode(RenameStmt);
3063                                         n->relation = $5;
3064                                         n->oldname = $3;
3065                                         n->newname = $8;
3066                                         n->renameType = RENAME_TRIGGER;
3067                                         $$ = (Node *)n;
3068                                 }
3069                 ;
3070
3071 opt_name:  name                                                 { $$ = $1; }
3072                 | /*EMPTY*/                                             { $$ = NULL; }
3073                 ;
3074
3075 opt_column:  COLUMN                                             { $$ = COLUMN; }
3076                 | /*EMPTY*/                                             { $$ = 0; }
3077                 ;
3078
3079
3080 /*****************************************************************************
3081  *
3082  *              QUERY:  Define Rewrite Rule
3083  *
3084  *****************************************************************************/
3085
3086 RuleStmt:  CREATE RULE name AS
3087                         { QueryIsRule=TRUE; }
3088                         ON event TO qualified_name where_clause
3089                         DO opt_instead RuleActionList
3090                                 {
3091                                         RuleStmt *n = makeNode(RuleStmt);
3092                                         n->relation = $9;
3093                                         n->rulename = $3;
3094                                         n->whereClause = $10;
3095                                         n->event = $7;
3096                                         n->instead = $12;
3097                                         n->actions = $13;
3098                                         $$ = (Node *)n;
3099                                         QueryIsRule=FALSE;
3100                                 }
3101                 ;
3102
3103 RuleActionList:  NOTHING                                { $$ = NIL; }
3104                 | RuleActionStmt                                { $$ = makeList1($1); }
3105                 | '(' RuleActionMulti ')'               { $$ = $2; }
3106                 ;
3107
3108 /* the thrashing around here is to discard "empty" statements... */
3109 RuleActionMulti:  RuleActionMulti ';' RuleActionStmtOrEmpty
3110                                 { if ($3 != (Node *) NULL)
3111                                         $$ = lappend($1, $3);
3112                                   else
3113                                         $$ = $1;
3114                                 }
3115                 | RuleActionStmtOrEmpty
3116                                 { if ($1 != (Node *) NULL)
3117                                         $$ = makeList1($1);
3118                                   else
3119                                         $$ = NIL;
3120                                 }
3121                 ;
3122
3123 RuleActionStmt: SelectStmt
3124                 | InsertStmt
3125                 | UpdateStmt
3126                 | DeleteStmt
3127                 | NotifyStmt
3128                 ;
3129
3130 RuleActionStmtOrEmpty:  RuleActionStmt
3131                 |       /*EMPTY*/
3132                                 { $$ = (Node *)NULL; }
3133                 ;
3134
3135 /* change me to select, update, etc. some day */
3136 event:  SELECT                                                  { $$ = CMD_SELECT; }
3137                 | UPDATE                                                { $$ = CMD_UPDATE; }
3138                 | DELETE_P                                              { $$ = CMD_DELETE; }
3139                 | INSERT                                                { $$ = CMD_INSERT; }
3140                  ;
3141
3142 opt_instead:  INSTEAD                                   { $$ = TRUE; }
3143                 | /*EMPTY*/                                             { $$ = FALSE; }
3144                 ;
3145
3146
3147 DropRuleStmt:  DROP RULE name ON qualified_name
3148                                 {
3149                                         DropPropertyStmt *n = makeNode(DropPropertyStmt);
3150                                         n->relation = $5;
3151                                         n->property = $3;
3152                                         n->removeType = DROP_RULE;
3153                                         $$ = (Node *) n;
3154                                 }
3155                 ;
3156
3157
3158 /*****************************************************************************
3159  *
3160  *              QUERY:
3161  *                              NOTIFY <qualified_name> can appear both in rule bodies and
3162  *                              as a query-level command
3163  *
3164  *****************************************************************************/
3165
3166 NotifyStmt:  NOTIFY qualified_name
3167                                 {
3168                                         NotifyStmt *n = makeNode(NotifyStmt);
3169                                         n->relation = $2;
3170                                         $$ = (Node *)n;
3171                                 }
3172                 ;
3173
3174 ListenStmt:  LISTEN qualified_name
3175                                 {
3176                                         ListenStmt *n = makeNode(ListenStmt);
3177                                         n->relation = $2;
3178                                         $$ = (Node *)n;
3179                                 }
3180                 ;
3181
3182 UnlistenStmt:  UNLISTEN qualified_name
3183                                 {
3184                                         UnlistenStmt *n = makeNode(UnlistenStmt);
3185                                         n->relation = $2;
3186                                         $$ = (Node *)n;
3187                                 }
3188                 | UNLISTEN '*'
3189                                 {
3190                                         UnlistenStmt *n = makeNode(UnlistenStmt);
3191                                         n->relation = makeNode(RangeVar);
3192                                         n->relation->relname = "*";
3193                                         n->relation->schemaname = NULL;
3194                                         $$ = (Node *)n;
3195                                 }
3196                 ;
3197
3198
3199 /*****************************************************************************
3200  *
3201  *              Transactions:
3202  *
3203  *      BEGIN / COMMIT / ROLLBACK
3204  *      (also older versions END / ABORT)
3205  *
3206  *****************************************************************************/
3207
3208 TransactionStmt: ABORT_TRANS opt_trans
3209                                 {
3210                                         TransactionStmt *n = makeNode(TransactionStmt);
3211                                         n->command = ROLLBACK;
3212                                         $$ = (Node *)n;
3213                                 }
3214                 | BEGIN_TRANS opt_trans
3215                                 {
3216                                         TransactionStmt *n = makeNode(TransactionStmt);
3217                                         n->command = BEGIN_TRANS;
3218                                         $$ = (Node *)n;
3219                                 }
3220                 | COMMIT opt_trans
3221                                 {
3222                                         TransactionStmt *n = makeNode(TransactionStmt);
3223                                         n->command = COMMIT;
3224                                         $$ = (Node *)n;
3225                                 }
3226                 | COMMIT opt_trans opt_chain
3227                                 {
3228                                         TransactionStmt *n = makeNode(TransactionStmt);
3229                                         n->command = COMMIT;
3230                                         $$ = (Node *)n;
3231                                 }
3232                 | END_TRANS opt_trans
3233                                 {
3234                                         TransactionStmt *n = makeNode(TransactionStmt);
3235                                         n->command = COMMIT;
3236                                         $$ = (Node *)n;
3237                                 }
3238                 | ROLLBACK opt_trans
3239                                 {
3240                                         TransactionStmt *n = makeNode(TransactionStmt);
3241                                         n->command = ROLLBACK;
3242                                         $$ = (Node *)n;
3243                                 }
3244                 | ROLLBACK opt_trans opt_chain
3245                                 {
3246                                         TransactionStmt *n = makeNode(TransactionStmt);
3247                                         n->command = ROLLBACK;
3248                                         $$ = (Node *)n;
3249                                 }
3250                 ;
3251
3252 opt_trans: WORK                                                                 { $$ = TRUE; }
3253                 | TRANSACTION                                                   { $$ = TRUE; }
3254                 | /*EMPTY*/                                                             { $$ = TRUE; }
3255                 ;
3256
3257 opt_chain: AND NO CHAIN
3258                                 { $$ = FALSE; }
3259                 | AND CHAIN
3260                                 {
3261                                         /* SQL99 asks that conforming dbs reject AND CHAIN
3262                                          * if they don't support it. So we can't just ignore it.
3263                                          * - thomas 2000-08-06
3264                                          */
3265                                         elog(ERROR, "COMMIT / CHAIN not yet supported");
3266                                         $$ = TRUE;
3267                                 }
3268                 ;
3269
3270
3271 /*****************************************************************************
3272  *
3273  *              QUERY:
3274  *                              define view <viewname> '('target-list ')' [where <quals> ]
3275  *
3276  *****************************************************************************/
3277
3278 ViewStmt:  CREATE VIEW qualified_name opt_column_list AS SelectStmt
3279                                 {
3280                                         ViewStmt *n = makeNode(ViewStmt);
3281                                         n->view = $3;
3282                                         n->aliases = $4;
3283                                         n->query = (Query *) $6;
3284                                         $$ = (Node *)n;
3285                                 }
3286                 ;
3287
3288
3289 /*****************************************************************************
3290  *
3291  *              QUERY:
3292  *                              load "filename"
3293  *
3294  *****************************************************************************/
3295
3296 LoadStmt:  LOAD file_name
3297                                 {
3298                                         LoadStmt *n = makeNode(LoadStmt);
3299                                         n->filename = $2;
3300                                         $$ = (Node *)n;
3301                                 }
3302                 ;
3303
3304
3305 /*****************************************************************************
3306  *
3307  *              CREATE DATABASE
3308  *
3309  *****************************************************************************/
3310
3311 CreatedbStmt:  CREATE DATABASE database_name opt_with createdb_opt_list
3312                                 {
3313                                         CreatedbStmt *n = makeNode(CreatedbStmt);
3314                                         List   *l;
3315
3316                                         n->dbname = $3;
3317                                         /* set default options */
3318                                         n->dbowner = NULL;
3319                                         n->dbpath = NULL;
3320                                         n->dbtemplate = NULL;
3321                                         n->encoding = -1;
3322                                         /* process additional options */
3323                                         foreach(l, $5)
3324                                         {
3325                                                 List   *optitem = (List *) lfirst(l);
3326
3327                                                 switch (lfirsti(optitem))
3328                                                 {
3329                                                         case 1:
3330                                                                 n->dbpath = (char *) lsecond(optitem);
3331                                                                 break;
3332                                                         case 2:
3333                                                                 n->dbtemplate = (char *) lsecond(optitem);
3334                                                                 break;
3335                                                         case 3:
3336                                                                 n->encoding = lfirsti(lnext(optitem));
3337                                                                 break;
3338                                                         case 4:
3339                                                                 n->dbowner = (char *) lsecond(optitem);
3340                                                                 break;
3341                                                 }
3342                                         }
3343                                         $$ = (Node *)n;
3344                                 }
3345                 | CREATE DATABASE database_name
3346                                 {
3347                                         CreatedbStmt *n = makeNode(CreatedbStmt);
3348                                         n->dbname = $3;
3349                                         n->dbowner = NULL;
3350                                         n->dbpath = NULL;
3351                                         n->dbtemplate = NULL;
3352                                         n->encoding = -1;
3353                                         $$ = (Node *)n;
3354                                 }
3355                 ;
3356
3357 createdb_opt_list:  createdb_opt_item
3358                                 { $$ = makeList1($1); }
3359                 | createdb_opt_list createdb_opt_item
3360                                 { $$ = lappend($1, $2); }
3361                 ;
3362
3363 /*
3364  * createdb_opt_item returns 2-element lists, with the first element
3365  * being an integer code to indicate which item was specified.
3366  */
3367 createdb_opt_item:  LOCATION opt_equal Sconst
3368                                 {
3369                                         $$ = lconsi(1, makeList1($3));
3370                                 }
3371                 | LOCATION opt_equal DEFAULT
3372                                 {
3373                                         $$ = lconsi(1, makeList1(NULL));
3374                                 }
3375                 | TEMPLATE opt_equal name
3376                                 {
3377                                         $$ = lconsi(2, makeList1($3));
3378                                 }
3379                 | TEMPLATE opt_equal DEFAULT
3380                                 {
3381                                         $$ = lconsi(2, makeList1(NULL));
3382                                 }
3383                 | ENCODING opt_equal Sconst
3384                                 {
3385                                         int             encoding;
3386 #ifdef MULTIBYTE
3387                                         encoding = pg_char_to_encoding($3);
3388                                         if (encoding == -1)
3389                                                 elog(ERROR, "%s is not a valid encoding name", $3);
3390 #else
3391                                         if (strcasecmp($3, GetStandardEncodingName()) != 0)
3392                                                 elog(ERROR, "Multi-byte support is not enabled");
3393                                         encoding = GetStandardEncoding();
3394 #endif
3395                                         $$ = lconsi(3, makeListi1(encoding));
3396                                 }
3397                 | ENCODING opt_equal Iconst
3398                                 {
3399 #ifdef MULTIBYTE
3400                                         if (!pg_get_enconv_by_encoding($3))
3401                                                 elog(ERROR, "%d is not a valid encoding code", $3);
3402 #else
3403                                         if ($3 != GetStandardEncoding())
3404                                                 elog(ERROR, "Multi-byte support is not enabled");
3405 #endif
3406                                         $$ = lconsi(3, makeListi1($3));
3407                                 }
3408                 | ENCODING opt_equal DEFAULT
3409                                 {
3410                                         $$ = lconsi(3, makeListi1(-1));
3411                                 }
3412                 | OWNER opt_equal name
3413                                 {
3414                                         $$ = lconsi(4, makeList1($3));
3415                                 }
3416                 | OWNER opt_equal DEFAULT
3417                                 {
3418                                         $$ = lconsi(4, makeList1(NULL));
3419                                 }
3420                 ;
3421
3422 /*
3423  *      Though the equals sign doesn't match other WITH options, pg_dump uses
3424  *  equals for backward compability, and it doesn't seem worth removing it.
3425  *  2002-02-25
3426  */
3427 opt_equal: '='                                                          { $$ = TRUE; }
3428                 | /*EMPTY*/                                                     { $$ = FALSE; }
3429                 ;
3430
3431
3432 /*****************************************************************************
3433  *
3434  *              ALTER DATABASE
3435  *
3436  *****************************************************************************/
3437
3438 AlterDatabaseSetStmt: ALTER DATABASE database_name SET set_rest
3439                                 {
3440                                         AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
3441                                         n->dbname = $3;
3442                                         n->variable = $5->name;
3443                                         n->value = $5->args;
3444                                         $$ = (Node *)n;
3445                                 }
3446                                 | ALTER DATABASE database_name VariableResetStmt
3447                                 {
3448                                         AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
3449                                         n->dbname = $3;
3450                                         n->variable = ((VariableResetStmt *)$4)->name;
3451                                         n->value = NIL;
3452                                         $$ = (Node *)n;
3453                                 }
3454                 ;
3455
3456
3457 /*****************************************************************************
3458  *
3459  *              DROP DATABASE
3460  *
3461  *****************************************************************************/
3462
3463 DropdbStmt:     DROP DATABASE database_name
3464                                 {
3465                                         DropdbStmt *n = makeNode(DropdbStmt);
3466                                         n->dbname = $3;
3467                                         $$ = (Node *)n;
3468                                 }
3469                 ;
3470
3471
3472 /*****************************************************************************
3473  *
3474  * Manipulate a domain
3475  *
3476  *****************************************************************************/
3477
3478 CreateDomainStmt:  CREATE DOMAIN_P any_name opt_as Typename ColQualList opt_collate
3479                                 {
3480                                         CreateDomainStmt *n = makeNode(CreateDomainStmt);
3481                                         n->domainname = $3;
3482                                         n->typename = $5;
3483                                         n->constraints = $6;
3484
3485                                         if ($7 != NULL)
3486                                                 elog(NOTICE,"CREATE DOMAIN / COLLATE %s not yet "
3487                                                         "implemented; clause ignored", $7);
3488                                         $$ = (Node *)n;
3489                                 }
3490                 ;
3491
3492 opt_as: AS      {$$ = TRUE; }
3493         | /* EMPTY */   {$$ = FALSE; }
3494         ;
3495
3496
3497 /*****************************************************************************
3498  *
3499  *              QUERY:
3500  *                              cluster <index_name> on <qualified_name>
3501  *
3502  *****************************************************************************/
3503
3504 ClusterStmt:  CLUSTER index_name ON qualified_name
3505                                 {
3506                                    ClusterStmt *n = makeNode(ClusterStmt);
3507                                    n->relation = $4;
3508                                    n->indexname = $2;
3509                                    $$ = (Node*)n;
3510                                 }
3511                 ;
3512
3513 /*****************************************************************************
3514  *
3515  *              QUERY:
3516  *                              vacuum
3517  *                              analyze
3518  *
3519  *****************************************************************************/
3520
3521 VacuumStmt:  VACUUM opt_full opt_freeze opt_verbose
3522                                 {
3523                                         VacuumStmt *n = makeNode(VacuumStmt);
3524                                         n->vacuum = true;
3525                                         n->analyze = false;
3526                                         n->full = $2;
3527                                         n->freeze = $3;
3528                                         n->verbose = $4;
3529                                         n->relation = NULL;
3530                                         n->va_cols = NIL;
3531                                         $$ = (Node *)n;
3532                                 }
3533                 | VACUUM opt_full opt_freeze opt_verbose qualified_name
3534                                 {
3535                                         VacuumStmt *n = makeNode(VacuumStmt);
3536                                         n->vacuum = true;
3537                                         n->analyze = false;
3538                                         n->full = $2;
3539                                         n->freeze = $3;
3540                                         n->verbose = $4;
3541                                         n->relation = $5;
3542                                         n->va_cols = NIL;
3543                                         $$ = (Node *)n;
3544                                 }
3545                 | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
3546                                 {
3547                                         VacuumStmt *n = (VacuumStmt *) $5;
3548                                         n->vacuum = true;
3549                                         n->full = $2;
3550                                         n->freeze = $3;
3551                                         n->verbose |= $4;
3552                                         $$ = (Node *)n;
3553                                 }
3554                 ;
3555
3556 AnalyzeStmt:  analyze_keyword opt_verbose
3557                                 {
3558                                         VacuumStmt *n = makeNode(VacuumStmt);
3559                                         n->vacuum = false;
3560                                         n->analyze = true;
3561                                         n->full = false;
3562                                         n->freeze = false;
3563                                         n->verbose = $2;
3564                                         n->relation = NULL;
3565                                         n->va_cols = NIL;
3566                                         $$ = (Node *)n;
3567                                 }
3568                 | analyze_keyword opt_verbose qualified_name opt_name_list
3569                                 {
3570                                         VacuumStmt *n = makeNode(VacuumStmt);
3571                                         n->vacuum = false;
3572                                         n->analyze = true;
3573                                         n->full = false;
3574                                         n->freeze = false;
3575                                         n->verbose = $2;
3576                                         n->relation = $3;
3577                                         n->va_cols = $4;
3578                                         $$ = (Node *)n;
3579                                 }
3580                 ;
3581
3582 analyze_keyword:  ANALYZE                                               { $$ = TRUE; }
3583                 |         ANALYSE /* British */                         { $$ = TRUE; }
3584                 ;
3585
3586 opt_verbose:  VERBOSE                                                   { $$ = TRUE; }
3587                 | /*EMPTY*/                                                             { $$ = FALSE; }
3588                 ;
3589
3590 opt_full:  FULL                                                                 { $$ = TRUE; }
3591                 | /*EMPTY*/                                                             { $$ = FALSE; }
3592                 ;
3593
3594 opt_freeze:  FREEZE                                                             { $$ = TRUE; }
3595                 | /*EMPTY*/                                                             { $$ = FALSE; }
3596                 ;
3597
3598 opt_name_list:  '(' name_list ')'                               { $$ = $2; }
3599                 | /*EMPTY*/                                                             { $$ = NIL; }
3600                 ;
3601
3602
3603 /*****************************************************************************
3604  *
3605  *              QUERY:
3606  *                              EXPLAIN query
3607  *                              EXPLAIN ANALYZE query
3608  *
3609  *****************************************************************************/
3610
3611 ExplainStmt:  EXPLAIN opt_verbose OptimizableStmt
3612                                 {
3613                                         ExplainStmt *n = makeNode(ExplainStmt);
3614                                         n->verbose = $2;
3615                                         n->analyze = FALSE;
3616                                         n->query = (Query*)$3;
3617                                         $$ = (Node *)n;
3618                                 }
3619                         | EXPLAIN analyze_keyword opt_verbose OptimizableStmt
3620                                 {
3621                                         ExplainStmt *n = makeNode(ExplainStmt);
3622                                         n->verbose = $3;
3623                                         n->analyze = TRUE;
3624                                         n->query = (Query*)$4;
3625                                         $$ = (Node *)n;
3626                                 }
3627                 ;
3628
3629
3630 /*****************************************************************************
3631  *                                                                                                                                                       *
3632  *              Optimizable Stmts:                                                                                                       *
3633  *                                                                                                                                                       *
3634  *              one of the five queries processed by the planner                                         *
3635  *                                                                                                                                                       *
3636  *              [ultimately] produces query-trees as specified                                           *
3637  *              in the query-spec document in ~postgres/ref                                                      *
3638  *                                                                                                                                                       *
3639  *****************************************************************************/
3640
3641 OptimizableStmt:  SelectStmt
3642                 | CursorStmt
3643                 | UpdateStmt
3644                 | InsertStmt
3645                 | DeleteStmt                                    /* by default all are $$=$1 */
3646                 ;
3647
3648
3649 /*****************************************************************************
3650  *
3651  *              QUERY:
3652  *                              INSERT STATEMENTS
3653  *
3654  *****************************************************************************/
3655
3656 InsertStmt:  INSERT INTO qualified_name insert_rest
3657                                 {
3658                                         $4->relation = $3;
3659                                         $$ = (Node *) $4;
3660                                 }
3661                 ;
3662
3663 insert_rest:  VALUES '(' insert_target_list ')'
3664                                 {
3665                                         $$ = makeNode(InsertStmt);
3666                                         $$->cols = NIL;
3667                                         $$->targetList = $3;
3668                                         $$->selectStmt = NULL;
3669                                 }
3670                 | DEFAULT VALUES
3671                                 {
3672                                         $$ = makeNode(InsertStmt);
3673                                         $$->cols = NIL;
3674                                         $$->targetList = NIL;
3675                                         $$->selectStmt = NULL;
3676                                 }
3677                 | SelectStmt
3678                                 {
3679                                         $$ = makeNode(InsertStmt);
3680                                         $$->cols = NIL;
3681                                         $$->targetList = NIL;
3682                                         $$->selectStmt = $1;
3683                                 }
3684                 | '(' insert_column_list ')' VALUES '(' insert_target_list ')'
3685                                 {
3686                                         $$ = makeNode(InsertStmt);
3687                                         $$->cols = $2;
3688                                         $$->targetList = $6;
3689                                         $$->selectStmt = NULL;
3690                                 }
3691                 | '(' insert_column_list ')' SelectStmt
3692                                 {
3693                                         $$ = makeNode(InsertStmt);
3694                                         $$->cols = $2;
3695                                         $$->targetList = NIL;
3696                                         $$->selectStmt = $4;
3697                                 }
3698                 ;
3699
3700 insert_column_list:  insert_column_list ',' insert_column_item
3701                                 { $$ = lappend($1, $3); }
3702                 | insert_column_item
3703                                 { $$ = makeList1($1); }
3704                 ;
3705
3706 insert_column_item:  ColId opt_indirection
3707                                 {
3708                                         ResTarget *n = makeNode(ResTarget);
3709                                         n->name = $1;
3710                                         n->indirection = $2;
3711                                         n->val = NULL;
3712                                         $$ = (Node *)n;
3713                                 }
3714                 ;
3715
3716
3717 /*****************************************************************************
3718  *
3719  *              QUERY:
3720  *                              DELETE STATEMENTS
3721  *
3722  *****************************************************************************/
3723
3724 DeleteStmt:  DELETE_P FROM relation_expr where_clause
3725                                 {
3726                                         DeleteStmt *n = makeNode(DeleteStmt);
3727                                         n->relation = $3;
3728                                         n->whereClause = $4;
3729                                         $$ = (Node *)n;
3730                                 }
3731                 ;
3732
3733 LockStmt:       LOCK_P opt_table qualified_name_list opt_lock
3734                                 {
3735                                         LockStmt *n = makeNode(LockStmt);
3736
3737                                         n->relations = $3;
3738                                         n->mode = $4;
3739                                         $$ = (Node *)n;
3740                                 }
3741                 ;
3742
3743 opt_lock:  IN_P lock_type MODE  { $$ = $2; }
3744                 | /*EMPTY*/                             { $$ = AccessExclusiveLock; }
3745                 ;
3746
3747 lock_type:  ACCESS SHARE                { $$ = AccessShareLock; }
3748                 | ROW SHARE                             { $$ = RowShareLock; }
3749                 | ROW EXCLUSIVE                 { $$ = RowExclusiveLock; }
3750                 | SHARE UPDATE EXCLUSIVE { $$ = ShareUpdateExclusiveLock; }
3751                 | SHARE                                 { $$ = ShareLock; }
3752                 | SHARE ROW EXCLUSIVE   { $$ = ShareRowExclusiveLock; }
3753                 | EXCLUSIVE                             { $$ = ExclusiveLock; }
3754                 | ACCESS EXCLUSIVE              { $$ = AccessExclusiveLock; }
3755                 ;
3756
3757
3758 /*****************************************************************************
3759  *
3760  *              QUERY:
3761  *                              UpdateStmt (UPDATE)
3762  *
3763  *****************************************************************************/
3764
3765 UpdateStmt:  UPDATE relation_expr
3766                           SET update_target_list
3767                           from_clause
3768                           where_clause
3769                                 {
3770                                         UpdateStmt *n = makeNode(UpdateStmt);
3771                                         n->relation = $2;
3772                                         n->targetList = $4;
3773                                         n->fromClause = $5;
3774                                         n->whereClause = $6;
3775                                         $$ = (Node *)n;
3776                                 }
3777                 ;
3778
3779
3780 /*****************************************************************************
3781  *
3782  *              QUERY:
3783  *                              CURSOR STATEMENTS
3784  *
3785  *****************************************************************************/
3786 CursorStmt:  DECLARE name opt_cursor CURSOR FOR SelectStmt
3787                                 {
3788                                         SelectStmt *n = (SelectStmt *)$6;
3789                                         n->portalname = $2;
3790                                         n->binary = $3;
3791                                         $$ = $6;
3792                                 }
3793                 ;
3794
3795 opt_cursor:  BINARY                                             { $$ = TRUE; }
3796                 | INSENSITIVE                                   { $$ = FALSE; }
3797                 | SCROLL                                                { $$ = FALSE; }
3798                 | INSENSITIVE SCROLL                    { $$ = FALSE; }
3799                 | /*EMPTY*/                                             { $$ = FALSE; }
3800                 ;
3801
3802 /*****************************************************************************
3803  *
3804  *              QUERY:
3805  *                              SELECT STATEMENTS
3806  *
3807  *****************************************************************************/
3808
3809 /* A complete SELECT statement looks like this.
3810  *
3811  * The rule returns either a single SelectStmt node or a tree of them,
3812  * representing a set-operation tree.
3813  *
3814  * There is an ambiguity when a sub-SELECT is within an a_expr and there
3815  * are excess parentheses: do the parentheses belong to the sub-SELECT or
3816  * to the surrounding a_expr?  We don't really care, but yacc wants to know.
3817  * To resolve the ambiguity, we are careful to define the grammar so that
3818  * the decision is staved off as long as possible: as long as we can keep
3819  * absorbing parentheses into the sub-SELECT, we will do so, and only when
3820  * it's no longer possible to do that will we decide that parens belong to
3821  * the expression.  For example, in "SELECT (((SELECT 2)) + 3)" the extra
3822  * parentheses are treated as part of the sub-select.  The necessity of doing
3823  * it that way is shown by "SELECT (((SELECT 2)) UNION SELECT 2)".  Had we
3824  * parsed "((SELECT 2))" as an a_expr, it'd be too late to go back to the
3825  * SELECT viewpoint when we see the UNION.
3826  *
3827  * This approach is implemented by defining a nonterminal select_with_parens,
3828  * which represents a SELECT with at least one outer layer of parentheses,
3829  * and being careful to use select_with_parens, never '(' SelectStmt ')',
3830  * in the expression grammar.  We will then have shift-reduce conflicts
3831  * which we can resolve in favor of always treating '(' <select> ')' as
3832  * a select_with_parens.  To resolve the conflicts, the productions that
3833  * conflict with the select_with_parens productions are manually given
3834  * precedences lower than the precedence of ')', thereby ensuring that we
3835  * shift ')' (and then reduce to select_with_parens) rather than trying to
3836  * reduce the inner <select> nonterminal to something else.  We use UMINUS
3837  * precedence for this, which is a fairly arbitrary choice.
3838  *
3839  * To be able to define select_with_parens itself without ambiguity, we need
3840  * a nonterminal select_no_parens that represents a SELECT structure with no
3841  * outermost parentheses.  This is a little bit tedious, but it works.
3842  *
3843  * In non-expression contexts, we use SelectStmt which can represent a SELECT
3844  * with or without outer parentheses.
3845  */
3846
3847 SelectStmt: select_no_parens                    %prec UMINUS
3848                 | select_with_parens                    %prec UMINUS
3849                 ;
3850
3851 select_with_parens: '(' select_no_parens ')'
3852                         {
3853                                 $$ = $2;
3854                         }
3855                 | '(' select_with_parens ')'
3856                         {
3857                                 $$ = $2;
3858                         }
3859                 ;
3860
3861 select_no_parens: simple_select
3862                         {
3863                                 $$ = $1;
3864                         }
3865                 | select_clause sort_clause opt_for_update_clause opt_select_limit
3866                         {
3867                                 insertSelectOptions((SelectStmt *) $1, $2, $3,
3868                                                                         nth(0, $4), nth(1, $4));
3869                                 $$ = $1;
3870                         }
3871                 | select_clause for_update_clause opt_select_limit
3872                         {
3873                                 insertSelectOptions((SelectStmt *) $1, NIL, $2,
3874                                                                         nth(0, $3), nth(1, $3));
3875                                 $$ = $1;
3876                         }
3877                 | select_clause select_limit
3878                         {
3879                                 insertSelectOptions((SelectStmt *) $1, NIL, NIL,
3880                                                                         nth(0, $2), nth(1, $2));
3881                                 $$ = $1;
3882                         }
3883                 ;
3884
3885 select_clause: simple_select
3886                 | select_with_parens
3887                 ;
3888
3889 /*
3890  * This rule parses SELECT statements that can appear within set operations,
3891  * including UNION, INTERSECT and EXCEPT.  '(' and ')' can be used to specify
3892  * the ordering of the set operations.  Without '(' and ')' we want the
3893  * operations to be ordered per the precedence specs at the head of this file.
3894  *
3895  * As with select_no_parens, simple_select cannot have outer parentheses,
3896  * but can have parenthesized subclauses.
3897  *
3898  * Note that sort clauses cannot be included at this level --- SQL92 requires
3899  *              SELECT foo UNION SELECT bar ORDER BY baz
3900  * to be parsed as
3901  *              (SELECT foo UNION SELECT bar) ORDER BY baz
3902  * not
3903  *              SELECT foo UNION (SELECT bar ORDER BY baz)
3904  * Likewise FOR UPDATE and LIMIT.  Therefore, those clauses are described
3905  * as part of the select_no_parens production, not simple_select.
3906  * This does not limit functionality, because you can reintroduce sort and
3907  * limit clauses inside parentheses.
3908  *
3909  * NOTE: only the leftmost component SelectStmt should have INTO.
3910  * However, this is not checked by the grammar; parse analysis must check it.
3911  */
3912 simple_select: SELECT opt_distinct target_list
3913                          into_clause from_clause where_clause
3914                          group_clause having_clause
3915                                 {
3916                                         SelectStmt *n = makeNode(SelectStmt);
3917                                         n->distinctClause = $2;
3918                                         n->targetList = $3;
3919                                         n->into = $4;
3920                                         n->intoColNames = NIL;
3921                                         n->fromClause = $5;
3922                                         n->whereClause = $6;
3923                                         n->groupClause = $7;
3924                                         n->havingClause = $8;
3925                                         $$ = (Node *)n;
3926                                 }
3927                 | select_clause UNION opt_all select_clause
3928                         {
3929                                 $$ = makeSetOp(SETOP_UNION, $3, $1, $4);
3930                         }
3931                 | select_clause INTERSECT opt_all select_clause
3932                         {
3933                                 $$ = makeSetOp(SETOP_INTERSECT, $3, $1, $4);
3934                         }
3935                 | select_clause EXCEPT opt_all select_clause
3936                         {
3937                                 $$ = makeSetOp(SETOP_EXCEPT, $3, $1, $4);
3938                         }
3939                 ;
3940
3941 into_clause:  INTO OptTempTableName             { $$ = $2; }
3942                 | /*EMPTY*/             { $$ = NULL; }
3943                 ;
3944
3945 /*
3946  * Redundancy here is needed to avoid shift/reduce conflicts,
3947  * since TEMP is not a reserved word.  See also OptTemp.
3948  */
3949 OptTempTableName:  TEMPORARY opt_table qualified_name
3950                                 {
3951                                         $$ = $3;
3952                                         $$->istemp = true;
3953                                 }
3954                         | TEMP opt_table qualified_name
3955                                 {
3956                                         $$ = $3;
3957                                         $$->istemp = true;
3958                                 }
3959                         | LOCAL TEMPORARY opt_table qualified_name
3960                                 {
3961                                         $$ = $4;
3962                                         $$->istemp = true;
3963                                 }
3964                         | LOCAL TEMP opt_table qualified_name
3965                                 {
3966                                         $$ = $4;
3967                                         $$->istemp = true;
3968                                 }
3969                         | GLOBAL TEMPORARY opt_table qualified_name
3970                                 {
3971                                         elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
3972                                         $$ = $4;
3973                                         $$->istemp = true;
3974                                 }
3975                         | GLOBAL TEMP opt_table qualified_name
3976                                 {
3977                                         elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
3978                                         $$ = $4;
3979                                         $$->istemp = true;
3980                                 }
3981                         | TABLE qualified_name
3982                                 {
3983                                         $$ = $2;
3984                                         $$->istemp = false;
3985                                 }
3986                         | qualified_name
3987                                 {
3988                                         $$ = $1;
3989                                         $$->istemp = false;
3990                                 }
3991                 ;
3992
3993 opt_table:  TABLE                                                               { $$ = TRUE; }
3994                 | /*EMPTY*/                                                             { $$ = FALSE; }
3995                 ;
3996
3997 opt_all:  ALL                                                                   { $$ = TRUE; }
3998                 | /*EMPTY*/                                                             { $$ = FALSE; }
3999                 ;
4000
4001 /* We use (NIL) as a placeholder to indicate that all target expressions
4002  * should be placed in the DISTINCT list during parsetree analysis.
4003  */
4004 opt_distinct:  DISTINCT                                                 { $$ = makeList1(NIL); }
4005                 | DISTINCT ON '(' expr_list ')'                 { $$ = $4; }
4006                 | ALL                                                                   { $$ = NIL; }
4007                 | /*EMPTY*/                                                             { $$ = NIL; }
4008                 ;
4009
4010 sort_clause:  ORDER BY sortby_list                              { $$ = $3; }
4011                 ;
4012
4013 sortby_list:  sortby                                                    { $$ = makeList1($1); }
4014                 | sortby_list ',' sortby                                { $$ = lappend($1, $3); }
4015                 ;
4016
4017 sortby: a_expr OptUseOp
4018                                 {
4019                                         $$ = makeNode(SortGroupBy);
4020                                         $$->node = $1;
4021                                         $$->useOp = $2;
4022                                 }
4023                 ;
4024
4025 OptUseOp:  USING qual_all_Op
4026                                 { $$ = $2; }
4027                 | ASC
4028                                 { $$ = makeList1(makeString("<")); }
4029                 | DESC
4030                                 { $$ = makeList1(makeString(">")); }
4031                 | /*EMPTY*/
4032                                 { $$ = makeList1(makeString("<"));      /*default*/ }
4033                 ;
4034
4035
4036 select_limit:   LIMIT select_limit_value OFFSET select_offset_value
4037                         { $$ = makeList2($4, $2); }
4038                 | OFFSET select_offset_value LIMIT select_limit_value
4039                         { $$ = makeList2($2, $4); }
4040                 | LIMIT select_limit_value
4041                         { $$ = makeList2(NULL, $2); }
4042                 | OFFSET select_offset_value
4043                         { $$ = makeList2($2, NULL); }
4044                 | LIMIT select_limit_value ',' select_offset_value
4045                         /* Disabled because it was too confusing, bjm 2002-02-18 */
4046                         { elog(ERROR, "LIMIT #,# syntax not supported.\n\tUse separate LIMIT and OFFSET clauses."); }
4047                 ;
4048
4049
4050 opt_select_limit:       select_limit                            { $$ = $1; }
4051                 | /* EMPTY */                                                   { $$ = makeList2(NULL,NULL); }
4052                 ;
4053
4054 select_limit_value:  Iconst
4055                         {
4056                                 Const   *n = makeNode(Const);
4057
4058                                 if ($1 < 0)
4059                                         elog(ERROR, "LIMIT must not be negative");
4060
4061                                 n->consttype    = INT4OID;
4062                                 n->constlen             = sizeof(int4);
4063                                 n->constvalue   = Int32GetDatum($1);
4064                                 n->constisnull  = FALSE;
4065                                 n->constbyval   = TRUE;
4066                                 n->constisset   = FALSE;
4067                                 n->constiscast  = FALSE;
4068                                 $$ = (Node *)n;
4069                         }
4070                 | ALL
4071                         {
4072                                 /* LIMIT ALL is represented as a NULL constant */
4073                                 Const   *n = makeNode(Const);
4074
4075                                 n->consttype    = INT4OID;
4076                                 n->constlen             = sizeof(int4);
4077                                 n->constvalue   = (Datum) 0;
4078                                 n->constisnull  = TRUE;
4079                                 n->constbyval   = TRUE;
4080                                 n->constisset   = FALSE;
4081                                 n->constiscast  = FALSE;
4082                                 $$ = (Node *)n;
4083                         }
4084                 | PARAM
4085                         {
4086                                 Param   *n = makeNode(Param);
4087
4088                                 n->paramkind    = PARAM_NUM;
4089                                 n->paramid              = $1;
4090                                 n->paramtype    = INT4OID;
4091                                 $$ = (Node *)n;
4092                         }
4093                 ;
4094
4095 select_offset_value:    Iconst
4096                         {
4097                                 Const   *n = makeNode(Const);
4098
4099                                 if ($1 < 0)
4100                                         elog(ERROR, "OFFSET must not be negative");
4101
4102                                 n->consttype    = INT4OID;
4103                                 n->constlen             = sizeof(int4);
4104                                 n->constvalue   = Int32GetDatum($1);
4105                                 n->constisnull  = FALSE;
4106                                 n->constbyval   = TRUE;
4107                                 n->constisset   = FALSE;
4108                                 n->constiscast  = FALSE;
4109                                 $$ = (Node *)n;
4110                         }
4111                 | PARAM
4112                         {
4113                                 Param   *n = makeNode(Param);
4114
4115                                 n->paramkind    = PARAM_NUM;
4116                                 n->paramid              = $1;
4117                                 n->paramtype    = INT4OID;
4118                                 $$ = (Node *)n;
4119                         }
4120                 ;
4121
4122 /*
4123  *      jimmy bell-style recursive queries aren't supported in the
4124  *      current system.
4125  *
4126  *      ...however, recursive addattr and rename supported.  make special
4127  *      cases for these.
4128  */
4129
4130 group_clause:  GROUP_P BY expr_list                             { $$ = $3; }
4131                 | /*EMPTY*/                                                             { $$ = NIL; }
4132                 ;
4133
4134 having_clause:  HAVING a_expr
4135                                 {
4136                                         $$ = $2;
4137                                 }
4138                 | /*EMPTY*/                                                             { $$ = NULL; }
4139                 ;
4140
4141 for_update_clause:  FOR UPDATE update_list              { $$ = $3; }
4142                 | FOR READ ONLY                                                 { $$ = NULL; }
4143                 ;
4144
4145 opt_for_update_clause:  for_update_clause               { $$ = $1; }
4146                 | /* EMPTY */                                                   { $$ = NULL; }
4147                 ;
4148
4149 update_list:  OF name_list                                              { $$ = $2; }
4150                 | /* EMPTY */                                                   { $$ = makeList1(NULL); }
4151                 ;
4152
4153 /*****************************************************************************
4154  *
4155  *      clauses common to all Optimizable Stmts:
4156  *              from_clause             - allow list of both JOIN expressions and table names
4157  *              where_clause    - qualifications for joins or restrictions
4158  *
4159  *****************************************************************************/
4160
4161 from_clause:  FROM from_list                                    { $$ = $2; }
4162                 | /*EMPTY*/                                                             { $$ = NIL; }
4163                 ;
4164
4165 from_list:  from_list ',' table_ref                             { $$ = lappend($1, $3); }
4166                 | table_ref                                                             { $$ = makeList1($1); }
4167                 ;
4168
4169 /*
4170  * table_ref is where an alias clause can be attached.  Note we cannot make
4171  * alias_clause have an empty production because that causes parse conflicts
4172  * between table_ref := '(' joined_table ')' alias_clause
4173  * and joined_table := '(' joined_table ')'.  So, we must have the
4174  * redundant-looking productions here instead.
4175  */
4176 table_ref:  relation_expr
4177                                 {
4178                                         $$ = (Node *) $1;
4179                                 }
4180                 | relation_expr alias_clause
4181                                 {
4182                                         $1->alias = $2;
4183                                         $$ = (Node *) $1;
4184                                 }
4185                 | func_table
4186                                 {
4187                                         RangeFunction *n = makeNode(RangeFunction);
4188                                         n->funccallnode = $1;
4189                                         $$ = (Node *) n;
4190                                 }
4191                 | func_table alias_clause
4192                                 {
4193                                         RangeFunction *n = makeNode(RangeFunction);
4194                                         n->funccallnode = $1;
4195                                         n->alias = $2;
4196                                         $$ = (Node *) n;
4197                                 }
4198                 | select_with_parens
4199                                 {
4200                                         /*
4201                                          * The SQL spec does not permit a subselect
4202                                          * (<derived_table>) without an alias clause,
4203                                          * so we don't either.  This avoids the problem
4204                                          * of needing to invent a unique refname for it.
4205                                          * That could be surmounted if there's sufficient
4206                                          * popular demand, but for now let's just implement
4207                                          * the spec and see if anyone complains.
4208                                          * However, it does seem like a good idea to emit
4209                                          * an error message that's better than "parse error".
4210                                          */
4211                                         elog(ERROR, "sub-SELECT in FROM must have an alias"
4212                                                  "\n\tFor example, FROM (SELECT ...) [AS] foo");
4213                                         $$ = NULL;
4214                                 }
4215                 | select_with_parens alias_clause
4216                                 {
4217                                         RangeSubselect *n = makeNode(RangeSubselect);
4218                                         n->subquery = $1;
4219                                         n->alias = $2;
4220                                         $$ = (Node *) n;
4221                                 }
4222                 | joined_table
4223                                 {
4224                                         $$ = (Node *) $1;
4225                                 }
4226                 | '(' joined_table ')' alias_clause
4227                                 {
4228                                         $2->alias = $4;
4229                                         $$ = (Node *) $2;
4230                                 }
4231                 ;
4232
4233
4234 /*
4235  * It may seem silly to separate joined_table from table_ref, but there is
4236  * method in SQL92's madness: if you don't do it this way you get reduce-
4237  * reduce conflicts, because it's not clear to the parser generator whether
4238  * to expect alias_clause after ')' or not.  For the same reason we must
4239  * treat 'JOIN' and 'join_type JOIN' separately, rather than allowing
4240  * join_type to expand to empty; if we try it, the parser generator can't
4241  * figure out when to reduce an empty join_type right after table_ref.
4242  *
4243  * Note that a CROSS JOIN is the same as an unqualified
4244  * INNER JOIN, and an INNER JOIN/ON has the same shape
4245  * but a qualification expression to limit membership.
4246  * A NATURAL JOIN implicitly matches column names between
4247  * tables and the shape is determined by which columns are
4248  * in common. We'll collect columns during the later transformations.
4249  */
4250
4251 joined_table:  '(' joined_table ')'
4252                                 {
4253                                         $$ = $2;
4254                                 }
4255                 | table_ref CROSS JOIN table_ref
4256                                 {
4257                                         /* CROSS JOIN is same as unqualified inner join */
4258                                         JoinExpr *n = makeNode(JoinExpr);
4259                                         n->jointype = JOIN_INNER;
4260                                         n->isNatural = FALSE;
4261                                         n->larg = $1;
4262                                         n->rarg = $4;
4263                                         n->using = NIL;
4264                                         n->quals = NULL;
4265                                         $$ = n;
4266                                 }
4267                 | table_ref UNIONJOIN table_ref
4268                                 {
4269                                         /* UNION JOIN is made into 1 token to avoid shift/reduce
4270                                          * conflict against regular UNION keyword.
4271                                          */
4272                                         JoinExpr *n = makeNode(JoinExpr);
4273                                         n->jointype = JOIN_UNION;
4274                                         n->isNatural = FALSE;
4275                                         n->larg = $1;
4276                                         n->rarg = $3;
4277                                         n->using = NIL;
4278                                         n->quals = NULL;
4279                                         $$ = n;
4280                                 }
4281                 | table_ref join_type JOIN table_ref join_qual
4282                                 {
4283                                         JoinExpr *n = makeNode(JoinExpr);
4284                                         n->jointype = $2;
4285                                         n->isNatural = FALSE;
4286                                         n->larg = $1;
4287                                         n->rarg = $4;
4288                                         if ($5 != NULL && IsA($5, List))
4289                                                 n->using = (List *) $5; /* USING clause */
4290                                         else
4291                                                 n->quals = $5; /* ON clause */
4292                                         $$ = n;
4293                                 }
4294                 | table_ref JOIN table_ref join_qual
4295                                 {
4296                                         /* letting join_type reduce to empty doesn't work */
4297                                         JoinExpr *n = makeNode(JoinExpr);
4298                                         n->jointype = JOIN_INNER;
4299                                         n->isNatural = FALSE;
4300                                         n->larg = $1;
4301                                         n->rarg = $3;
4302                                         if ($4 != NULL && IsA($4, List))
4303                                                 n->using = (List *) $4; /* USING clause */
4304                                         else
4305                                                 n->quals = $4; /* ON clause */
4306                                         $$ = n;
4307                                 }
4308                 | table_ref NATURAL join_type JOIN table_ref
4309                                 {
4310                                         JoinExpr *n = makeNode(JoinExpr);
4311                                         n->jointype = $3;
4312                                         n->isNatural = TRUE;
4313                                         n->larg = $1;
4314                                         n->rarg = $5;
4315                                         n->using = NIL; /* figure out which columns later... */
4316                                         n->quals = NULL; /* fill later */
4317                                         $$ = n;
4318                                 }
4319                 | table_ref NATURAL JOIN table_ref
4320                                 {
4321                                         /* letting join_type reduce to empty doesn't work */
4322                                         JoinExpr *n = makeNode(JoinExpr);
4323                                         n->jointype = JOIN_INNER;
4324                                         n->isNatural = TRUE;
4325                                         n->larg = $1;
4326                                         n->rarg = $4;
4327                                         n->using = NIL; /* figure out which columns later... */
4328                                         n->quals = NULL; /* fill later */
4329                                         $$ = n;
4330                                 }
4331                 ;
4332
4333 alias_clause:  AS ColId '(' name_list ')'
4334                                 {
4335                                         $$ = makeNode(Alias);
4336                                         $$->aliasname = $2;
4337                                         $$->colnames = $4;
4338                                 }
4339                 | AS ColId
4340                                 {
4341                                         $$ = makeNode(Alias);
4342                                         $$->aliasname = $2;
4343                                 }
4344                 | ColId '(' name_list ')'
4345                                 {
4346                                         $$ = makeNode(Alias);
4347                                         $$->aliasname = $1;
4348                                         $$->colnames = $3;
4349                                 }
4350                 | ColId
4351                                 {
4352                                         $$ = makeNode(Alias);
4353                                         $$->aliasname = $1;
4354                                 }
4355                 ;
4356
4357 join_type:  FULL join_outer                                             { $$ = JOIN_FULL; }
4358                 | LEFT join_outer                                               { $$ = JOIN_LEFT; }
4359                 | RIGHT join_outer                                              { $$ = JOIN_RIGHT; }
4360                 | INNER_P                                                               { $$ = JOIN_INNER; }
4361                 ;
4362
4363 /* OUTER is just noise... */
4364 join_outer:  OUTER_P                                                    { $$ = NULL; }
4365                 | /*EMPTY*/                                                             { $$ = NULL; }
4366                 ;
4367
4368 /* JOIN qualification clauses
4369  * Possibilities are:
4370  *  USING ( column list ) allows only unqualified column names,
4371  *                        which must match between tables.
4372  *  ON expr allows more general qualifications.
4373  *
4374  * We return USING as a List node, while an ON-expr will not be a List.
4375  */
4376
4377 join_qual:  USING '(' name_list ')'                             { $$ = (Node *) $3; }
4378                 | ON a_expr                                                             { $$ = $2; }
4379                 ;
4380
4381
4382 relation_expr:  qualified_name
4383                                 {
4384                                         /* default inheritance */
4385                                         $$ = $1;
4386                                         $$->inhOpt = INH_DEFAULT;
4387                                         $$->alias = NULL;
4388                                 }
4389                 | qualified_name '*'
4390                                 {
4391                                         /* inheritance query */
4392                                         $$ = $1;
4393                                         $$->inhOpt = INH_YES;
4394                                         $$->alias = NULL;
4395                                 }
4396                 | ONLY qualified_name
4397                                 {
4398                                         /* no inheritance */
4399                                         $$ = $2;
4400                                         $$->inhOpt = INH_NO;
4401                                         $$->alias = NULL;
4402                 }
4403                 ;
4404
4405
4406 func_table:  func_name '(' ')'
4407                                 {
4408                                         FuncCall *n = makeNode(FuncCall);
4409                                         n->funcname = $1;
4410                                         n->args = NIL;
4411                                         n->agg_star = FALSE;
4412                                         n->agg_distinct = FALSE;
4413                                         $$ = (Node *)n;
4414                                 }
4415                 | func_name '(' expr_list ')'
4416                                 {
4417                                         FuncCall *n = makeNode(FuncCall);
4418                                         n->funcname = $1;
4419                                         n->args = $3;
4420                                         n->agg_star = FALSE;
4421                                         n->agg_distinct = FALSE;
4422                                         $$ = (Node *)n;
4423                                 }
4424                 ;
4425
4426
4427 where_clause:  WHERE a_expr                                             { $$ = $2; }
4428                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
4429                 ;
4430
4431
4432 /*****************************************************************************
4433  *
4434  *      Type syntax
4435  *              SQL92 introduces a large amount of type-specific syntax.
4436  *              Define individual clauses to handle these cases, and use
4437  *               the generic case to handle regular type-extensible Postgres syntax.
4438  *              - thomas 1997-10-10
4439  *
4440  *****************************************************************************/
4441
4442 Typename:  SimpleTypename opt_array_bounds
4443                                 {
4444                                         $$ = $1;
4445                                         $$->arrayBounds = $2;
4446                                 }
4447                 | SETOF SimpleTypename
4448                                 {
4449                                         $$ = $2;
4450                                         $$->setof = TRUE;
4451                                 }
4452                 ;
4453
4454 opt_array_bounds:       opt_array_bounds '[' ']'
4455                                 {  $$ = lappend($1, makeInteger(-1)); }
4456                 | opt_array_bounds '[' Iconst ']'
4457                                 {  $$ = lappend($1, makeInteger($3)); }
4458                 | /*EMPTY*/
4459                                 {  $$ = NIL; }
4460                 ;
4461
4462 /*
4463  * XXX ideally, the production for a qualified typename should be ColId attrs
4464  * (there's no obvious reason why the first name should need to be restricted)
4465  * and should be an alternative of GenericType (so that it can be used to
4466  * specify a type for a literal in AExprConst).  However doing either causes
4467  * reduce/reduce conflicts that I haven't been able to find a workaround
4468  * for.  FIXME later.
4469  */
4470 SimpleTypename:  ConstTypename
4471                 | ConstInterval opt_interval
4472                                 {
4473                                         $$ = $1;
4474                                         if ($2 != -1)
4475                                                 $$->typmod = ((($2 & 0x7FFF) << 16) | 0xFFFF);
4476                                 }
4477                 | ConstInterval '(' Iconst ')' opt_interval
4478                                 {
4479                                         $$ = $1;
4480                                         if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
4481                                                 elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
4482                                                          $3, 0, MAX_INTERVAL_PRECISION);
4483                                         $$->typmod = ((($5 & 0x7FFF) << 16) | $3);
4484                                 }
4485                 | type_name attrs
4486                                 {
4487                                         $$ = makeNode(TypeName);
4488                                         $$->names = lcons(makeString($1), $2);
4489                                         $$->typmod = -1;
4490                                 }
4491                 ;
4492
4493 ConstTypename:  GenericType
4494                 | Numeric
4495                 | Bit
4496                 | Character
4497                 | ConstDatetime
4498                 ;
4499
4500 GenericType:  type_name
4501                                 {
4502                                         $$ = makeTypeName($1);
4503                                 }
4504                 ;
4505
4506 /* SQL92 numeric data types
4507  * Check FLOAT() precision limits assuming IEEE floating types.
4508  * Provide real DECIMAL() and NUMERIC() implementations now - Jan 1998-12-30
4509  * - thomas 1997-09-18
4510  */
4511 Numeric:  INT
4512                                 {
4513                                         $$ = SystemTypeName("int4");
4514                                 }
4515                 | INTEGER
4516                                 {
4517                                         $$ = SystemTypeName("int4");
4518                                 }
4519                 | SMALLINT
4520                                 {
4521                                         $$ = SystemTypeName("int2");
4522                                 }
4523                 | BIGINT
4524                                 {
4525                                         $$ = SystemTypeName("int8");
4526                                 }
4527                 | REAL
4528                                 {
4529                                         $$ = SystemTypeName("float4");
4530                                 }
4531                 | FLOAT_P opt_float
4532                                 {
4533                                         $$ = $2;
4534                                 }
4535                 | DOUBLE PRECISION
4536                                 {
4537                                         $$ = SystemTypeName("float8");
4538                                 }
4539                 | DECIMAL opt_decimal
4540                                 {
4541                                         $$ = SystemTypeName("numeric");
4542                                         $$->typmod = $2;
4543                                 }
4544                 | DEC opt_decimal
4545                                 {
4546                                         $$ = SystemTypeName("numeric");
4547                                         $$->typmod = $2;
4548                                 }
4549                 | NUMERIC opt_numeric
4550                                 {
4551                                         $$ = SystemTypeName("numeric");
4552                                         $$->typmod = $2;
4553                                 }
4554                 | BOOLEAN
4555                                 {
4556                                         $$ = SystemTypeName("bool");
4557                                 }
4558                 ;
4559
4560 opt_float:  '(' Iconst ')'
4561                                 {
4562                                         if ($2 < 1)
4563                                                 elog(ERROR, "precision for FLOAT must be at least 1");
4564                                         else if ($2 < 7)
4565                                                 $$ = SystemTypeName("float4");
4566                                         else if ($2 < 16)
4567                                                 $$ = SystemTypeName("float8");
4568                                         else
4569                                                 elog(ERROR, "precision for FLOAT must be less than 16");
4570                                 }
4571                 | /*EMPTY*/
4572                                 {
4573                                         $$ = SystemTypeName("float8");
4574                                 }
4575                 ;
4576
4577 opt_numeric:  '(' Iconst ',' Iconst ')'
4578                                 {
4579                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
4580                                                 elog(ERROR, "NUMERIC precision %d must be between 1 and %d",
4581                                                          $2, NUMERIC_MAX_PRECISION);
4582                                         if ($4 < 0 || $4 > $2)
4583                                                 elog(ERROR, "NUMERIC scale %d must be between 0 and precision %d",
4584                                                          $4,$2);
4585
4586                                         $$ = (($2 << 16) | $4) + VARHDRSZ;
4587                                 }
4588                 | '(' Iconst ')'
4589                                 {
4590                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
4591                                                 elog(ERROR, "NUMERIC precision %d must be between 1 and %d",
4592                                                          $2, NUMERIC_MAX_PRECISION);
4593
4594                                         $$ = ($2 << 16) + VARHDRSZ;
4595                                 }
4596                 | /*EMPTY*/
4597                                 {
4598                                         /* Insert "-1" meaning "no limit" */
4599                                         $$ = -1;
4600                                 }
4601                 ;
4602
4603 opt_decimal:  '(' Iconst ',' Iconst ')'
4604                                 {
4605                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
4606                                                 elog(ERROR, "DECIMAL precision %d must be between 1 and %d",
4607                                                                         $2, NUMERIC_MAX_PRECISION);
4608                                         if ($4 < 0 || $4 > $2)
4609                                                 elog(ERROR, "DECIMAL scale %d must be between 0 and precision %d",
4610                                                                         $4,$2);
4611
4612                                         $$ = (($2 << 16) | $4) + VARHDRSZ;
4613                                 }
4614                 | '(' Iconst ')'
4615                                 {
4616                                         if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
4617                                                 elog(ERROR, "DECIMAL precision %d must be between 1 and %d",
4618                                                                         $2, NUMERIC_MAX_PRECISION);
4619
4620                                         $$ = ($2 << 16) + VARHDRSZ;
4621                                 }
4622                 | /*EMPTY*/
4623                                 {
4624                                         /* Insert "-1" meaning "no limit" */
4625                                         $$ = -1;
4626                                 }
4627                 ;
4628
4629
4630 /*
4631  * SQL92 bit-field data types
4632  * The following implements BIT() and BIT VARYING().
4633  */
4634 Bit:  BIT opt_varying '(' Iconst ')'
4635                                 {
4636                                         char *typname;
4637
4638                                         typname = $2 ? "varbit" : "bit";
4639                                         $$ = SystemTypeName(typname);
4640                                         if ($4 < 1)
4641                                                 elog(ERROR, "length for type '%s' must be at least 1",
4642                                                          typname);
4643                                         else if ($4 > (MaxAttrSize * BITS_PER_BYTE))
4644                                                 elog(ERROR, "length for type '%s' cannot exceed %d",
4645                                                          typname, (MaxAttrSize * BITS_PER_BYTE));
4646                                         $$->typmod = $4;
4647                                 }
4648                 | BIT opt_varying
4649                                 {
4650                                         /* bit defaults to bit(1), varbit to no limit */
4651                                         if ($2)
4652                                         {
4653                                                 $$ = SystemTypeName("varbit");
4654                                                 $$->typmod = -1;
4655                                         }
4656                                         else
4657                                         {
4658                                                 $$ = SystemTypeName("bit");
4659                                                 $$->typmod = 1;
4660                                         }
4661                                 }
4662                 ;
4663
4664
4665 /*
4666  * SQL92 character data types
4667  * The following implements CHAR() and VARCHAR().
4668  */
4669 Character:  character '(' Iconst ')' opt_charset
4670                                 {
4671                                         if (($5 != NULL) && (strcmp($5, "sql_text") != 0))
4672                                         {
4673                                                 char *type;
4674
4675                                                 type = palloc(strlen($1) + 1 + strlen($5) + 1);
4676                                                 strcpy(type, $1);
4677                                                 strcat(type, "_");
4678                                                 strcat(type, $5);
4679                                                 $1 = type;
4680                                         }
4681
4682                                         $$ = SystemTypeName($1);
4683
4684                                         if ($3 < 1)
4685                                                 elog(ERROR, "length for type '%s' must be at least 1",
4686                                                          $1);
4687                                         else if ($3 > MaxAttrSize)
4688                                                 elog(ERROR, "length for type '%s' cannot exceed %d",
4689                                                          $1, MaxAttrSize);
4690
4691                                         /* we actually implement these like a varlen, so
4692                                          * the first 4 bytes is the length. (the difference
4693                                          * between these and "text" is that we blank-pad and
4694                                          * truncate where necessary)
4695                                          */
4696                                         $$->typmod = VARHDRSZ + $3;
4697                                 }
4698                 | character opt_charset
4699                                 {
4700                                         if (($2 != NULL) && (strcmp($2, "sql_text") != 0))
4701                                         {
4702                                                 char *type;
4703
4704                                                 type = palloc(strlen($1) + 1 + strlen($2) + 1);
4705                                                 strcpy(type, $1);
4706                                                 strcat(type, "_");
4707                                                 strcat(type, $2);
4708                                                 $1 = type;
4709                                         }
4710
4711                                         $$ = SystemTypeName($1);
4712
4713                                         /* char defaults to char(1), varchar to no limit */
4714                                         if (strcmp($1, "bpchar") == 0)
4715                                                 $$->typmod = VARHDRSZ + 1;
4716                                         else
4717                                                 $$->typmod = -1;
4718                                 }
4719                 ;
4720
4721 character:  CHARACTER opt_varying                               { $$ = $2 ? "varchar": "bpchar"; }
4722                 | CHAR_P opt_varying                                            { $$ = $2 ? "varchar": "bpchar"; }
4723                 | VARCHAR                                                               { $$ = "varchar"; }
4724                 | NATIONAL CHARACTER opt_varying                { $$ = $3 ? "varchar": "bpchar"; }
4725                 | NATIONAL CHAR_P opt_varying                           { $$ = $3 ? "varchar": "bpchar"; }
4726                 | NCHAR opt_varying                                             { $$ = $2 ? "varchar": "bpchar"; }
4727                 ;
4728
4729 opt_varying:  VARYING                                                   { $$ = TRUE; }
4730                 | /*EMPTY*/                                                             { $$ = FALSE; }
4731                 ;
4732
4733 opt_charset:  CHARACTER SET ColId                               { $$ = $3; }
4734                 | /*EMPTY*/                                                             { $$ = NULL; }
4735                 ;
4736
4737 opt_collate:  COLLATE ColId                                             { $$ = $2; }
4738                 | /*EMPTY*/                                                             { $$ = NULL; }
4739                 ;
4740
4741 ConstDatetime:  TIMESTAMP '(' Iconst ')' opt_timezone
4742                                 {
4743                                         if ($5)
4744                                                 $$ = SystemTypeName("timestamptz");
4745                                         else
4746                                                 $$ = SystemTypeName("timestamp");
4747                                         /* XXX the timezone field seems to be unused
4748                                          * - thomas 2001-09-06
4749                                          */
4750                                         $$->timezone = $5;
4751                                         if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
4752                                                 elog(ERROR, "TIMESTAMP(%d)%s precision must be between %d and %d",
4753                                                          $3, ($5 ? " WITH TIME ZONE": ""), 0, MAX_TIMESTAMP_PRECISION);
4754                                         $$->typmod = $3;
4755                                 }
4756                 | TIMESTAMP opt_timezone
4757                                 {
4758                                         if ($2)
4759                                                 $$ = SystemTypeName("timestamptz");
4760                                         else
4761                                                 $$ = SystemTypeName("timestamp");
4762                                         /* XXX the timezone field seems to be unused
4763                                          * - thomas 2001-09-06
4764                                          */
4765                                         $$->timezone = $2;
4766                                         /* SQL99 specified a default precision of six
4767                                          * for schema definitions. But for timestamp
4768                                          * literals we don't want to throw away precision
4769                                          * so leave this as unspecified for now.
4770                                          * Later, we may want a different production
4771                                          * for schemas. - thomas 2001-12-07
4772                                          */
4773                                         $$->typmod = -1;
4774                                 }
4775                 | TIME '(' Iconst ')' opt_timezone
4776                                 {
4777                                         if ($5)
4778                                                 $$ = SystemTypeName("timetz");
4779                                         else
4780                                                 $$ = SystemTypeName("time");
4781                                         if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
4782                                                 elog(ERROR, "TIME(%d)%s precision must be between %d and %d",
4783                                                          $3, ($5 ? " WITH TIME ZONE": ""), 0, MAX_TIME_PRECISION);
4784                                         $$->typmod = $3;
4785                                 }
4786                 | TIME opt_timezone
4787                                 {
4788                                         if ($2)
4789                                                 $$ = SystemTypeName("timetz");
4790                                         else
4791                                                 $$ = SystemTypeName("time");
4792                                         /* SQL99 specified a default precision of zero.
4793                                          * See comments for timestamp above on why we will
4794                                          * leave this unspecified for now. - thomas 2001-12-07
4795                                          */
4796                                         $$->typmod = -1;
4797                                 }
4798                 ;
4799
4800 ConstInterval:  INTERVAL
4801                                 {
4802                                         $$ = SystemTypeName("interval");
4803                                 }
4804                 ;
4805
4806 opt_timezone:  WITH TIME ZONE                                   { $$ = TRUE; }
4807                 | WITHOUT TIME ZONE                                             { $$ = FALSE; }
4808                 | /*EMPTY*/                                                             { $$ = FALSE; }
4809                 ;
4810
4811 opt_interval:  YEAR_P                                                   { $$ = MASK(YEAR); }
4812                 | MONTH_P                                                               { $$ = MASK(MONTH); }
4813                 | DAY_P                                                                 { $$ = MASK(DAY); }
4814                 | HOUR_P                                                                { $$ = MASK(HOUR); }
4815                 | MINUTE_P                                                              { $$ = MASK(MINUTE); }
4816                 | SECOND_P                                                              { $$ = MASK(SECOND); }
4817                 | YEAR_P TO MONTH_P                                             { $$ = MASK(YEAR) | MASK(MONTH); }
4818                 | DAY_P TO HOUR_P                                               { $$ = MASK(DAY) | MASK(HOUR); }
4819                 | DAY_P TO MINUTE_P                                             { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE); }
4820                 | DAY_P TO SECOND_P                                             { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
4821                 | HOUR_P TO MINUTE_P                                    { $$ = MASK(HOUR) | MASK(MINUTE); }
4822                 | HOUR_P TO SECOND_P                                    { $$ = MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
4823                 | MINUTE_P TO SECOND_P                                  { $$ = MASK(MINUTE) | MASK(SECOND); }
4824                 | /*EMPTY*/                                                             { $$ = -1; }
4825                 ;
4826
4827
4828 /*****************************************************************************
4829  *
4830  *      expression grammar
4831  *
4832  *****************************************************************************/
4833
4834 /* Expressions using row descriptors
4835  * Define row_descriptor to allow yacc to break the reduce/reduce conflict
4836  *  with singleton expressions.
4837  */
4838 row_expr: '(' row_descriptor ')' IN_P select_with_parens
4839                                 {
4840                                         SubLink *n = makeNode(SubLink);
4841                                         n->lefthand = $2;
4842                                         n->oper = (List *) makeSimpleA_Expr(OP, "=", NULL, NULL);
4843                                         n->useor = FALSE;
4844                                         n->subLinkType = ANY_SUBLINK;
4845                                         n->subselect = $5;
4846                                         $$ = (Node *)n;
4847                                 }
4848                 | '(' row_descriptor ')' NOT IN_P select_with_parens
4849                                 {
4850                                         SubLink *n = makeNode(SubLink);
4851                                         n->lefthand = $2;
4852                                         n->oper = (List *) makeSimpleA_Expr(OP, "<>", NULL, NULL);
4853                                         n->useor = TRUE;
4854                                         n->subLinkType = ALL_SUBLINK;
4855                                         n->subselect = $6;
4856                                         $$ = (Node *)n;
4857                                 }
4858                 | '(' row_descriptor ')' qual_all_Op sub_type select_with_parens        %prec Op
4859                                 {
4860                                         SubLink *n = makeNode(SubLink);
4861                                         n->lefthand = $2;
4862                                         n->oper = (List *) makeA_Expr(OP, $4, NULL, NULL);
4863                                         if (strcmp(strVal(llast($4)), "<>") == 0)
4864                                                 n->useor = TRUE;
4865                                         else
4866                                                 n->useor = FALSE;
4867                                         n->subLinkType = $5;
4868                                         n->subselect = $6;
4869                                         $$ = (Node *)n;
4870                                 }
4871                 | '(' row_descriptor ')' qual_all_Op select_with_parens         %prec Op
4872                                 {
4873                                         SubLink *n = makeNode(SubLink);
4874                                         n->lefthand = $2;
4875                                         n->oper = (List *) makeA_Expr(OP, $4, NULL, NULL);
4876                                         if (strcmp(strVal(llast($4)), "<>") == 0)
4877                                                 n->useor = TRUE;
4878                                         else
4879                                                 n->useor = FALSE;
4880                                         n->subLinkType = MULTIEXPR_SUBLINK;
4881                                         n->subselect = $5;
4882                                         $$ = (Node *)n;
4883                                 }
4884                 | '(' row_descriptor ')' qual_all_Op '(' row_descriptor ')'             %prec Op
4885                                 {
4886                                         $$ = makeRowExpr($4, $2, $6);
4887                                 }
4888                 | '(' row_descriptor ')' OVERLAPS '(' row_descriptor ')'
4889                                 {
4890                                         FuncCall *n = makeNode(FuncCall);
4891                                         List *largs = $2;
4892                                         List *rargs = $6;
4893                                         n->funcname = SystemFuncName("overlaps");
4894                                         if (length(largs) == 1)
4895                                                 largs = lappend(largs, $2);
4896                                         else if (length(largs) != 2)
4897                                                 elog(ERROR, "Wrong number of parameters"
4898                                                          " on left side of OVERLAPS expression");
4899                                         if (length(rargs) == 1)
4900                                                 rargs = lappend(rargs, $6);
4901                                         else if (length(rargs) != 2)
4902                                                 elog(ERROR, "Wrong number of parameters"
4903                                                          " on right side of OVERLAPS expression");
4904                                         n->args = nconc(largs, rargs);
4905                                         n->agg_star = FALSE;
4906                                         n->agg_distinct = FALSE;
4907                                         $$ = (Node *)n;
4908                                 }
4909                 ;
4910
4911 row_descriptor:  row_list ',' a_expr
4912                                 {
4913                                         $$ = lappend($1, $3);
4914                                 }
4915                 ;
4916
4917 row_list:  row_list ',' a_expr
4918                                 {
4919                                         $$ = lappend($1, $3);
4920                                 }
4921                 | a_expr
4922                                 {
4923                                         $$ = makeList1($1);
4924                                 }
4925                 ;
4926
4927 sub_type:  ANY                                                          { $$ = ANY_SUBLINK; }
4928                 | SOME                                                          { $$ = ANY_SUBLINK; }
4929                 | ALL                                                           { $$ = ALL_SUBLINK; }
4930                 ;
4931
4932 all_Op:  Op | MathOp;
4933
4934 MathOp:  '+'                    { $$ = "+"; }
4935                 | '-'                   { $$ = "-"; }
4936                 | '*'                   { $$ = "*"; }
4937                 | '/'                   { $$ = "/"; }
4938                 | '%'                   { $$ = "%"; }
4939                 | '^'                   { $$ = "^"; }
4940                 | '<'                   { $$ = "<"; }
4941                 | '>'                   { $$ = ">"; }
4942                 | '='                   { $$ = "="; }
4943                 ;
4944
4945 qual_Op:  Op
4946                         { $$ = makeList1(makeString($1)); }
4947                 |  OPERATOR '(' any_operator ')'
4948                         { $$ = $3; }
4949                 ;
4950
4951 qual_all_Op:  all_Op
4952                         { $$ = makeList1(makeString($1)); }
4953                 |  OPERATOR '(' any_operator ')'
4954                         { $$ = $3; }
4955                 ;
4956
4957 /*
4958  * General expressions
4959  * This is the heart of the expression syntax.
4960  *
4961  * We have two expression types: a_expr is the unrestricted kind, and
4962  * b_expr is a subset that must be used in some places to avoid shift/reduce
4963  * conflicts.  For example, we can't do BETWEEN as "BETWEEN a_expr AND a_expr"
4964  * because that use of AND conflicts with AND as a boolean operator.  So,
4965  * b_expr is used in BETWEEN and we remove boolean keywords from b_expr.
4966  *
4967  * Note that '(' a_expr ')' is a b_expr, so an unrestricted expression can
4968  * always be used by surrounding it with parens.
4969  *
4970  * c_expr is all the productions that are common to a_expr and b_expr;
4971  * it's factored out just to eliminate redundant coding.
4972  */
4973 a_expr:  c_expr
4974                                 {       $$ = $1; }
4975                 | a_expr TYPECAST Typename
4976                                 {       $$ = makeTypeCast($1, $3); }
4977                 | a_expr COLLATE ColId
4978                                 {
4979                                         FuncCall *n = makeNode(FuncCall);
4980                                         n->funcname = SystemFuncName($3);
4981                                         n->args = makeList1($1);
4982                                         n->agg_star = FALSE;
4983                                         n->agg_distinct = FALSE;
4984                                         $$ = (Node *) n;
4985                                 }
4986                 | a_expr AT TIME ZONE c_expr
4987                                 {
4988                                         FuncCall *n = makeNode(FuncCall);
4989                                         n->funcname = SystemFuncName("timezone");
4990                                         n->args = makeList2($5, $1);
4991                                         n->agg_star = FALSE;
4992                                         n->agg_distinct = FALSE;
4993                                         $$ = (Node *) n;
4994                                 }
4995                 /*
4996                  * These operators must be called out explicitly in order to make use
4997                  * of yacc/bison's automatic operator-precedence handling.  All other
4998                  * operator names are handled by the generic productions using "Op",
4999                  * below; and all those operators will have the same precedence.
5000                  *
5001                  * If you add more explicitly-known operators, be sure to add them
5002                  * also to b_expr and to the MathOp list above.
5003                  */
5004                 | '+' a_expr                                    %prec UMINUS
5005                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "+", NULL, $2); }
5006                 | '-' a_expr                                    %prec UMINUS
5007                                 {       $$ = doNegate($2); }
5008                 | '%' a_expr
5009                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", NULL, $2); }
5010                 | '^' a_expr
5011                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", NULL, $2); }
5012                 | a_expr '%'
5013                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, NULL); }
5014                 | a_expr '^'
5015                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, NULL); }
5016                 | a_expr '+' a_expr
5017                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "+", $1, $3); }
5018                 | a_expr '-' a_expr
5019                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "-", $1, $3); }
5020                 | a_expr '*' a_expr
5021                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "*", $1, $3); }
5022                 | a_expr '/' a_expr
5023                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "/", $1, $3); }
5024                 | a_expr '%' a_expr
5025                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, $3); }
5026                 | a_expr '^' a_expr
5027                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, $3); }
5028                 | a_expr '<' a_expr
5029                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "<", $1, $3); }
5030                 | a_expr '>' a_expr
5031                                 {       $$ = (Node *) makeSimpleA_Expr(OP, ">", $1, $3); }
5032                 | a_expr '=' a_expr
5033                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "=", $1, $3); }
5034
5035                 | a_expr qual_Op a_expr                         %prec Op
5036                                 {       $$ = (Node *) makeA_Expr(OP, $2, $1, $3); }
5037                 | qual_Op a_expr                                        %prec Op
5038                                 {       $$ = (Node *) makeA_Expr(OP, $1, NULL, $2); }
5039                 | a_expr qual_Op                                        %prec POSTFIXOP
5040                                 {       $$ = (Node *) makeA_Expr(OP, $2, $1, NULL); }
5041
5042                 | a_expr AND a_expr
5043                                 {       $$ = (Node *) makeA_Expr(AND, NIL, $1, $3); }
5044                 | a_expr OR a_expr
5045                                 {       $$ = (Node *) makeA_Expr(OR, NIL, $1, $3); }
5046                 | NOT a_expr
5047                                 {       $$ = (Node *) makeA_Expr(NOT, NIL, NULL, $2); }
5048
5049                 | a_expr LIKE a_expr
5050                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "~~", $1, $3); }
5051                 | a_expr LIKE a_expr ESCAPE a_expr
5052                                 {
5053                                         FuncCall *n = makeNode(FuncCall);
5054                                         n->funcname = SystemFuncName("like_escape");
5055                                         n->args = makeList2($3, $5);
5056                                         n->agg_star = FALSE;
5057                                         n->agg_distinct = FALSE;
5058                                         $$ = (Node *) makeSimpleA_Expr(OP, "~~", $1, (Node *) n);
5059                                 }
5060                 | a_expr NOT LIKE a_expr
5061                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "!~~", $1, $4); }
5062                 | a_expr NOT LIKE a_expr ESCAPE a_expr
5063                                 {
5064                                         FuncCall *n = makeNode(FuncCall);
5065                                         n->funcname = SystemFuncName("like_escape");
5066                                         n->args = makeList2($4, $6);
5067                                         n->agg_star = FALSE;
5068                                         n->agg_distinct = FALSE;
5069                                         $$ = (Node *) makeSimpleA_Expr(OP, "!~~", $1, (Node *) n);
5070                                 }
5071                 | a_expr ILIKE a_expr
5072                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "~~*", $1, $3); }
5073                 | a_expr ILIKE a_expr ESCAPE a_expr
5074                                 {
5075                                         FuncCall *n = makeNode(FuncCall);
5076                                         n->funcname = SystemFuncName("like_escape");
5077                                         n->args = makeList2($3, $5);
5078                                         n->agg_star = FALSE;
5079                                         n->agg_distinct = FALSE;
5080                                         $$ = (Node *) makeSimpleA_Expr(OP, "~~*", $1, (Node *) n);
5081                                 }
5082                 | a_expr NOT ILIKE a_expr
5083                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "!~~*", $1, $4); }
5084                 | a_expr NOT ILIKE a_expr ESCAPE a_expr
5085                                 {
5086                                         FuncCall *n = makeNode(FuncCall);
5087                                         n->funcname = SystemFuncName("like_escape");
5088                                         n->args = makeList2($4, $6);
5089                                         n->agg_star = FALSE;
5090                                         n->agg_distinct = FALSE;
5091                                         $$ = (Node *) makeSimpleA_Expr(OP, "!~~*", $1, (Node *) n);
5092                                 }
5093
5094                 | a_expr SIMILAR TO a_expr                              %prec SIMILAR
5095                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "~", $1, $4); }
5096                 | a_expr SIMILAR TO a_expr ESCAPE a_expr
5097                                 {
5098                                         FuncCall *n = makeNode(FuncCall);
5099                                         n->funcname = SystemFuncName("like_escape");
5100                                         n->args = makeList2($4, $6);
5101                                         n->agg_star = FALSE;
5102                                         n->agg_distinct = FALSE;
5103                                         $$ = (Node *) makeSimpleA_Expr(OP, "~", $1, (Node *) n);
5104                                 }
5105                 | a_expr NOT SIMILAR TO a_expr                  %prec SIMILAR
5106                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "!~", $1, $5); }
5107                 | a_expr NOT SIMILAR TO a_expr ESCAPE a_expr
5108                                 {
5109                                         FuncCall *n = makeNode(FuncCall);
5110                                         n->funcname = SystemFuncName("like_escape");
5111                                         n->args = makeList2($5, $7);
5112                                         n->agg_star = FALSE;
5113                                         n->agg_distinct = FALSE;
5114                                         $$ = (Node *) makeSimpleA_Expr(OP, "!~", $1, (Node *) n);
5115                                 }
5116
5117                 /* NullTest clause
5118                  * Define SQL92-style Null test clause.
5119                  * Allow two forms described in the standard:
5120                  *  a IS NULL
5121                  *  a IS NOT NULL
5122                  * Allow two SQL extensions
5123                  *  a ISNULL
5124                  *  a NOTNULL
5125                  * NOTE: this is not yet fully SQL-compatible, since SQL92
5126                  * allows a row constructor as argument, not just a scalar.
5127                  */
5128                 | a_expr ISNULL
5129                                 {
5130                                         NullTest *n = makeNode(NullTest);
5131                                         n->arg = $1;
5132                                         n->nulltesttype = IS_NULL;
5133                                         $$ = (Node *)n;
5134                                 }
5135                 | a_expr IS NULL_P
5136                                 {
5137                                         NullTest *n = makeNode(NullTest);
5138                                         n->arg = $1;
5139                                         n->nulltesttype = IS_NULL;
5140                                         $$ = (Node *)n;
5141                                 }
5142                 | a_expr NOTNULL
5143                                 {
5144                                         NullTest *n = makeNode(NullTest);
5145                                         n->arg = $1;
5146                                         n->nulltesttype = IS_NOT_NULL;
5147                                         $$ = (Node *)n;
5148                                 }
5149                 | a_expr IS NOT NULL_P
5150                                 {
5151                                         NullTest *n = makeNode(NullTest);
5152                                         n->arg = $1;
5153                                         n->nulltesttype = IS_NOT_NULL;
5154                                         $$ = (Node *)n;
5155                                 }
5156                 /* IS TRUE, IS FALSE, etc used to be function calls
5157                  *  but let's make them expressions to allow the optimizer
5158                  *  a chance to eliminate them if a_expr is a constant string.
5159                  * - thomas 1997-12-22
5160                  *
5161                  *  Created BooleanTest Node type, and changed handling
5162                  *  for NULL inputs
5163                  * - jec 2001-06-18
5164                  */
5165                 | a_expr IS TRUE_P
5166                                 {
5167                                         BooleanTest *b = makeNode(BooleanTest);
5168                                         b->arg = $1;
5169                                         b->booltesttype = IS_TRUE;
5170                                         $$ = (Node *)b;
5171                                 }
5172                 | a_expr IS NOT TRUE_P
5173                                 {
5174                                         BooleanTest *b = makeNode(BooleanTest);
5175                                         b->arg = $1;
5176                                         b->booltesttype = IS_NOT_TRUE;
5177                                         $$ = (Node *)b;
5178                                 }
5179                 | a_expr IS FALSE_P
5180                                 {
5181                                         BooleanTest *b = makeNode(BooleanTest);
5182                                         b->arg = $1;
5183                                         b->booltesttype = IS_FALSE;
5184                                         $$ = (Node *)b;
5185                                 }
5186                 | a_expr IS NOT FALSE_P
5187                                 {
5188                                         BooleanTest *b = makeNode(BooleanTest);
5189                                         b->arg = $1;
5190                                         b->booltesttype = IS_NOT_FALSE;
5191                                         $$ = (Node *)b;
5192                                 }
5193                 | a_expr IS UNKNOWN
5194                                 {
5195                                         BooleanTest *b = makeNode(BooleanTest);
5196                                         b->arg = $1;
5197                                         b->booltesttype = IS_UNKNOWN;
5198                                         $$ = (Node *)b;
5199                                 }
5200                 | a_expr IS NOT UNKNOWN
5201                                 {
5202                                         BooleanTest *b = makeNode(BooleanTest);
5203                                         b->arg = $1;
5204                                         b->booltesttype = IS_NOT_UNKNOWN;
5205                                         $$ = (Node *)b;
5206                                 }
5207                 | a_expr BETWEEN b_expr AND b_expr                      %prec BETWEEN
5208                                 {
5209                                         $$ = (Node *) makeA_Expr(AND, NIL,
5210                                                 (Node *) makeSimpleA_Expr(OP, ">=", $1, $3),
5211                                                 (Node *) makeSimpleA_Expr(OP, "<=", $1, $5));
5212                                 }
5213                 | a_expr NOT BETWEEN b_expr AND b_expr          %prec BETWEEN
5214                                 {
5215                                         $$ = (Node *) makeA_Expr(OR, NIL,
5216                                                 (Node *) makeSimpleA_Expr(OP, "<", $1, $4),
5217                                                 (Node *) makeSimpleA_Expr(OP, ">", $1, $6));
5218                                 }
5219                 | a_expr IN_P in_expr
5220                                 {
5221                                         /* in_expr returns a SubLink or a list of a_exprs */
5222                                         if (IsA($3, SubLink))
5223                                         {
5224                                                         SubLink *n = (SubLink *)$3;
5225                                                         n->lefthand = makeList1($1);
5226                                                         n->oper = (List *) makeSimpleA_Expr(OP, "=",
5227                                                                                                                                 NULL, NULL);
5228                                                         n->useor = FALSE;
5229                                                         n->subLinkType = ANY_SUBLINK;
5230                                                         $$ = (Node *)n;
5231                                         }
5232                                         else
5233                                         {
5234                                                 Node *n = NULL;
5235                                                 List *l;
5236                                                 foreach(l, (List *) $3)
5237                                                 {
5238                                                         Node *cmp;
5239                                                         cmp = (Node *) makeSimpleA_Expr(OP, "=",
5240                                                                                                                         $1, lfirst(l));
5241                                                         if (n == NULL)
5242                                                                 n = cmp;
5243                                                         else
5244                                                                 n = (Node *) makeA_Expr(OR, NIL, n, cmp);
5245                                                 }
5246                                                 $$ = n;
5247                                         }
5248                                 }
5249                 | a_expr NOT IN_P in_expr
5250                                 {
5251                                         /* in_expr returns a SubLink or a list of a_exprs */
5252                                         if (IsA($4, SubLink))
5253                                         {
5254                                                 SubLink *n = (SubLink *)$4;
5255                                                 n->lefthand = makeList1($1);
5256                                                 n->oper = (List *) makeSimpleA_Expr(OP, "<>",
5257                                                                                                                         NULL, NULL);
5258                                                 n->useor = FALSE;
5259                                                 n->subLinkType = ALL_SUBLINK;
5260                                                 $$ = (Node *)n;
5261                                         }
5262                                         else
5263                                         {
5264                                                 Node *n = NULL;
5265                                                 List *l;
5266                                                 foreach(l, (List *) $4)
5267                                                 {
5268                                                         Node *cmp;
5269                                                         cmp = (Node *) makeSimpleA_Expr(OP, "<>",
5270                                                                                                                         $1, lfirst(l));
5271                                                         if (n == NULL)
5272                                                                 n = cmp;
5273                                                         else
5274                                                                 n = (Node *) makeA_Expr(AND, NIL, n, cmp);
5275                                                 }
5276                                                 $$ = n;
5277                                         }
5278                                 }
5279                 | a_expr qual_all_Op sub_type select_with_parens                %prec Op
5280                                 {
5281                                         SubLink *n = makeNode(SubLink);
5282                                         n->lefthand = makeList1($1);
5283                                         n->oper = (List *) makeA_Expr(OP, $2, NULL, NULL);
5284                                         n->useor = FALSE; /* doesn't matter since only one col */
5285                                         n->subLinkType = $3;
5286                                         n->subselect = $4;
5287                                         $$ = (Node *)n;
5288                                 }
5289                 | row_expr
5290                                 {       $$ = $1;  }
5291                 ;
5292
5293 /*
5294  * Restricted expressions
5295  *
5296  * b_expr is a subset of the complete expression syntax defined by a_expr.
5297  *
5298  * Presently, AND, NOT, IS, and IN are the a_expr keywords that would
5299  * cause trouble in the places where b_expr is used.  For simplicity, we
5300  * just eliminate all the boolean-keyword-operator productions from b_expr.
5301  */
5302 b_expr:  c_expr
5303                                 {       $$ = $1;  }
5304                 | b_expr TYPECAST Typename
5305                                 {       $$ = makeTypeCast($1, $3); }
5306                 | '+' b_expr                                    %prec UMINUS
5307                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "+", NULL, $2); }
5308                 | '-' b_expr                                    %prec UMINUS
5309                                 {       $$ = doNegate($2); }
5310                 | '%' b_expr
5311                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", NULL, $2); }
5312                 | '^' b_expr
5313                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", NULL, $2); }
5314                 | b_expr '%'
5315                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, NULL); }
5316                 | b_expr '^'
5317                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, NULL); }
5318                 | b_expr '+' b_expr
5319                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "+", $1, $3); }
5320                 | b_expr '-' b_expr
5321                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "-", $1, $3); }
5322                 | b_expr '*' b_expr
5323                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "*", $1, $3); }
5324                 | b_expr '/' b_expr
5325                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "/", $1, $3); }
5326                 | b_expr '%' b_expr
5327                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "%", $1, $3); }
5328                 | b_expr '^' b_expr
5329                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "^", $1, $3); }
5330                 | b_expr '<' b_expr
5331                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "<", $1, $3); }
5332                 | b_expr '>' b_expr
5333                                 {       $$ = (Node *) makeSimpleA_Expr(OP, ">", $1, $3); }
5334                 | b_expr '=' b_expr
5335                                 {       $$ = (Node *) makeSimpleA_Expr(OP, "=", $1, $3); }
5336
5337                 | b_expr qual_Op b_expr                         %prec Op
5338                                 {       $$ = (Node *) makeA_Expr(OP, $2, $1, $3); }
5339                 | qual_Op b_expr                                        %prec Op
5340                                 {       $$ = (Node *) makeA_Expr(OP, $1, NULL, $2); }
5341                 | b_expr qual_Op                                        %prec POSTFIXOP
5342                                 {       $$ = (Node *) makeA_Expr(OP, $2, $1, NULL); }
5343                 ;
5344
5345 /*
5346  * Productions that can be used in both a_expr and b_expr.
5347  *
5348  * Note: productions that refer recursively to a_expr or b_expr mostly
5349  * cannot appear here.  However, it's OK to refer to a_exprs that occur
5350  * inside parentheses, such as function arguments; that cannot introduce
5351  * ambiguity to the b_expr syntax.
5352  */
5353 c_expr:  columnref
5354                                 {       $$ = (Node *) $1;  }
5355                 | AexprConst
5356                                 {       $$ = $1;  }
5357                 | PARAM attrs opt_indirection
5358                                 {
5359                                         /*
5360                                          * PARAM without field names is considered a constant,
5361                                          * but with 'em, it is not.  Not very consistent ...
5362                                          */
5363                                         ParamRef *n = makeNode(ParamRef);
5364                                         n->number = $1;
5365                                         n->fields = $2;
5366                                         n->indirection = $3;
5367                                         $$ = (Node *)n;
5368                                 }
5369                 | '(' a_expr ')'
5370                                 {       $$ = $2; }
5371                 | '(' a_expr ')' attrs opt_indirection
5372                                 {
5373                                         ExprFieldSelect *n = makeNode(ExprFieldSelect);
5374                                         n->arg = $2;
5375                                         n->fields = $4;
5376                                         n->indirection = $5;
5377                                         $$ = (Node *)n;
5378                                 }
5379                 | CAST '(' a_expr AS Typename ')'
5380                                 {       $$ = makeTypeCast($3, $5); }
5381                 | case_expr
5382                                 {       $$ = $1; }
5383                 | func_name '(' ')'
5384                                 {
5385                                         FuncCall *n = makeNode(FuncCall);
5386                                         n->funcname = $1;
5387                                         n->args = NIL;
5388                                         n->agg_star = FALSE;
5389                                         n->agg_distinct = FALSE;
5390                                         $$ = (Node *)n;
5391                                 }
5392                 | func_name '(' expr_list ')'
5393                                 {
5394                                         FuncCall *n = makeNode(FuncCall);
5395                                         n->funcname = $1;
5396                                         n->args = $3;
5397                                         n->agg_star = FALSE;
5398                                         n->agg_distinct = FALSE;
5399                                         $$ = (Node *)n;
5400                                 }
5401                 | func_name '(' ALL expr_list ')'
5402                                 {
5403                                         FuncCall *n = makeNode(FuncCall);
5404                                         n->funcname = $1;
5405                                         n->args = $4;
5406                                         n->agg_star = FALSE;
5407                                         n->agg_distinct = FALSE;
5408                                         /* Ideally we'd mark the FuncCall node to indicate
5409                                          * "must be an aggregate", but there's no provision
5410                                          * for that in FuncCall at the moment.
5411                                          */
5412                                         $$ = (Node *)n;
5413                                 }
5414                 | func_name '(' DISTINCT expr_list ')'
5415                                 {
5416                                         FuncCall *n = makeNode(FuncCall);
5417                                         n->funcname = $1;
5418                                         n->args = $4;
5419                                         n->agg_star = FALSE;
5420                                         n->agg_distinct = TRUE;
5421                                         $$ = (Node *)n;
5422                                 }
5423                 | func_name '(' '*' ')'
5424                                 {
5425                                         /*
5426                                          * For now, we transform AGGREGATE(*) into AGGREGATE(1).
5427                                          *
5428                                          * This does the right thing for COUNT(*) (in fact,
5429                                          * any certainly-non-null expression would do for COUNT),
5430                                          * and there are no other aggregates in SQL92 that accept
5431                                          * '*' as parameter.
5432                                          *
5433                                          * The FuncCall node is also marked agg_star = true,
5434                                          * so that later processing can detect what the argument
5435                                          * really was.
5436                                          */
5437                                         FuncCall *n = makeNode(FuncCall);
5438                                         A_Const *star = makeNode(A_Const);
5439
5440                                         star->val.type = T_Integer;
5441                                         star->val.val.ival = 1;
5442                                         n->funcname = $1;
5443                                         n->args = makeList1(star);
5444                                         n->agg_star = TRUE;
5445                                         n->agg_distinct = FALSE;
5446                                         $$ = (Node *)n;
5447                                 }
5448                 | CURRENT_DATE
5449                                 {
5450                                         /*
5451                                          * Translate as "'now'::text::date".
5452                                          *
5453                                          * We cannot use "'now'::date" because coerce_type() will
5454                                          * immediately reduce that to a constant representing
5455                                          * today's date.  We need to delay the conversion until
5456                                          * runtime, else the wrong things will happen when
5457                                          * CURRENT_DATE is used in a column default value or rule.
5458                                          *
5459                                          * This could be simplified if we had a way to generate
5460                                          * an expression tree representing runtime application
5461                                          * of type-input conversion functions...
5462                                          */
5463                                         A_Const *s = makeNode(A_Const);
5464                                         TypeName *d;
5465
5466                                         s->val.type = T_String;
5467                                         s->val.val.str = "now";
5468                                         s->typename = SystemTypeName("text");
5469
5470                                         d = SystemTypeName("date");
5471
5472                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5473                                 }
5474                 | CURRENT_TIME
5475                                 {
5476                                         /*
5477                                          * Translate as "'now'::text::timetz".
5478                                          * See comments for CURRENT_DATE.
5479                                          */
5480                                         A_Const *s = makeNode(A_Const);
5481                                         TypeName *d;
5482
5483                                         s->val.type = T_String;
5484                                         s->val.val.str = "now";
5485                                         s->typename = SystemTypeName("text");
5486
5487                                         d = SystemTypeName("timetz");
5488                                         /* SQL99 mandates a default precision of zero for TIME
5489                                          * fields in schemas. However, for CURRENT_TIME
5490                                          * let's preserve the microsecond precision we
5491                                          * might see from the system clock. - thomas 2001-12-07
5492                                          */
5493                                         d->typmod = 6;
5494
5495                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5496                                 }
5497                 | CURRENT_TIME '(' Iconst ')'
5498                                 {
5499                                         /*
5500                                          * Translate as "'now'::text::timetz(n)".
5501                                          * See comments for CURRENT_DATE.
5502                                          */
5503                                         A_Const *s = makeNode(A_Const);
5504                                         TypeName *d;
5505
5506                                         s->val.type = T_String;
5507                                         s->val.val.str = "now";
5508                                         s->typename = SystemTypeName("text");
5509                                         d = SystemTypeName("timetz");
5510                                         if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
5511                                                 elog(ERROR, "CURRENT_TIME(%d) precision must be between %d and %d",
5512                                                          $3, 0, MAX_TIME_PRECISION);
5513                                         d->typmod = $3;
5514
5515                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5516                                 }
5517                 | CURRENT_TIMESTAMP
5518                                 {
5519                                         /*
5520                                          * Translate as "'now'::text::timestamptz".
5521                                          * See comments for CURRENT_DATE.
5522                                          */
5523                                         A_Const *s = makeNode(A_Const);
5524                                         TypeName *d;
5525
5526                                         s->val.type = T_String;
5527                                         s->val.val.str = "now";
5528                                         s->typename = SystemTypeName("text");
5529
5530                                         d = SystemTypeName("timestamptz");
5531                                         /* SQL99 mandates a default precision of 6 for timestamp.
5532                                          * Also, that is about as precise as we will get since
5533                                          * we are using a microsecond time interface.
5534                                          * - thomas 2001-12-07
5535                                          */
5536                                         d->typmod = 6;
5537
5538                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5539                                 }
5540                 | CURRENT_TIMESTAMP '(' Iconst ')'
5541                                 {
5542                                         /*
5543                                          * Translate as "'now'::text::timestamptz(n)".
5544                                          * See comments for CURRENT_DATE.
5545                                          */
5546                                         A_Const *s = makeNode(A_Const);
5547                                         TypeName *d;
5548
5549                                         s->val.type = T_String;
5550                                         s->val.val.str = "now";
5551                                         s->typename = SystemTypeName("text");
5552
5553                                         d = SystemTypeName("timestamptz");
5554                                         if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
5555                                                 elog(ERROR, "CURRENT_TIMESTAMP(%d) precision must be between %d and %d",
5556                                                          $3, 0, MAX_TIMESTAMP_PRECISION);
5557                                         d->typmod = $3;
5558
5559                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5560                                 }
5561                 | LOCALTIME
5562                                 {
5563                                         /*
5564                                          * Translate as "'now'::text::time".
5565                                          * See comments for CURRENT_DATE.
5566                                          */
5567                                         A_Const *s = makeNode(A_Const);
5568                                         TypeName *d;
5569
5570                                         s->val.type = T_String;
5571                                         s->val.val.str = "now";
5572                                         s->typename = SystemTypeName("text");
5573
5574                                         d = SystemTypeName("time");
5575                                         /* SQL99 mandates a default precision of zero for TIME
5576                                          * fields in schemas. However, for LOCALTIME
5577                                          * let's preserve the microsecond precision we
5578                                          * might see from the system clock. - thomas 2001-12-07
5579                                          */
5580                                         d->typmod = 6;
5581
5582                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5583                                 }
5584                 | LOCALTIME '(' Iconst ')'
5585                                 {
5586                                         /*
5587                                          * Translate as "'now'::text::time(n)".
5588                                          * See comments for CURRENT_DATE.
5589                                          */
5590                                         A_Const *s = makeNode(A_Const);
5591                                         TypeName *d;
5592
5593                                         s->val.type = T_String;
5594                                         s->val.val.str = "now";
5595                                         s->typename = SystemTypeName("text");
5596                                         d = SystemTypeName("time");
5597                                         if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
5598                                                 elog(ERROR, "LOCALTIME(%d) precision must be between %d and %d",
5599                                                          $3, 0, MAX_TIME_PRECISION);
5600                                         d->typmod = $3;
5601
5602                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5603                                 }
5604                 | LOCALTIMESTAMP
5605                                 {
5606                                         /*
5607                                          * Translate as "'now'::text::timestamp".
5608                                          * See comments for CURRENT_DATE.
5609                                          */
5610                                         A_Const *s = makeNode(A_Const);
5611                                         TypeName *d;
5612
5613                                         s->val.type = T_String;
5614                                         s->val.val.str = "now";
5615                                         s->typename = SystemTypeName("text");
5616
5617                                         d = SystemTypeName("timestamp");
5618                                         /* SQL99 mandates a default precision of 6 for timestamp.
5619                                          * Also, that is about as precise as we will get since
5620                                          * we are using a microsecond time interface.
5621                                          * - thomas 2001-12-07
5622                                          */
5623                                         d->typmod = 6;
5624
5625                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5626                                 }
5627                 | LOCALTIMESTAMP '(' Iconst ')'
5628                                 {
5629                                         /*
5630                                          * Translate as "'now'::text::timestamp(n)".
5631                                          * See comments for CURRENT_DATE.
5632                                          */
5633                                         A_Const *s = makeNode(A_Const);
5634                                         TypeName *d;
5635
5636                                         s->val.type = T_String;
5637                                         s->val.val.str = "now";
5638                                         s->typename = SystemTypeName("text");
5639
5640                                         d = SystemTypeName("timestamp");
5641                                         if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
5642                                                 elog(ERROR, "LOCALTIMESTAMP(%d) precision must be between %d and %d",
5643                                                          $3, 0, MAX_TIMESTAMP_PRECISION);
5644                                         d->typmod = $3;
5645
5646                                         $$ = (Node *)makeTypeCast((Node *)s, d);
5647                                 }
5648                 | CURRENT_USER
5649                                 {
5650                                         FuncCall *n = makeNode(FuncCall);
5651                                         n->funcname = SystemFuncName("current_user");
5652                                         n->args = NIL;
5653                                         n->agg_star = FALSE;
5654                                         n->agg_distinct = FALSE;
5655                                         $$ = (Node *)n;
5656                                 }
5657                 | SESSION_USER
5658                                 {
5659                                         FuncCall *n = makeNode(FuncCall);
5660                                         n->funcname = SystemFuncName("session_user");
5661                                         n->args = NIL;
5662                                         n->agg_star = FALSE;
5663                                         n->agg_distinct = FALSE;
5664                                         $$ = (Node *)n;
5665                                 }
5666                 | USER
5667                                 {
5668                                         FuncCall *n = makeNode(FuncCall);
5669                                         n->funcname = SystemFuncName("current_user");
5670                                         n->args = NIL;
5671                                         n->agg_star = FALSE;
5672                                         n->agg_distinct = FALSE;
5673                                         $$ = (Node *)n;
5674                                 }
5675                 | EXTRACT '(' extract_list ')'
5676                                 {
5677                                         FuncCall *n = makeNode(FuncCall);
5678                                         n->funcname = SystemFuncName("date_part");
5679                                         n->args = $3;
5680                                         n->agg_star = FALSE;
5681                                         n->agg_distinct = FALSE;
5682                                         $$ = (Node *)n;
5683                                 }
5684                 | OVERLAY '(' overlay_list ')'
5685                                 {
5686                                         /* overlay(A PLACING B FROM C FOR D) is converted to
5687                                          * substring(A, 1, C-1) || B || substring(A, C+1, C+D)
5688                                          * overlay(A PLACING B FROM C) is converted to
5689                                          * substring(A, 1, C-1) || B || substring(A, C+1, C+char_length(B))
5690                                          */
5691                                         FuncCall *n = makeNode(FuncCall);
5692                                         n->funcname = SystemFuncName("overlay");
5693                                         n->args = $3;
5694                                         n->agg_star = FALSE;
5695                                         n->agg_distinct = FALSE;
5696                                         $$ = (Node *)n;
5697                                 }
5698                 | POSITION '(' position_list ')'
5699                                 {
5700                                         /* position(A in B) is converted to position(B, A) */
5701                                         FuncCall *n = makeNode(FuncCall);
5702                                         n->funcname = SystemFuncName("position");
5703                                         n->args = $3;
5704                                         n->agg_star = FALSE;
5705                                         n->agg_distinct = FALSE;
5706                                         $$ = (Node *)n;
5707                                 }
5708                 | SUBSTRING '(' substr_list ')'
5709                                 {
5710                                         /* substring(A from B for C) is converted to
5711                                          * substring(A, B, C) - thomas 2000-11-28
5712                                          */
5713                                         FuncCall *n = makeNode(FuncCall);
5714                                         n->funcname = SystemFuncName("substring");
5715                                         n->args = $3;
5716                                         n->agg_star = FALSE;
5717                                         n->agg_distinct = FALSE;
5718                                         $$ = (Node *)n;
5719                                 }
5720                 | TRIM '(' BOTH trim_list ')'
5721                                 {
5722                                         /* various trim expressions are defined in SQL92
5723                                          * - thomas 1997-07-19
5724                                          */
5725                                         FuncCall *n = makeNode(FuncCall);
5726                                         n->funcname = SystemFuncName("btrim");
5727                                         n->args = $4;
5728                                         n->agg_star = FALSE;
5729                                         n->agg_distinct = FALSE;
5730                                         $$ = (Node *)n;
5731                                 }
5732                 | TRIM '(' LEADING trim_list ')'
5733                                 {
5734                                         FuncCall *n = makeNode(FuncCall);
5735                                         n->funcname = SystemFuncName("ltrim");
5736                                         n->args = $4;
5737                                         n->agg_star = FALSE;
5738                                         n->agg_distinct = FALSE;
5739                                         $$ = (Node *)n;
5740                                 }
5741                 | TRIM '(' TRAILING trim_list ')'
5742                                 {
5743                                         FuncCall *n = makeNode(FuncCall);
5744                                         n->funcname = SystemFuncName("rtrim");
5745                                         n->args = $4;
5746                                         n->agg_star = FALSE;
5747                                         n->agg_distinct = FALSE;
5748                                         $$ = (Node *)n;
5749                                 }
5750                 | TRIM '(' trim_list ')'
5751                                 {
5752                                         FuncCall *n = makeNode(FuncCall);
5753                                         n->funcname = SystemFuncName("btrim");
5754                                         n->args = $3;
5755                                         n->agg_star = FALSE;
5756                                         n->agg_distinct = FALSE;
5757                                         $$ = (Node *)n;
5758                                 }
5759                 | select_with_parens                    %prec UMINUS
5760                                 {
5761                                         SubLink *n = makeNode(SubLink);
5762                                         n->lefthand = NIL;
5763                                         n->oper = NIL;
5764                                         n->useor = FALSE;
5765                                         n->subLinkType = EXPR_SUBLINK;
5766                                         n->subselect = $1;
5767                                         $$ = (Node *)n;
5768                                 }
5769                 | EXISTS select_with_parens
5770                                 {
5771                                         SubLink *n = makeNode(SubLink);
5772                                         n->lefthand = NIL;
5773                                         n->oper = NIL;
5774                                         n->useor = FALSE;
5775                                         n->subLinkType = EXISTS_SUBLINK;
5776                                         n->subselect = $2;
5777                                         $$ = (Node *)n;
5778                                 }
5779                 ;
5780
5781 /*
5782  * Supporting nonterminals for expressions.
5783  */
5784
5785 opt_indirection:        opt_indirection '[' a_expr ']'
5786                                 {
5787                                         A_Indices *ai = makeNode(A_Indices);
5788                                         ai->lidx = NULL;
5789                                         ai->uidx = $3;
5790                                         $$ = lappend($1, ai);
5791                                 }
5792                 | opt_indirection '[' a_expr ':' a_expr ']'
5793                                 {
5794                                         A_Indices *ai = makeNode(A_Indices);
5795                                         ai->lidx = $3;
5796                                         ai->uidx = $5;
5797                                         $$ = lappend($1, ai);
5798                                 }
5799                 | /*EMPTY*/
5800                                 {       $$ = NIL; }
5801                 ;
5802
5803 expr_list:  a_expr
5804                                 { $$ = makeList1($1); }
5805                 | expr_list ',' a_expr
5806                                 { $$ = lappend($1, $3); }
5807                 | expr_list USING a_expr
5808                                 { $$ = lappend($1, $3); }
5809                 ;
5810
5811 extract_list:  extract_arg FROM a_expr
5812                                 {
5813                                         A_Const *n = makeNode(A_Const);
5814                                         n->val.type = T_String;
5815                                         n->val.val.str = $1;
5816                                         $$ = makeList2((Node *) n, $3);
5817                                 }
5818                 | /*EMPTY*/
5819                                 {       $$ = NIL; }
5820                 ;
5821
5822 /* Allow delimited string SCONST in extract_arg as an SQL extension.
5823  * - thomas 2001-04-12
5824  */
5825
5826 extract_arg:  IDENT                                             { $$ = $1; }
5827                 | YEAR_P                                                { $$ = "year"; }
5828                 | MONTH_P                                               { $$ = "month"; }
5829                 | DAY_P                                                 { $$ = "day"; }
5830                 | HOUR_P                                                { $$ = "hour"; }
5831                 | MINUTE_P                                              { $$ = "minute"; }
5832                 | SECOND_P                                              { $$ = "second"; }
5833                 | SCONST                                                { $$ = $1; }
5834                 ;
5835
5836 /* OVERLAY() arguments
5837  * SQL99 defines the OVERLAY() function:
5838  * o overlay(text placing text from int for int)
5839  * o overlay(text placing text from int)
5840  */
5841 overlay_list:  a_expr overlay_placing substr_from substr_for
5842                                 {
5843                                         $$ = makeList4($1, $2, $3, $4);
5844                                 }
5845                 | a_expr overlay_placing substr_from
5846                                 {
5847                                         $$ = makeList3($1, $2, $3);
5848                                 }
5849                 ;
5850
5851 overlay_placing:  PLACING a_expr
5852                                 {       $$ = $2; }
5853                 ;
5854
5855 /* position_list uses b_expr not a_expr to avoid conflict with general IN */
5856
5857 position_list:  b_expr IN_P b_expr
5858                                 {       $$ = makeList2($3, $1); }
5859                 | /*EMPTY*/
5860                                 {       $$ = NIL; }
5861                 ;
5862
5863 /* SUBSTRING() arguments
5864  * SQL9x defines a specific syntax for arguments to SUBSTRING():
5865  * o substring(text from int for int)
5866  * o substring(text from int) get entire string from starting point "int"
5867  * o substring(text for int) get first "int" characters of string
5868  * We also want to implement generic substring functions which accept
5869  * the usual generic list of arguments. So we will accept both styles
5870  * here, and convert the SQL9x style to the generic list for further
5871  * processing. - thomas 2000-11-28
5872  */
5873 substr_list:  a_expr substr_from substr_for
5874                                 {
5875                                         $$ = makeList3($1, $2, $3);
5876                                 }
5877                 | a_expr substr_for substr_from
5878                                 {
5879                                         $$ = makeList3($1, $3, $2);
5880                                 }
5881                 | a_expr substr_from
5882                                 {
5883                                         $$ = makeList2($1, $2);
5884                                 }
5885                 | a_expr substr_for
5886                                 {
5887                                         A_Const *n = makeNode(A_Const);
5888                                         n->val.type = T_Integer;
5889                                         n->val.val.ival = 1;
5890                                         $$ = makeList3($1, (Node *)n, $2);
5891                                 }
5892                 | expr_list
5893                                 {
5894                                         $$ = $1;
5895                                 }
5896                 | /*EMPTY*/
5897                                 {       $$ = NIL; }
5898                 ;
5899
5900 substr_from:  FROM a_expr
5901                                 {       $$ = $2; }
5902                 ;
5903
5904 substr_for:  FOR a_expr
5905                                 {       $$ = $2; }
5906                 ;
5907
5908 trim_list:  a_expr FROM expr_list
5909                                 { $$ = lappend($3, $1); }
5910                 | FROM expr_list
5911                                 { $$ = $2; }
5912                 | expr_list
5913                                 { $$ = $1; }
5914                 ;
5915
5916 in_expr:  select_with_parens
5917                                 {
5918                                         SubLink *n = makeNode(SubLink);
5919                                         n->subselect = $1;
5920                                         $$ = (Node *)n;
5921                                 }
5922                 | '(' in_expr_nodes ')'
5923                                 {       $$ = (Node *)$2; }
5924                 ;
5925
5926 in_expr_nodes:  a_expr
5927                                 {       $$ = makeList1($1); }
5928                 | in_expr_nodes ',' a_expr
5929                                 {       $$ = lappend($1, $3); }
5930                 ;
5931
5932 /* Case clause
5933  * Define SQL92-style case clause.
5934  * Allow all four forms described in the standard:
5935  * - Full specification
5936  *  CASE WHEN a = b THEN c ... ELSE d END
5937  * - Implicit argument
5938  *  CASE a WHEN b THEN c ... ELSE d END
5939  * - Conditional NULL
5940  *  NULLIF(x,y)
5941  *  same as CASE WHEN x = y THEN NULL ELSE x END
5942  * - Conditional substitution from list, use first non-null argument
5943  *  COALESCE(a,b,...)
5944  * same as CASE WHEN a IS NOT NULL THEN a WHEN b IS NOT NULL THEN b ... END
5945  * - thomas 1998-11-09
5946  */
5947 case_expr:  CASE case_arg when_clause_list case_default END_TRANS
5948                                 {
5949                                         CaseExpr *c = makeNode(CaseExpr);
5950                                         c->arg = $2;
5951                                         c->args = $3;
5952                                         c->defresult = $4;
5953                                         $$ = (Node *)c;
5954                                 }
5955                 | NULLIF '(' a_expr ',' a_expr ')'
5956                                 {
5957                                         CaseExpr *c = makeNode(CaseExpr);
5958                                         CaseWhen *w = makeNode(CaseWhen);
5959
5960                                         w->expr = (Node *) makeSimpleA_Expr(OP, "=", $3, $5);
5961                                         /* w->result is left NULL */
5962                                         c->args = makeList1(w);
5963                                         c->defresult = $3;
5964                                         $$ = (Node *)c;
5965                                 }
5966                 | COALESCE '(' expr_list ')'
5967                                 {
5968                                         CaseExpr *c = makeNode(CaseExpr);
5969                                         List *l;
5970                                         foreach (l,$3)
5971                                         {
5972                                                 CaseWhen *w = makeNode(CaseWhen);
5973                                                 NullTest *n = makeNode(NullTest);
5974                                                 n->arg = lfirst(l);
5975                                                 n->nulltesttype = IS_NOT_NULL;
5976                                                 w->expr = (Node *) n;
5977                                                 w->result = lfirst(l);
5978                                                 c->args = lappend(c->args, w);
5979                                         }
5980                                         $$ = (Node *)c;
5981                                 }
5982                 ;
5983
5984 when_clause_list:  when_clause_list when_clause
5985                                 { $$ = lappend($1, $2); }
5986                 | when_clause
5987                                 { $$ = makeList1($1); }
5988                 ;
5989
5990 when_clause:  WHEN a_expr THEN a_expr
5991                                 {
5992                                         CaseWhen *w = makeNode(CaseWhen);
5993                                         w->expr = $2;
5994                                         w->result = $4;
5995                                         $$ = (Node *)w;
5996                                 }
5997                 ;
5998
5999 case_default:  ELSE a_expr                                              { $$ = $2; }
6000                 | /*EMPTY*/                                                             { $$ = NULL; }
6001                 ;
6002
6003 case_arg:  a_expr
6004                                 {       $$ = $1; }
6005                 | /*EMPTY*/
6006                                 {       $$ = NULL; }
6007                 ;
6008
6009 /*
6010  * columnref starts with relation_name not ColId, so that OLD and NEW
6011  * references can be accepted.  Note that when there are more than two
6012  * dotted names, the first name is not actually a relation name...
6013  */
6014 columnref: relation_name opt_indirection
6015                                 {
6016                                         $$ = makeNode(ColumnRef);
6017                                         $$->fields = makeList1(makeString($1));
6018                                         $$->indirection = $2;
6019                                 }
6020                 | dotted_name opt_indirection
6021                                 {
6022                                         $$ = makeNode(ColumnRef);
6023                                         $$->fields = $1;
6024                                         $$->indirection = $2;
6025                                 }
6026                 ;
6027
6028 dotted_name: relation_name attrs
6029                                 { $$ = lcons(makeString($1), $2); }
6030                 ;
6031
6032 attrs:  '.' attr_name
6033                                 { $$ = makeList1(makeString($2)); }
6034                 | '.' '*'
6035                                 { $$ = makeList1(makeString("*")); }
6036                 | '.' attr_name attrs
6037                                 { $$ = lcons(makeString($2), $3); }
6038                 ;
6039
6040
6041 /*****************************************************************************
6042  *
6043  *      target lists
6044  *
6045  *****************************************************************************/
6046
6047 /* Target lists as found in SELECT ... and INSERT VALUES ( ... ) */
6048
6049 target_list:  target_list ',' target_el
6050                                 {       $$ = lappend($1, $3);  }
6051                 | target_el
6052                                 {       $$ = makeList1($1);  }
6053                 ;
6054
6055 /* AS is not optional because shift/red conflict with unary ops */
6056 target_el:  a_expr AS ColLabel
6057                                 {
6058                                         $$ = makeNode(ResTarget);
6059                                         $$->name = $3;
6060                                         $$->indirection = NIL;
6061                                         $$->val = (Node *)$1;
6062                                 }
6063                 | a_expr
6064                                 {
6065                                         $$ = makeNode(ResTarget);
6066                                         $$->name = NULL;
6067                                         $$->indirection = NIL;
6068                                         $$->val = (Node *)$1;
6069                                 }
6070                 | '*'
6071                                 {
6072                                         ColumnRef *n = makeNode(ColumnRef);
6073                                         n->fields = makeList1(makeString("*"));
6074                                         n->indirection = NIL;
6075                                         $$ = makeNode(ResTarget);
6076                                         $$->name = NULL;
6077                                         $$->indirection = NIL;
6078                                         $$->val = (Node *)n;
6079                                 }
6080                 ;
6081
6082 /* Target list as found in UPDATE table SET ...
6083 | '(' row_ ')' = '(' row_ ')'
6084 {
6085         $$ = NULL;
6086 }
6087  */
6088 update_target_list:  update_target_list ',' update_target_el
6089                                 {       $$ = lappend($1,$3);  }
6090                 | update_target_el
6091                                 {       $$ = makeList1($1);  }
6092                 ;
6093
6094 update_target_el:  ColId opt_indirection '=' a_expr
6095                                 {
6096                                         $$ = makeNode(ResTarget);
6097                                         $$->name = $1;
6098                                         $$->indirection = $2;
6099                                         $$->val = (Node *)$4;
6100                                 }
6101                 ;
6102
6103 insert_target_list:  insert_target_list ',' insert_target_el
6104                                 {       $$ = lappend($1, $3);  }
6105                 | insert_target_el
6106                                 {       $$ = makeList1($1);  }
6107                 ;
6108
6109 insert_target_el:  target_el    {       $$ = $1;  }
6110                                 | DEFAULT               {
6111                                                                         InsertDefault *def = makeNode(InsertDefault);
6112                                                                         $$ = makeNode(ResTarget);
6113                                                                         $$->name = NULL;
6114                                                                         $$->indirection = NULL;
6115                                                                         $$->val = (Node *)def;
6116                                                                 }
6117                                 ;
6118
6119
6120 /*****************************************************************************
6121  *
6122  *      Names and constants
6123  *
6124  *****************************************************************************/
6125
6126 relation_name:  SpecialRuleRelation
6127                                 {
6128                                         $$ = $1;
6129                                 }
6130                 | ColId
6131                                 {
6132                                         $$ = $1;
6133                                 }
6134                 ;
6135
6136 qualified_name_list:  qualified_name
6137                                 { $$ = makeList1($1); }
6138                 | qualified_name_list ',' qualified_name
6139                                 { $$ = lappend($1, $3); }
6140                 ;
6141
6142 qualified_name: relation_name
6143                                 {
6144                                         $$ = makeNode(RangeVar);
6145                                         $$->catalogname = NULL;
6146                                         $$->schemaname = NULL;
6147                                         $$->relname = $1;
6148                                 }
6149                 | dotted_name
6150                                 {
6151                                         $$ = makeNode(RangeVar);
6152                                         switch (length($1))
6153                                         {
6154                                                 case 2:
6155                                                         $$->catalogname = NULL;
6156                                                         $$->schemaname = strVal(lfirst($1));
6157                                                         $$->relname = strVal(lsecond($1));
6158                                                         break;
6159                                                 case 3:
6160                                                         $$->catalogname = strVal(lfirst($1));
6161                                                         $$->schemaname = strVal(lsecond($1));
6162                                                         $$->relname = strVal(lfirst(lnext(lnext($1))));
6163                                                         break;
6164                                                 default:
6165                                                         elog(ERROR, "Improper qualified name (too many dotted names): %s",
6166                                                                  NameListToString($1));
6167                                                         break;
6168                                         }
6169                                 }
6170                 ;
6171
6172 name_list:  name
6173                                 {       $$ = makeList1(makeString($1)); }
6174                 | name_list ',' name
6175                                 {       $$ = lappend($1, makeString($3)); }
6176                 ;
6177
6178
6179 name:                                   ColId                   { $$ = $1; };
6180 database_name:                  ColId                   { $$ = $1; };
6181 access_method:                  ColId                   { $$ = $1; };
6182 attr_name:                              ColId                   { $$ = $1; };
6183 index_name:                             ColId                   { $$ = $1; };
6184 file_name:                              Sconst                  { $$ = $1; };
6185
6186 func_name: function_name
6187                         { $$ = makeList1(makeString($1)); }
6188                 | dotted_name
6189                         { $$ = $1; }
6190                 ;
6191
6192
6193 /* Constants
6194  * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
6195  */
6196 AexprConst:  Iconst
6197                                 {
6198                                         A_Const *n = makeNode(A_Const);
6199                                         n->val.type = T_Integer;
6200                                         n->val.val.ival = $1;
6201                                         $$ = (Node *)n;
6202                                 }
6203                 | FCONST
6204                                 {
6205                                         A_Const *n = makeNode(A_Const);
6206                                         n->val.type = T_Float;
6207                                         n->val.val.str = $1;
6208                                         $$ = (Node *)n;
6209                                 }
6210                 | Sconst
6211                                 {
6212                                         A_Const *n = makeNode(A_Const);
6213                                         n->val.type = T_String;
6214                                         n->val.val.str = $1;
6215                                         $$ = (Node *)n;
6216                                 }
6217                 | BITCONST
6218                                 {
6219                                         A_Const *n = makeNode(A_Const);
6220                                         n->val.type = T_BitString;
6221                                         n->val.val.str = $1;
6222                                         $$ = (Node *)n;
6223                                 }
6224                 /* This rule formerly used Typename,
6225                  * but that causes reduce conflicts with subscripted column names.
6226                  * Now, separate into ConstTypename and ConstInterval,
6227                  * to allow implementing the SQL92 syntax for INTERVAL literals.
6228                  * - thomas 2000-06-24
6229                  */
6230                 | ConstTypename Sconst
6231                                 {
6232                                         A_Const *n = makeNode(A_Const);
6233                                         n->typename = $1;
6234                                         n->val.type = T_String;
6235                                         n->val.val.str = $2;
6236                                         $$ = (Node *)n;
6237                                 }
6238                 | ConstInterval Sconst opt_interval
6239                                 {
6240                                         A_Const *n = makeNode(A_Const);
6241                                         n->typename = $1;
6242                                         n->val.type = T_String;
6243                                         n->val.val.str = $2;
6244                                         /* precision is not specified, but fields may be... */
6245                                         if ($3 != -1)
6246                                                 n->typename->typmod = ((($3 & 0x7FFF) << 16) | 0xFFFF);
6247                                         $$ = (Node *)n;
6248                                 }
6249                 | ConstInterval '(' Iconst ')' Sconst opt_interval
6250                                 {
6251                                         A_Const *n = makeNode(A_Const);
6252                                         n->typename = $1;
6253                                         n->val.type = T_String;
6254                                         n->val.val.str = $5;
6255                                         /* precision specified, and fields may be... */
6256                                         if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
6257                                                 elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
6258                                                          $3, 0, MAX_INTERVAL_PRECISION);
6259                                         n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
6260                                         $$ = (Node *)n;
6261                                 }
6262                 | PARAM opt_indirection
6263                                 {
6264                                         ParamRef *n = makeNode(ParamRef);
6265                                         n->number = $1;
6266                                         n->fields = NIL;
6267                                         n->indirection = $2;
6268                                         $$ = (Node *)n;
6269                                 }
6270                 | TRUE_P
6271                                 {
6272                                         A_Const *n = makeNode(A_Const);
6273                                         n->val.type = T_String;
6274                                         n->val.val.str = "t";
6275                                         n->typename = SystemTypeName("bool");
6276                                         $$ = (Node *)n;
6277                                 }
6278                 | FALSE_P
6279                                 {
6280                                         A_Const *n = makeNode(A_Const);
6281                                         n->val.type = T_String;
6282                                         n->val.val.str = "f";
6283                                         n->typename = SystemTypeName("bool");
6284                                         $$ = (Node *)n;
6285                                 }
6286                 | NULL_P
6287                                 {
6288                                         A_Const *n = makeNode(A_Const);
6289                                         n->val.type = T_Null;
6290                                         $$ = (Node *)n;
6291                                 }
6292                 ;
6293
6294 Iconst:  ICONST                                                 { $$ = $1; };
6295 Sconst:  SCONST                                                 { $$ = $1; };
6296 UserId:  ColId                                                  { $$ = $1; };
6297
6298 /*
6299  * Name classification hierarchy.
6300  *
6301  * IDENT is the lexeme returned by the lexer for identifiers that match
6302  * no known keyword.  In most cases, we can accept certain keywords as
6303  * names, not only IDENTs.  We prefer to accept as many such keywords
6304  * as possible to minimize the impact of "reserved words" on programmers.
6305  * So, we divide names into several possible classes.  The classification
6306  * is chosen in part to make keywords acceptable as names wherever possible.
6307  */
6308
6309 /* Column identifier --- names that can be column, table, etc names.
6310  */
6311 ColId:  IDENT                                                   { $$ = $1; }
6312                 | unreserved_keyword                    { $$ = pstrdup($1); }
6313                 | col_name_keyword                              { $$ = pstrdup($1); }
6314                 ;
6315
6316 /* Type identifier --- names that can be type names.
6317  */
6318 type_name:  IDENT                                               { $$ = $1; }
6319                 | unreserved_keyword                    { $$ = pstrdup($1); }
6320                 ;
6321
6322 /* Function identifier --- names that can be function names.
6323  */
6324 function_name:  IDENT                                   { $$ = $1; }
6325                 | unreserved_keyword                    { $$ = pstrdup($1); }
6326                 | func_name_keyword                             { $$ = pstrdup($1); }
6327                 ;
6328
6329 /* Column label --- allowed labels in "AS" clauses.
6330  * This presently includes *all* Postgres keywords.
6331  */
6332 ColLabel:  IDENT                                                { $$ = $1; }
6333                 | unreserved_keyword                    { $$ = pstrdup($1); }
6334                 | col_name_keyword                              { $$ = pstrdup($1); }
6335                 | func_name_keyword                             { $$ = pstrdup($1); }
6336                 | reserved_keyword                              { $$ = pstrdup($1); }
6337                 ;
6338
6339
6340 /*
6341  * Keyword classification lists.  Generally, every keyword present in
6342  * the Postgres grammar should appear in exactly one of these lists.
6343  *
6344  * Put a new keyword into the first list that it can go into without causing
6345  * shift or reduce conflicts.  The earlier lists define "less reserved"
6346  * categories of keywords.
6347  */
6348
6349 /* "Unreserved" keywords --- available for use as any kind of name.
6350  */
6351 unreserved_keyword:
6352                   ABORT_TRANS
6353                 | ABSOLUTE
6354                 | ACCESS
6355                 | ACTION
6356                 | ADD
6357                 | AFTER
6358                 | AGGREGATE
6359                 | ALTER
6360                 | ASSERTION
6361                 | AT
6362                 | BACKWARD
6363                 | BEFORE
6364                 | BEGIN_TRANS
6365                 | BY
6366                 | CACHE
6367                 | CALLED
6368                 | CASCADE
6369                 | CHAIN
6370                 | CHARACTERISTICS
6371                 | CHECKPOINT
6372                 | CLOSE
6373                 | CLUSTER
6374                 | COMMENT
6375                 | COMMIT
6376                 | COMMITTED
6377                 | CONSTRAINTS
6378                 | COPY
6379                 | CREATEDB
6380                 | CREATEUSER
6381                 | CURSOR
6382                 | CYCLE
6383                 | DATABASE
6384                 | DAY_P
6385                 | DECLARE
6386                 | DEFERRED
6387                 | DEFINER
6388                 | DELETE_P
6389                 | DELIMITERS
6390                 | DOMAIN_P
6391                 | DOUBLE
6392                 | DROP
6393                 | EACH
6394                 | ENCODING
6395                 | ENCRYPTED
6396                 | ESCAPE
6397                 | EXCLUSIVE
6398                 | EXECUTE
6399                 | EXPLAIN
6400                 | EXTERNAL
6401                 | FETCH
6402                 | FORCE
6403                 | FORWARD
6404                 | FUNCTION
6405                 | GET
6406                 | GLOBAL
6407                 | HANDLER
6408                 | HOUR_P
6409                 | IMMEDIATE
6410                 | IMMUTABLE
6411                 | IMPLICIT
6412                 | INCREMENT
6413                 | INDEX
6414                 | INHERITS
6415                 | INOUT
6416                 | INPUT
6417                 | INSENSITIVE
6418                 | INSERT
6419                 | INSTEAD
6420                 | INVOKER
6421                 | ISOLATION
6422                 | KEY
6423                 | LANGUAGE
6424                 | LANCOMPILER
6425                 | LEVEL
6426                 | LISTEN
6427                 | LOAD
6428                 | LOCAL
6429                 | LOCATION
6430                 | LOCK_P
6431                 | MATCH
6432                 | MAXVALUE
6433                 | MINUTE_P
6434                 | MINVALUE
6435                 | MODE
6436                 | MONTH_P
6437                 | MOVE
6438                 | NAMES
6439                 | NATIONAL
6440                 | NEXT
6441                 | NO
6442                 | NOCREATEDB
6443                 | NOCREATEUSER
6444                 | NOTHING
6445                 | NOTIFY
6446                 | OF
6447                 | OIDS
6448                 | OPERATOR
6449                 | OPTION
6450                 | OUT_P
6451                 | OWNER
6452                 | PARTIAL
6453                 | PASSWORD
6454                 | PATH_P
6455                 | PENDANT
6456                 | PRECISION
6457                 | PRIOR
6458                 | PRIVILEGES
6459                 | PROCEDURAL
6460                 | PROCEDURE
6461                 | READ
6462                 | REINDEX
6463                 | RELATIVE
6464                 | RENAME
6465                 | REPLACE
6466                 | RESET
6467                 | RESTRICT
6468                 | RETURNS
6469                 | REVOKE
6470                 | ROLLBACK
6471                 | ROW
6472                 | RULE
6473                 | SCHEMA
6474                 | SCROLL
6475                 | SECOND_P
6476                 | SECURITY
6477                 | SESSION
6478                 | SEQUENCE
6479                 | SERIALIZABLE
6480                 | SET
6481                 | SHARE
6482                 | SHOW
6483                 | STABLE
6484                 | START
6485                 | STATEMENT
6486                 | STATISTICS
6487                 | STDIN
6488                 | STDOUT
6489                 | STORAGE
6490                 | STRICT
6491                 | SYSID
6492                 | TEMP
6493                 | TEMPLATE
6494                 | TEMPORARY
6495                 | TOAST
6496                 | TRANSACTION
6497                 | TRIGGER
6498                 | TRUNCATE
6499                 | TRUSTED
6500                 | TYPE_P
6501                 | UNENCRYPTED
6502                 | UNKNOWN
6503                 | UNLISTEN
6504                 | UNTIL
6505                 | UPDATE
6506                 | USAGE
6507                 | VACUUM
6508                 | VALID
6509                 | VALIDATOR
6510                 | VALUES
6511                 | VARYING
6512                 | VERSION
6513                 | VIEW
6514                 | VOLATILE
6515                 | WITH
6516                 | WITHOUT
6517                 | WORK
6518                 | YEAR_P
6519                 | ZONE
6520                 ;
6521
6522 /* Column identifier --- keywords that can be column, table, etc names.
6523  *
6524  * Many of these keywords will in fact be recognized as type or function
6525  * names too; but they have special productions for the purpose, and so
6526  * can't be treated as "generic" type or function names.
6527  *
6528  * The type names appearing here are not usable as function names
6529  * because they can be followed by '(' in typename productions, which
6530  * looks too much like a function call for an LR(1) parser.
6531  */
6532 col_name_keyword:
6533                   BIGINT
6534                 | BIT
6535                 | BOOLEAN
6536                 | CHAR_P
6537                 | CHARACTER
6538                 | COALESCE
6539                 | DEC
6540                 | DECIMAL
6541                 | EXISTS
6542                 | EXTRACT
6543                 | FLOAT_P
6544                 | INT
6545                 | INTEGER
6546                 | INTERVAL
6547                 | NCHAR
6548                 | NONE
6549                 | NULLIF
6550                 | NUMERIC
6551                 | OVERLAY
6552                 | POSITION
6553                 | REAL
6554                 | SETOF
6555                 | SMALLINT
6556                 | SUBSTRING
6557                 | TIME
6558                 | TIMESTAMP
6559                 | TRIM
6560                 | VARCHAR
6561                 ;
6562
6563 /* Function identifier --- keywords that can be function names.
6564  *
6565  * Most of these are keywords that are used as operators in expressions;
6566  * in general such keywords can't be column names because they would be
6567  * ambiguous with variables, but they are unambiguous as function identifiers.
6568  *
6569  * Do not include POSITION, SUBSTRING, etc here since they have explicit
6570  * productions in a_expr to support the goofy SQL9x argument syntax.
6571  * - thomas 2000-11-28
6572  */
6573 func_name_keyword:
6574                   AUTHORIZATION
6575                 | BETWEEN
6576                 | BINARY
6577                 | CROSS
6578                 | FREEZE
6579                 | FULL
6580                 | ILIKE
6581                 | IN_P
6582                 | INNER_P
6583                 | IS
6584                 | ISNULL
6585                 | JOIN
6586                 | LEFT
6587                 | LIKE
6588                 | NATURAL
6589                 | NOTNULL
6590                 | OUTER_P
6591                 | OVERLAPS
6592                 | RIGHT
6593                 | SIMILAR
6594                 | VERBOSE
6595                 ;
6596
6597 /* Reserved keyword --- these keywords are usable only as a ColLabel.
6598  *
6599  * Keywords appear here if they could not be distinguished from variable,
6600  * type, or function names in some contexts.  Don't put things here unless
6601  * forced to.
6602  */
6603 reserved_keyword:
6604                   ALL
6605                 | ANALYSE
6606                 | ANALYZE
6607                 | AND
6608                 | ANY
6609                 | AS
6610                 | ASC
6611                 | BOTH
6612                 | CASE
6613                 | CAST
6614                 | CHECK
6615                 | COLLATE
6616                 | COLUMN
6617                 | CONSTRAINT
6618                 | CREATE
6619                 | CURRENT_DATE
6620                 | CURRENT_TIME
6621                 | CURRENT_TIMESTAMP
6622                 | CURRENT_USER
6623                 | DEFAULT
6624                 | DEFERRABLE
6625                 | DESC
6626                 | DISTINCT
6627                 | DO
6628                 | ELSE
6629                 | END_TRANS
6630                 | EXCEPT
6631                 | FALSE_P
6632                 | FOR
6633                 | FOREIGN
6634                 | FROM
6635                 | GRANT
6636                 | GROUP_P
6637                 | HAVING
6638                 | INITIALLY
6639                 | INTERSECT
6640                 | INTO
6641                 | LEADING
6642                 | LIMIT
6643                 | LOCALTIME
6644                 | LOCALTIMESTAMP
6645                 | NEW
6646                 | NOT
6647                 | NULL_P
6648                 | OFF
6649                 | OFFSET
6650                 | OLD
6651                 | ON
6652                 | ONLY
6653                 | OR
6654                 | ORDER
6655                 | PLACING
6656                 | PRIMARY
6657                 | REFERENCES
6658                 | SELECT
6659                 | SESSION_USER
6660                 | SOME
6661                 | TABLE
6662                 | THEN
6663                 | TO
6664                 | TRAILING
6665                 | TRUE_P
6666                 | UNION
6667                 | UNIQUE
6668                 | USER
6669                 | USING
6670                 | WHEN
6671                 | WHERE
6672                 ;
6673
6674
6675 SpecialRuleRelation:  OLD
6676                                 {
6677                                         if (QueryIsRule)
6678                                                 $$ = "*OLD*";
6679                                         else
6680                                                 elog(ERROR, "OLD used in non-rule query");
6681                                 }
6682                 | NEW
6683                                 {
6684                                         if (QueryIsRule)
6685                                                 $$ = "*NEW*";
6686                                         else
6687                                                 elog(ERROR, "NEW used in non-rule query");
6688                                 }
6689                 ;
6690
6691 %%
6692
6693 static Node *
6694 makeTypeCast(Node *arg, TypeName *typename)
6695 {
6696         /*
6697          * If arg is an A_Const, just stick the typename into the
6698          * field reserved for it --- unless there's something there already!
6699          * (We don't want to collapse x::type1::type2 into just x::type2.)
6700          * Otherwise, generate a TypeCast node.
6701          */
6702         if (IsA(arg, A_Const) &&
6703                 ((A_Const *) arg)->typename == NULL)
6704         {
6705                 ((A_Const *) arg)->typename = typename;
6706                 return arg;
6707         }
6708         else
6709         {
6710                 TypeCast *n = makeNode(TypeCast);
6711                 n->arg = arg;
6712                 n->typename = typename;
6713                 return (Node *) n;
6714         }
6715 }
6716
6717 static Node *
6718 makeStringConst(char *str, TypeName *typename)
6719 {
6720         A_Const *n = makeNode(A_Const);
6721
6722         n->val.type = T_String;
6723         n->val.val.str = str;
6724         n->typename = typename;
6725
6726         return (Node *)n;
6727 }
6728
6729 static Node *
6730 makeIntConst(int val)
6731 {
6732         A_Const *n = makeNode(A_Const);
6733         n->val.type = T_Integer;
6734         n->val.val.ival = val;
6735         n->typename = SystemTypeName("int4");
6736
6737         return (Node *)n;
6738 }
6739
6740 static Node *
6741 makeFloatConst(char *str)
6742 {
6743         A_Const *n = makeNode(A_Const);
6744
6745         n->val.type = T_Float;
6746         n->val.val.str = str;
6747         n->typename = SystemTypeName("float8");
6748
6749         return (Node *)n;
6750 }
6751
6752 static Node *
6753 makeAConst(Value *v)
6754 {
6755         Node *n;
6756
6757         switch (v->type)
6758         {
6759                 case T_Float:
6760                         n = makeFloatConst(v->val.str);
6761                         break;
6762
6763                 case T_Integer:
6764                         n = makeIntConst(v->val.ival);
6765                         break;
6766
6767                 case T_String:
6768                 default:
6769                         n = makeStringConst(v->val.str, NULL);
6770                         break;
6771         }
6772
6773         return n;
6774 }
6775
6776 /* makeRowExpr()
6777  * Generate separate operator nodes for a single row descriptor expression.
6778  * Perhaps this should go deeper in the parser someday...
6779  * - thomas 1997-12-22
6780  */
6781 static Node *
6782 makeRowExpr(List *opr, List *largs, List *rargs)
6783 {
6784         Node *expr = NULL;
6785         Node *larg, *rarg;
6786         char *oprname;
6787
6788         if (length(largs) != length(rargs))
6789                 elog(ERROR, "Unequal number of entries in row expression");
6790
6791         if (lnext(largs) != NIL)
6792                 expr = makeRowExpr(opr, lnext(largs), lnext(rargs));
6793
6794         larg = lfirst(largs);
6795         rarg = lfirst(rargs);
6796
6797         oprname = strVal(llast(opr));
6798
6799         if ((strcmp(oprname, "=") == 0) ||
6800                 (strcmp(oprname, "<") == 0) ||
6801                 (strcmp(oprname, "<=") == 0) ||
6802                 (strcmp(oprname, ">") == 0) ||
6803                 (strcmp(oprname, ">=") == 0))
6804         {
6805                 if (expr == NULL)
6806                         expr = (Node *) makeA_Expr(OP, opr, larg, rarg);
6807                 else
6808                         expr = (Node *) makeA_Expr(AND, NIL, expr,
6809                                                                            (Node *) makeA_Expr(OP, opr,
6810                                                                                                                    larg, rarg));
6811         }
6812         else if (strcmp(oprname, "<>") == 0)
6813         {
6814                 if (expr == NULL)
6815                         expr = (Node *) makeA_Expr(OP, opr, larg, rarg);
6816                 else
6817                         expr = (Node *) makeA_Expr(OR, NIL, expr,
6818                                                                            (Node *) makeA_Expr(OP, opr,
6819                                                                                                                    larg, rarg));
6820         }
6821         else
6822         {
6823                 elog(ERROR, "Operator '%s' not implemented for row expressions",
6824                          oprname);
6825         }
6826
6827         return expr;
6828 }
6829
6830 /* findLeftmostSelect()
6831  *              Find the leftmost component SelectStmt in a set-operation parsetree.
6832  */
6833 static SelectStmt *
6834 findLeftmostSelect(SelectStmt *node)
6835 {
6836         while (node && node->op != SETOP_NONE)
6837                 node = node->larg;
6838         Assert(node && IsA(node, SelectStmt) && node->larg == NULL);
6839         return node;
6840 }
6841
6842 /* insertSelectOptions()
6843  *              Insert ORDER BY, etc into an already-constructed SelectStmt.
6844  *
6845  * This routine is just to avoid duplicating code in SelectStmt productions.
6846  */
6847 static void
6848 insertSelectOptions(SelectStmt *stmt,
6849                                         List *sortClause, List *forUpdate,
6850                                         Node *limitOffset, Node *limitCount)
6851 {
6852         /*
6853          * Tests here are to reject constructs like
6854          *      (SELECT foo ORDER BY bar) ORDER BY baz
6855          */
6856         if (sortClause)
6857         {
6858                 if (stmt->sortClause)
6859                         elog(ERROR, "Multiple ORDER BY clauses not allowed");
6860                 stmt->sortClause = sortClause;
6861         }
6862         if (forUpdate)
6863         {
6864                 if (stmt->forUpdate)
6865                         elog(ERROR, "Multiple FOR UPDATE clauses not allowed");
6866                 stmt->forUpdate = forUpdate;
6867         }
6868         if (limitOffset)
6869         {
6870                 if (stmt->limitOffset)
6871                         elog(ERROR, "Multiple OFFSET clauses not allowed");
6872                 stmt->limitOffset = limitOffset;
6873         }
6874         if (limitCount)
6875         {
6876                 if (stmt->limitCount)
6877                         elog(ERROR, "Multiple LIMIT clauses not allowed");
6878                 stmt->limitCount = limitCount;
6879         }
6880 }
6881
6882 static Node *
6883 makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg)
6884 {
6885         SelectStmt *n = makeNode(SelectStmt);
6886
6887         n->op = op;
6888         n->all = all;
6889         n->larg = (SelectStmt *) larg;
6890         n->rarg = (SelectStmt *) rarg;
6891         return (Node *) n;
6892 }
6893
6894 /* SystemFuncName()
6895  *      Build a properly-qualified reference to a built-in function.
6896  */
6897 List *
6898 SystemFuncName(char *name)
6899 {
6900         return makeList2(makeString("pg_catalog"), makeString(name));
6901 }
6902
6903 /* SystemTypeName()
6904  *      Build a properly-qualified reference to a built-in type.
6905  *
6906  * typmod is defaulted, but may be changed afterwards by caller.
6907  */
6908 TypeName *
6909 SystemTypeName(char *name)
6910 {
6911         TypeName   *n = makeNode(TypeName);
6912
6913         n->names = makeList2(makeString("pg_catalog"), makeString(name));
6914         n->typmod = -1;
6915         return n;
6916 }
6917
6918 /*
6919  * Initialize to parse one query string
6920  */
6921 void
6922 parser_init(Oid *typev, int nargs)
6923 {
6924         QueryIsRule = FALSE;
6925         /*
6926          * Keep enough information around to fill out the type of param nodes
6927          * used in postquel functions
6928          */
6929         param_type_info = typev;
6930         pfunc_num_args = nargs;
6931 }
6932
6933 /*
6934  * Fetch a parameter type previously passed to parser_init
6935  */
6936 Oid
6937 param_type(int t)
6938 {
6939         if ((t > pfunc_num_args) || (t <= 0))
6940                 return InvalidOid;
6941         return param_type_info[t - 1];
6942 }
6943
6944 /*
6945  * Test whether an a_expr is a plain NULL constant or not.
6946  */
6947 bool
6948 exprIsNullConstant(Node *arg)
6949 {
6950         if (arg && IsA(arg, A_Const))
6951         {
6952                 A_Const *con = (A_Const *) arg;
6953
6954                 if (con->val.type == T_Null &&
6955                         con->typename == NULL)
6956                         return TRUE;
6957         }
6958         return FALSE;
6959 }
6960
6961 /*
6962  * doNegate --- handle negation of a numeric constant.
6963  *
6964  * Formerly, we did this here because the optimizer couldn't cope with
6965  * indexquals that looked like "var = -4" --- it wants "var = const"
6966  * and a unary minus operator applied to a constant didn't qualify.
6967  * As of Postgres 7.0, that problem doesn't exist anymore because there
6968  * is a constant-subexpression simplifier in the optimizer.  However,
6969  * there's still a good reason for doing this here, which is that we can
6970  * postpone committing to a particular internal representation for simple
6971  * negative constants.  It's better to leave "-123.456" in string form
6972  * until we know what the desired type is.
6973  */
6974 static Node *
6975 doNegate(Node *n)
6976 {
6977         if (IsA(n, A_Const))
6978         {
6979                 A_Const *con = (A_Const *)n;
6980
6981                 if (con->val.type == T_Integer)
6982                 {
6983                         con->val.val.ival = -con->val.val.ival;
6984                         return n;
6985                 }
6986                 if (con->val.type == T_Float)
6987                 {
6988                         doNegateFloat(&con->val);
6989                         return n;
6990                 }
6991         }
6992
6993         return (Node *) makeSimpleA_Expr(OP, "-", NULL, n);
6994 }
6995
6996 static void
6997 doNegateFloat(Value *v)
6998 {
6999         char   *oldval = v->val.str;
7000
7001         Assert(IsA(v, Float));
7002         if (*oldval == '+')
7003                 oldval++;
7004         if (*oldval == '-')
7005                 v->val.str = oldval+1;  /* just strip the '-' */
7006         else
7007         {
7008                 char   *newval = (char *) palloc(strlen(oldval) + 2);
7009
7010                 *newval = '-';
7011                 strcpy(newval+1, oldval);
7012                 v->val.str = newval;
7013         }
7014 }