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

   1 %{ /* -*-text-*- */
   2
   3 /*#define YYDEBUG 1*/
   4 /*-------------------------------------------------------------------------
   5  *
   6  * gram.y--
   7  *        POSTGRES SQL YACC rules/actions
   8  *
   9  * Copyright (c) 1994, Regents of the University of California
  10  *
  11  *
  12  * IDENTIFICATION
  13  *        $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.89 1998/01/11 03:41:38 momjian Exp $
  14  *
  15  * HISTORY
  16  *        AUTHOR                        DATE                    MAJOR EVENT
  17  *        Andrew Yu                     Sept, 1994              POSTQUEL to SQL conversion
  18  *        Andrew Yu                     Oct, 1994               lispy code conversion
  19  *
  20  * NOTES
  21  *        CAPITALS are used to represent terminal symbols.
  22  *        non-capitals are used to represent non-terminals.
  23  *        SQL92-specific syntax is separated from plain SQL/Postgres syntax
  24  *        to help isolate the non-extensible portions of the parser.
  25  *
  26  *        if you use list, make sure the datum is a node so that the printing
  27  *        routines work
  28  *
  29  * WARNING
  30  *        sometimes we assign constants to makeStrings. Make sure we don't free
  31  *        those.
  32  *
  33  *-------------------------------------------------------------------------
  34  */
  35 #include <string.h>
  36 #include <ctype.h>
  37
  38 #include "postgres.h"
  39 #include "nodes/parsenodes.h"
  40 #include "nodes/print.h"
  41 #include "parser/gramparse.h"
  42 #include "parser/parse_type.h"
  43 #include "utils/acl.h"
  44 #include "utils/palloc.h"
  45 #include "catalog/catname.h"
  46 #include "utils/elog.h"
  47 #include "access/xact.h"
  48
  49 static char saved_relname[NAMEDATALEN];  /* need this for complex attributes */
  50 static bool QueryIsRule = FALSE;
  51 static Node *saved_In_Expr;
  52 static Oid      *param_type_info;
  53 static int      pfunc_num_args;
  54 extern List *parsetree;
  55
  56
  57 /*
  58  * If you need access to certain yacc-generated variables and find that
  59  * they're static by default, uncomment the next line.  (this is not a
  60  * problem, yet.)
  61  */
  62 /*#define __YYSCLASS*/
  63
  64 static char *xlateSqlType(char *);
  65 static Node *makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr);
  66 static Node *makeRowExpr(char *opr, List *largs, List *rargs);
  67 void mapTargetColumns(List *source, List *target);
  68 static List *makeConstantList( A_Const *node);
  69 static char *FlattenStringList(List *list);
  70 static char *fmtId(char *rawid);
  71 static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr);
  72 static void param_type_init(Oid *typev, int nargs);
  73
  74 Oid     param_type(int t); /* used in parse_expr.c */
  75
  76 /* old versions of flex define this as a macro */
  77 #if defined(yywrap)
  78 #undef yywrap
  79 #endif /* yywrap */
  80 %}
  81
  82
  83 %union
  84 {
  85         double                          dval;
  86         int                                     ival;
  87         char                            chr;
  88         char                            *str;
  89         bool                            boolean;
  90         bool*                           pboolean;       /* for pg_user privileges */
  91         List                            *list;
  92         Node                            *node;
  93         Value                           *value;
  94
  95         Attr                            *attr;
  96
  97         TypeName                        *typnam;
  98         DefElem                         *defelt;
  99         ParamString                     *param;
 100         SortGroupBy                     *sortgroupby;
 101         IndexElem                       *ielem;
 102         RangeVar                        *range;
 103         RelExpr                         *relexp;
 104         A_Indices                       *aind;
 105         ResTarget                       *target;
 106         ParamNo                         *paramno;
 107
 108         VersionStmt                     *vstmt;
 109         DefineStmt                      *dstmt;
 110         RuleStmt                        *rstmt;
 111         InsertStmt                      *astmt;
 112 }
 113
 114 %type <node>    stmt,
 115                 AddAttrStmt, ClosePortalStmt,
 116                 CopyStmt, CreateStmt, CreateAsStmt, CreateSeqStmt, DefineStmt, DestroyStmt,
 117                 ExtendStmt, FetchStmt,  GrantStmt, CreateTrigStmt, DropTrigStmt,
 118                 CreatePLangStmt, DropPLangStmt,
 119                 IndexStmt, ListenStmt, OptimizableStmt,
 120                 ProcedureStmt,  RecipeStmt, RemoveAggrStmt, RemoveOperStmt,
 121                 RemoveFuncStmt, RemoveStmt,
 122                 RenameStmt, RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
 123                 CreatedbStmt, DestroydbStmt, VacuumStmt, CursorStmt, SubSelect,
 124                 UpdateStmt, InsertStmt, SelectStmt, NotifyStmt, DeleteStmt, ClusterStmt,
 125                 ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt,
 126                 CreateUserStmt, AlterUserStmt, DropUserStmt
 127
 128 %type <rtstmt>
 129
 130 %type <str>             opt_database, location
 131
 132 %type <pboolean> user_createdb_clause, user_createuser_clause
 133 %type <str>   user_passwd_clause
 134 %type <str>   user_valid_clause
 135 %type <list>  user_group_list, user_group_clause
 136
 137 %type <str>             join_expr, join_outer, join_spec
 138 %type <boolean> TriggerActionTime, TriggerForSpec, PLangTrusted
 139
 140 %type <str>             TriggerEvents, TriggerFuncArg
 141
 142 %type <str>             relation_name, copy_file_name, copy_delimiter, def_name,
 143                 database_name, access_method_clause, access_method, attr_name,
 144                 class, index_name, name, file_name, recipe_name, aggr_argtype
 145
 146 %type <str>             opt_id, opt_portal_name,
 147                 all_Op, MathOp, opt_name, opt_unique,
 148                 result, OptUseOp, opt_class, SpecialRuleRelation
 149
 150 %type <str>             privileges, operation_commalist, grantee
 151 %type <chr>             operation, TriggerOneEvent
 152
 153 %type <list>    stmtblock, stmtmulti,
 154                 relation_name_list, OptTableElementList,
 155                 OptInherit, definition,
 156                 opt_with, def_args, def_name_list, func_argtypes,
 157                 oper_argtypes, OptStmtList, OptStmtBlock, OptStmtMulti,
 158                 opt_column_list, columnList, opt_va_list, va_list,
 159                 sort_clause, sortby_list, index_params, index_list, name_list,
 160                 from_clause, from_list, opt_array_bounds, nest_array_bounds,
 161                 expr_list, attrs, res_target_list, res_target_list2,
 162                 def_list, opt_indirection, group_clause, groupby_list, TriggerFuncArgs
 163
 164 %type <list>    union_clause, select_list
 165 %type <list>    join_list
 166 %type <sortgroupby>
 167                                 join_using
 168 %type <boolean> opt_union
 169
 170 %type <node>    position_expr
 171 %type <list>    extract_list, position_list
 172 %type <list>    substr_list, substr_from, substr_for, trim_list
 173 %type <list>    opt_interval
 174
 175 %type <boolean> opt_inh_star, opt_binary, opt_instead, opt_with_copy,
 176                                 index_opt_unique, opt_verbose, opt_analyze
 177
 178 %type <ival>    copy_dirn, def_type, opt_direction, remove_type,
 179                                 opt_column, event
 180
 181 %type <ival>    fetch_how_many
 182
 183 %type <list>    OptSeqList
 184 %type <defelt>  OptSeqElem
 185
 186 %type <dstmt>   def_rest
 187 %type <astmt>   insert_rest
 188
 189 %type <node>    OptTableElement, ConstraintElem
 190 %type <node>    columnDef, alter_clause
 191 %type <defelt>  def_elem
 192 %type <node>    def_arg, columnElem, where_clause,
 193                                 a_expr, a_expr_or_null, AexprConst,
 194                                 in_expr, in_expr_nodes, not_in_expr, not_in_expr_nodes,
 195                                 having_clause
 196 %type <list>    row_descriptor, row_list
 197 %type <node>    row_expr
 198 %type <list>    OptCreateAs, CreateAsList
 199 %type <node>    CreateAsElement
 200 %type <value>   NumConst
 201 %type <attr>    event_object, attr
 202 %type <sortgroupby>             groupby
 203 %type <sortgroupby>             sortby
 204 %type <ielem>   index_elem, func_index
 205 %type <range>   from_val
 206 %type <relexp>  relation_expr
 207 %type <target>  res_target_el, res_target_el2
 208 %type <paramno> ParamNo
 209
 210 %type <typnam>  Typename, opt_type, Array, Generic, Character, Datetime, Numeric
 211 %type <str>             generic, character, datetime
 212 %type <str>             opt_charset, opt_collate
 213 %type <str>             opt_float, opt_numeric, opt_decimal
 214 %type <boolean> opt_varying, opt_timezone
 215
 216 %type <ival>    Iconst
 217 %type <str>             Sconst
 218 %type <str>             Id, var_value, zone_value
 219 %type <str>             ColId, ColLabel
 220
 221 %type <node>    TableConstraint
 222 %type <list>    constraint_list, constraint_expr
 223 %type <list>    default_list, default_expr
 224 %type <list>    ColQualList, ColQualifier
 225 %type <node>    ColConstraint, ColConstraintElem
 226 %type <list>    key_actions, key_action
 227 %type <str>             key_match, key_reference
 228
 229 /*
 230  * If you make any token changes, remember to:
 231  *              - use "yacc -d" and update parse.h
 232  *              - update the keyword table in parser/keywords.c
 233  */
 234
 235 /* Reserved word tokens
 236  * SQL92 syntax has many type-specific constructs.
 237  * So, go ahead and make these types reserved words,
 238  *  and call-out the syntax explicitly.
 239  * This gets annoying when trying to also retain Postgres' nice
 240  *  type-extensible features, but we don't really have a choice.
 241  * - thomas 1997-10-11
 242  */
 243
 244 /* Keywords (in SQL92 reserved words) */
 245 %token  ACTION, ADD, ALL, ALTER, AND, AS, ASC,
 246                 BEGIN_TRANS, BETWEEN, BOTH, BY,
 247                 CASCADE, CAST, CHAR, CHARACTER, CHECK, CLOSE, COLLATE, COLUMN, COMMIT,
 248                 CONSTRAINT, CREATE, CROSS, CURRENT, CURRENT_DATE, CURRENT_TIME,
 249                 CURRENT_TIMESTAMP, CURRENT_USER, CURSOR,
 250                 DAY_P, DECIMAL, DECLARE, DEFAULT, DELETE, DESC, DISTINCT, DOUBLE, DROP,
 251                 END_TRANS, EXECUTE, EXISTS, EXTRACT,
 252                 FETCH, FLOAT, FOR, FOREIGN, FROM, FULL,
 253                 GRANT, GROUP, HAVING, HOUR_P,
 254                 IN, INNER_P, INSERT, INTERVAL, INTO, IS,
 255                 JOIN, KEY, LANGUAGE, LEADING, LEFT, LIKE, LOCAL,
 256                 MATCH, MINUTE_P, MONTH_P,
 257                 NATIONAL, NATURAL, NCHAR, NO, NOT, NOTIFY, NULL_P, NUMERIC,
 258                 ON, OPTION, OR, ORDER, OUTER_P,
 259                 PARTIAL, POSITION, PRECISION, PRIMARY, PRIVILEGES, PROCEDURE, PUBLIC,
 260                 REFERENCES, REVOKE, RIGHT, ROLLBACK,
 261                 SECOND_P, SELECT, SET, SUBSTRING,
 262                 TABLE, TIME, TIMESTAMP, TO, TRAILING, TRANSACTION, TRIM,
 263                 UNION, UNIQUE, UPDATE, USING,
 264                 VALUES, VARCHAR, VARYING, VERBOSE, VERSION, VIEW,
 265                 WHERE, WITH, WORK, YEAR_P, ZONE
 266
 267 /* Keywords (in SQL3 reserved words) */
 268 %token  FALSE_P, TRIGGER, TRUE_P
 269
 270 /* Keywords (in SQL92 non-reserved words) */
 271 %token  TYPE_P
 272
 273 /* Keywords for Postgres support (not in SQL92 reserved words) */
 274 %token  ABORT_TRANS, ACL, AFTER, AGGREGATE, ANALYZE,
 275                 APPEND, BACKWARD, BEFORE, BINARY, CHANGE, CLUSTER, COPY,
 276                 DATABASE, DELIMITERS, DO, EXPLAIN, EXTEND,
 277                 FORWARD, FUNCTION, HANDLER,
 278                 INDEX, INHERITS, INSTEAD, ISNULL,
 279                 LANCOMPILER, LISTEN, LOAD, LOCATION, MERGE, MOVE,
 280                 NEW, NONE, NOTHING, NOTNULL, OIDS, OPERATOR, PROCEDURAL,
 281                 RECIPE, RENAME, REPLACE, RESET, RETRIEVE, RETURNS, RULE,
 282                 SEQUENCE, SETOF, SHOW, STDIN, STDOUT, TRUSTED,
 283                 VACUUM, VERBOSE, VERSION
 284
 285 /* Keywords (obsolete; retain temporarily for parser - thomas 1997-12-04) */
 286 %token  ARCHIVE
 287
 288 /*
 289  * Tokens for pg_passwd support.  The CREATEDB and CREATEUSER tokens should go away
 290  * when some sort of pg_privileges relation is introduced.
 291  *
 292  *                                    Todd A. Brandys
 293  */
 294 %token  USER, PASSWORD, CREATEDB, NOCREATEDB, CREATEUSER, NOCREATEUSER, VALID, UNTIL
 295
 296 /* Special keywords, not in the query language - see the "lex" file */
 297 %token <str>    IDENT, SCONST, Op
 298 %token <ival>   ICONST, PARAM
 299 %token <dval>   FCONST
 300
 301 /* these are not real. they are here so that they get generated as #define's*/
 302 %token                  OP
 303
 304 /* precedence */
 305 %left           OR
 306 %left           AND
 307 %right          NOT
 308 %right          '='
 309 %nonassoc       '<' '>'
 310 %nonassoc       LIKE
 311 %nonassoc       BETWEEN
 312 %nonassoc       IN
 313 %nonassoc       Op                              /* multi-character ops and user-defined operators */
 314 %nonassoc       NOTNULL
 315 %nonassoc       ISNULL
 316 %nonassoc       IS
 317 %left           '+' '-'
 318 %left           '*' '/'
 319 %left           '|'                             /* this is the relation union op, not logical or */
 320 /* Unary Operators */
 321 %right          ':'
 322 %left           ';'                             /* end of statement or natural log */
 323 %right          UMINUS
 324 %left           '.'
 325 %left           '[' ']'
 326 %nonassoc       TYPECAST
 327 %nonassoc       REDUCE
 328 %left           UNION
 329 %%
 330
 331 stmtblock:  stmtmulti
 332                                 { parsetree = $1; }
 333                 | stmt
 334                                 { parsetree = lcons($1,NIL); }
 335                 ;
 336
 337 stmtmulti:  stmtmulti stmt ';'
 338                                 { $$ = lappend($1, $2); }
 339                 | stmtmulti stmt
 340                                 { $$ = lappend($1, $2); }
 341                 | stmt ';'
 342                                 { $$ = lcons($1,NIL); }
 343                 ;
 344
 345 stmt :    AddAttrStmt
 346                 | AlterUserStmt
 347                 | ClosePortalStmt
 348                 | CopyStmt
 349                 | CreateStmt
 350                 | CreateAsStmt
 351                 | CreateSeqStmt
 352                 | CreatePLangStmt
 353                 | CreateTrigStmt
 354                 | CreateUserStmt
 355                 | ClusterStmt
 356                 | DefineStmt
 357                 | DestroyStmt
 358                 | DropPLangStmt
 359                 | DropTrigStmt
 360                 | DropUserStmt
 361                 | ExtendStmt
 362                 | ExplainStmt
 363                 | FetchStmt
 364                 | GrantStmt
 365                 | IndexStmt
 366                 | ListenStmt
 367                 | ProcedureStmt
 368                 | RecipeStmt
 369                 | RemoveAggrStmt
 370                 | RemoveOperStmt
 371                 | RemoveFuncStmt
 372                 | RemoveStmt
 373                 | RenameStmt
 374                 | RevokeStmt
 375                 | OptimizableStmt
 376                 | RuleStmt
 377                 | TransactionStmt
 378                 | ViewStmt
 379                 | LoadStmt
 380                 | CreatedbStmt
 381                 | DestroydbStmt
 382                 | VacuumStmt
 383                 | VariableSetStmt
 384                 | VariableShowStmt
 385                 | VariableResetStmt
 386                 ;
 387
 388 /*****************************************************************************
 389  *
 390  * Create a new Postgres DBMS user
 391  *
 392  *
 393  *****************************************************************************/
 394
 395 CreateUserStmt:  CREATE USER Id user_passwd_clause user_createdb_clause
 396                         user_createuser_clause user_group_clause user_valid_clause
 397                                 {
 398                                         CreateUserStmt *n = makeNode(CreateUserStmt);
 399                                         n->user = $3;
 400                                         n->password = $4;
 401                                         n->createdb = $5;
 402                                         n->createuser = $6;
 403                                         n->groupElts = $7;
 404                                         n->validUntil = $8;
 405                                         $$ = (Node *)n;
 406                                 }
 407                 ;
 408
 409 /*****************************************************************************
 410  *
 411  * Alter a postresql DBMS user
 412  *
 413  *
 414  *****************************************************************************/
 415
 416 AlterUserStmt:  ALTER USER Id user_passwd_clause user_createdb_clause
 417                         user_createuser_clause user_group_clause user_valid_clause
 418                                 {
 419                                         AlterUserStmt *n = makeNode(AlterUserStmt);
 420                                         n->user = $3;
 421                                         n->password = $4;
 422                                         n->createdb = $5;
 423                                         n->createuser = $6;
 424                                         n->groupElts = $7;
 425                                         n->validUntil = $8;
 426                                         $$ = (Node *)n;
 427                                 }
 428                 ;
 429
 430 /*****************************************************************************
 431  *
 432  * Drop a postresql DBMS user
 433  *
 434  *
 435  *****************************************************************************/
 436
 437 DropUserStmt:  DROP USER Id
 438                                 {
 439                                         DropUserStmt *n = makeNode(DropUserStmt);
 440                                         n->user = $3;
 441                                         $$ = (Node *)n;
 442                                 }
 443                 ;
 444
 445 user_passwd_clause:  WITH PASSWORD Id                   { $$ = $3; }
 446                         | /*EMPTY*/                                                     { $$ = NULL; }
 447                 ;
 448
 449 user_createdb_clause:  CREATEDB
 450                                 {
 451                                         bool*  b;
 452                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 453                                         *b = true;
 454                                 }
 455                         | NOCREATEDB
 456                                 {
 457                                         bool*  b;
 458                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 459                                         *b = false;
 460                                 }
 461                         | /*EMPTY*/                                                     { $$ = NULL; }
 462                 ;
 463
 464 user_createuser_clause:  CREATEUSER
 465                                 {
 466                                         bool*  b;
 467                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 468                                         *b = true;
 469                                 }
 470                         | NOCREATEUSER
 471                                 {
 472                                         bool*  b;
 473                                         $$ = (b = (bool*)palloc(sizeof(bool)));
 474                                         *b = false;
 475                                 }
 476                         | /*EMPTY*/                                                     { $$ = NULL; }
 477                 ;
 478
 479 user_group_list:  user_group_list ',' Id
 480                                 {
 481                                         $$ = lcons((void*)makeString($3), $1);
 482                                 }
 483                         | Id
 484                                 {
 485                                         $$ = lcons((void*)makeString($1), NIL);
 486                                 }
 487                 ;
 488
 489 user_group_clause:  IN GROUP user_group_list    { $$ = $3; }
 490                         | /*EMPTY*/                                                     { $$ = NULL; }
 491                 ;
 492
 493 user_valid_clause:  VALID UNTIL SCONST                  { $$ = $3; }
 494                         | /*EMPTY*/                                                     { $$ = NULL; }
 495                 ;
 496
 497 /*****************************************************************************
 498  *
 499  * Set PG internal variable
 500  *        SET name TO 'var_value'
 501  * Include SQL92 syntax (thomas 1997-10-22):
 502  *    SET TIME ZONE 'var_value'
 503  *
 504  *****************************************************************************/
 505
 506 VariableSetStmt:  SET ColId TO var_value
 507                                 {
 508                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 509                                         n->name  = $2;
 510                                         n->value = $4;
 511                                         $$ = (Node *) n;
 512                                 }
 513                 | SET ColId '=' var_value
 514                                 {
 515                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 516                                         n->name  = $2;
 517                                         n->value = $4;
 518                                         $$ = (Node *) n;
 519                                 }
 520                 | SET TIME ZONE zone_value
 521                                 {
 522                                         VariableSetStmt *n = makeNode(VariableSetStmt);
 523                                         n->name  = "timezone";
 524                                         n->value = $4;
 525                                         $$ = (Node *) n;
 526                                 }
 527                 ;
 528
 529 var_value:  Sconst                      { $$ = $1; }
 530                 | DEFAULT                       { $$ = NULL; }
 531                 ;
 532
 533 zone_value:  Sconst                     { $$ = $1; }
 534                 | DEFAULT                       { $$ = NULL; }
 535                 | LOCAL                         { $$ = "default"; }
 536                 ;
 537
 538 VariableShowStmt:  SHOW ColId
 539                                 {
 540                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 541                                         n->name  = $2;
 542                                         $$ = (Node *) n;
 543                                 }
 544                 | SHOW TIME ZONE
 545                                 {
 546                                         VariableShowStmt *n = makeNode(VariableShowStmt);
 547                                         n->name  = "timezone";
 548                                         $$ = (Node *) n;
 549                                 }
 550                 ;
 551
 552 VariableResetStmt:      RESET ColId
 553                                 {
 554                                         VariableResetStmt *n = makeNode(VariableResetStmt);
 555                                         n->name  = $2;
 556                                         $$ = (Node *) n;
 557                                 }
 558                 | RESET TIME ZONE
 559                                 {
 560                                         VariableResetStmt *n = makeNode(VariableResetStmt);
 561                                         n->name  = "timezone";
 562                                         $$ = (Node *) n;
 563                                 }
 564                 ;
 565
 566
 567 /*****************************************************************************
 568  *
 569  *              QUERY :
 570  *                              addattr ( attr1 = type1 .. attrn = typen ) to <relname> [*]
 571  *
 572  *****************************************************************************/
 573
 574 AddAttrStmt:  ALTER TABLE relation_name opt_inh_star alter_clause
 575                                 {
 576                                         AddAttrStmt *n = makeNode(AddAttrStmt);
 577                                         n->relname = $3;
 578                                         n->inh = $4;
 579                                         n->colDef = $5;
 580                                         $$ = (Node *)n;
 581                                 }
 582                 ;
 583
 584 alter_clause:  ADD opt_column columnDef
 585                                 {
 586                                         $$ = $3;
 587                                 }
 588                         | ADD '(' OptTableElementList ')'
 589                                 {
 590                                         Node *lp = lfirst($3);
 591
 592                                         if (length($3) != 1)
 593                                                 elog(ERROR,"ALTER TABLE/ADD() allows one column only");
 594                                         $$ = lp;
 595                                 }
 596                         | DROP opt_column ColId
 597                                 {       elog(ERROR,"ALTER TABLE/DROP COLUMN not yet implemented"); }
 598                         | ALTER opt_column ColId SET DEFAULT default_expr
 599                                 {       elog(ERROR,"ALTER TABLE/ALTER COLUMN/SET DEFAULT not yet implemented"); }
 600                         | ALTER opt_column ColId DROP DEFAULT
 601                                 {       elog(ERROR,"ALTER TABLE/ALTER COLUMN/DROP DEFAULT not yet implemented"); }
 602                         | ADD ConstraintElem
 603                                 {       elog(ERROR,"ALTER TABLE/ADD CONSTRAINT not yet implemented"); }
 604                 ;
 605
 606
 607 /*****************************************************************************
 608  *
 609  *              QUERY :
 610  *                              close <optname>
 611  *
 612  *****************************************************************************/
 613
 614 ClosePortalStmt:  CLOSE opt_id
 615                                 {
 616                                         ClosePortalStmt *n = makeNode(ClosePortalStmt);
 617                                         n->portalname = $2;
 618                                         $$ = (Node *)n;
 619                                 }
 620                 ;
 621
 622
 623 /*****************************************************************************
 624  *
 625  *              QUERY :
 626  *                              COPY [BINARY] <relname> FROM/TO
 627  *                              [USING DELIMITERS <delimiter>]
 628  *
 629  *****************************************************************************/
 630
 631 CopyStmt:  COPY opt_binary relation_name opt_with_copy copy_dirn copy_file_name copy_delimiter
 632                                 {
 633                                         CopyStmt *n = makeNode(CopyStmt);
 634                                         n->binary = $2;
 635                                         n->relname = $3;
 636                                         n->oids = $4;
 637                                         n->direction = $5;
 638                                         n->filename = $6;
 639                                         n->delimiter = $7;
 640                                         $$ = (Node *)n;
 641                                 }
 642                 ;
 643
 644 copy_dirn:      TO
 645                                 { $$ = TO; }
 646                 | FROM
 647                                 { $$ = FROM; }
 648                 ;
 649
 650 /*
 651  * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
 652  * used depends on the direction. (It really doesn't make sense to copy from
 653  * stdout. We silently correct the "typo".               - AY 9/94
 654  */
 655 copy_file_name:  Sconst                                                 { $$ = $1; }
 656                 | STDIN                                                                 { $$ = NULL; }
 657                 | STDOUT                                                                { $$ = NULL; }
 658                 ;
 659
 660 opt_binary:  BINARY                                                             { $$ = TRUE; }
 661                 | /*EMPTY*/                                                             { $$ = FALSE; }
 662                 ;
 663
 664 opt_with_copy:  WITH OIDS                                               { $$ = TRUE; }
 665                 | /*EMPTY*/                                                             { $$ = FALSE; }
 666                 ;
 667
 668 /*
 669  * the default copy delimiter is tab but the user can configure it
 670  */
 671 copy_delimiter:  USING DELIMITERS Sconst                { $$ = $3; }
 672                 | /*EMPTY*/                                                             { $$ = "\t"; }
 673                 ;
 674
 675
 676 /*****************************************************************************
 677  *
 678  *              QUERY :
 679  *                              CREATE relname
 680  *
 681  *****************************************************************************/
 682
 683 CreateStmt:  CREATE TABLE relation_name '(' OptTableElementList ')'
 684                                 OptInherit OptArchiveType
 685                                 {
 686                                         CreateStmt *n = makeNode(CreateStmt);
 687                                         n->relname = $3;
 688                                         n->tableElts = $5;
 689                                         n->inhRelnames = $7;
 690                                         n->constraints = NIL;
 691                                         $$ = (Node *)n;
 692                                 }
 693                 ;
 694
 695 OptTableElementList:  OptTableElementList ',' OptTableElement
 696                                                                                                 { $$ = lappend($1, $3); }
 697                         | OptTableElement                                       { $$ = lcons($1, NIL); }
 698                         | /*EMPTY*/                                                     { $$ = NULL; }
 699                 ;
 700
 701 OptTableElement:  columnDef                                             { $$ = $1; }
 702                         | TableConstraint                                       { $$ = $1; }
 703                 ;
 704
 705 columnDef:  ColId Typename ColQualifier
 706                                 {
 707                                         ColumnDef *n = makeNode(ColumnDef);
 708                                         n->colname = $1;
 709                                         n->typename = $2;
 710                                         n->defval = NULL;
 711                                         n->is_not_null = FALSE;
 712                                         n->constraints = $3;
 713                                         $$ = (Node *)n;
 714                                 }
 715                 ;
 716
 717 ColQualifier:  ColQualList                                              { $$ = $1; }
 718                         | /*EMPTY*/                                                     { $$ = NULL; }
 719                 ;
 720
 721 ColQualList:  ColQualList ColConstraint                 { $$ = lappend($1,$2); }
 722                         | ColConstraint                                         { $$ = lcons($1, NIL); }
 723                 ;
 724
 725 ColConstraint:
 726                 CONSTRAINT name ColConstraintElem
 727                                 {
 728                                                 Constraint *n = (Constraint *)$3;
 729                                                 n->name = fmtId($2);
 730                                                 $$ = $3;
 731                                 }
 732                 | ColConstraintElem
 733                                 { $$ = $1; }
 734                 ;
 735
 736 ColConstraintElem:  CHECK '(' constraint_expr ')'
 737                                 {
 738                                         Constraint *n = makeNode(Constraint);
 739                                         n->contype = CONSTR_CHECK;
 740                                         n->name = NULL;
 741                                         n->def = FlattenStringList($3);
 742                                         n->keys = NULL;
 743                                         $$ = (Node *)n;
 744                                 }
 745                         | DEFAULT default_expr
 746                                 {
 747                                         Constraint *n = makeNode(Constraint);
 748                                         n->contype = CONSTR_DEFAULT;
 749                                         n->name = NULL;
 750                                         n->def = FlattenStringList($2);
 751                                         n->keys = NULL;
 752                                         $$ = (Node *)n;
 753                                 }
 754                         | NOT NULL_P
 755                                 {
 756                                         Constraint *n = makeNode(Constraint);
 757                                         n->contype = CONSTR_NOTNULL;
 758                                         n->name = NULL;
 759                                         n->def = NULL;
 760                                         n->keys = NULL;
 761                                         $$ = (Node *)n;
 762                                 }
 763                         | UNIQUE
 764                                 {
 765                                         Constraint *n = makeNode(Constraint);
 766                                         n->contype = CONSTR_UNIQUE;
 767                                         n->name = NULL;
 768                                         n->def = NULL;
 769                                         n->keys = NULL;
 770                                         $$ = (Node *)n;
 771                                 }
 772                         | PRIMARY KEY
 773                                 {
 774                                         Constraint *n = makeNode(Constraint);
 775                                         n->contype = CONSTR_PRIMARY;
 776                                         n->name = NULL;
 777                                         n->def = NULL;
 778                                         n->keys = NULL;
 779                                         $$ = (Node *)n;
 780                                 }
 781                         | REFERENCES ColId opt_column_list key_match key_actions
 782                                 {
 783                                         elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented");
 784                                         $$ = NULL;
 785                                 }
 786                 ;
 787
 788 default_list:  default_list ',' default_expr
 789                                 {
 790                                         $$ = lappend($1,makeString(","));
 791                                         $$ = nconc($$, $3);
 792                                 }
 793                         | default_expr
 794                                 {
 795                                         $$ = $1;
 796                                 }
 797                 ;
 798
 799 default_expr:  AexprConst
 800                                 {       $$ = makeConstantList((A_Const *) $1); }
 801                         | NULL_P
 802                                 {       $$ = lcons( makeString("NULL"), NIL); }
 803                         | '-' default_expr %prec UMINUS
 804                                 {       $$ = lcons( makeString( "-"), $2); }
 805                         | default_expr '+' default_expr
 806                                 {       $$ = nconc( $1, lcons( makeString( "+"), $3)); }
 807                         | default_expr '-' default_expr
 808                                 {       $$ = nconc( $1, lcons( makeString( "-"), $3)); }
 809                         | default_expr '/' default_expr
 810                                 {       $$ = nconc( $1, lcons( makeString( "/"), $3)); }
 811                         | default_expr '*' default_expr
 812                                 {       $$ = nconc( $1, lcons( makeString( "*"), $3)); }
 813                         | default_expr '=' default_expr
 814                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 815                         | default_expr '<' default_expr
 816                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 817                         | default_expr '>' default_expr
 818                                 {       elog(ERROR,"boolean expressions not supported in DEFAULT"); }
 819                         | ':' default_expr
 820                                 {       $$ = lcons( makeString( ":"), $2); }
 821                         | ';' default_expr
 822                                 {       $$ = lcons( makeString( ";"), $2); }
 823                         | '|' default_expr
 824                                 {       $$ = lcons( makeString( "|"), $2); }
 825                         | default_expr TYPECAST Typename
 826                                 {
 827                                         $3->name = fmtId($3->name);
 828                                         $$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
 829                                 }
 830                         | CAST default_expr AS Typename
 831                                 {
 832                                         $4->name = fmtId($4->name);
 833                                         $$ = nconc( lcons( makeString( "CAST"), $2), makeList( makeString("AS"), $4, -1));
 834                                 }
 835                         | '(' default_expr ')'
 836                                 {       $$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
 837                         | name '(' ')'
 838                                 {
 839                                         $$ = makeList( makeString($1), makeString("("), -1);
 840                                         $$ = lappend( $$, makeString(")"));
 841                                 }
 842                         | name '(' default_list ')'
 843                                 {
 844                                         $$ = makeList( makeString($1), makeString("("), -1);
 845                                         $$ = nconc( $$, $3);
 846                                         $$ = lappend( $$, makeString(")"));
 847                                 }
 848                         | default_expr Op default_expr
 849                                 {
 850                                         if (!strcmp("<=", $2) || !strcmp(">=", $2))
 851                                                 elog(ERROR,"boolean expressions not supported in DEFAULT");
 852                                         $$ = nconc( $1, lcons( makeString( $2), $3));
 853                                 }
 854                         | Op default_expr
 855                                 {       $$ = lcons( makeString( $1), $2); }
 856                         | default_expr Op
 857                                 {       $$ = lappend( $1, makeString( $2)); }
 858                         /* XXX - thomas 1997-10-07 v6.2 function-specific code to be changed */
 859                         | CURRENT_DATE
 860                                 {       $$ = lcons( makeString( "date( 'current'::datetime + '0 sec')"), NIL); }
 861                         | CURRENT_TIME
 862                                 {       $$ = lcons( makeString( "'now'::time"), NIL); }
 863                         | CURRENT_TIME '(' Iconst ')'
 864                                 {
 865                                         if ($3 != 0)
 866                                                 elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
 867                                         $$ = lcons( makeString( "'now'::time"), NIL);
 868                                 }
 869                         | CURRENT_TIMESTAMP
 870                                 {       $$ = lcons( makeString( "now()"), NIL); }
 871                         | CURRENT_TIMESTAMP '(' Iconst ')'
 872                                 {
 873                                         if ($3 != 0)
 874                                                 elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
 875                                         $$ = lcons( makeString( "now()"), NIL);
 876                                 }
 877                         | CURRENT_USER
 878                                 {       $$ = lcons( makeString( "CURRENT_USER"), NIL); }
 879                 ;
 880
 881 /* ConstraintElem specifies constraint syntax which is not embedded into
 882  *  a column definition. ColConstraintElem specifies the embedded form.
 883  * - thomas 1997-12-03
 884  */
 885 TableConstraint:  CONSTRAINT name ConstraintElem
 886                                 {
 887                                                 Constraint *n = (Constraint *)$3;
 888                                                 n->name = fmtId($2);
 889                                                 $$ = $3;
 890                                 }
 891                 | ConstraintElem
 892                                 { $$ = $1; }
 893                 ;
 894
 895 ConstraintElem:  CHECK '(' constraint_expr ')'
 896                                 {
 897                                         Constraint *n = makeNode(Constraint);
 898                                         n->contype = CONSTR_CHECK;
 899                                         n->name = NULL;
 900                                         n->def = FlattenStringList($3);
 901                                         $$ = (Node *)n;
 902                                 }
 903                 | UNIQUE '(' columnList ')'
 904                                 {
 905                                         Constraint *n = makeNode(Constraint);
 906                                         n->contype = CONSTR_UNIQUE;
 907                                         n->name = NULL;
 908                                         n->def = NULL;
 909                                         n->keys = $3;
 910                                         $$ = (Node *)n;
 911                                 }
 912                 | PRIMARY KEY '(' columnList ')'
 913                                 {
 914                                         Constraint *n = makeNode(Constraint);
 915                                         n->contype = CONSTR_PRIMARY;
 916                                         n->name = NULL;
 917                                         n->def = NULL;
 918                                         n->keys = $4;
 919                                         $$ = (Node *)n;
 920                                 }
 921                 | FOREIGN KEY '(' columnList ')' REFERENCES ColId opt_column_list key_match key_actions
 922                                 {       elog(NOTICE,"CREATE TABLE/FOREIGN KEY clause ignored; not yet implemented"); }
 923                 ;
 924
 925 constraint_list:  constraint_list ',' constraint_expr
 926                                 {
 927                                         $$ = lappend($1,makeString(","));
 928                                         $$ = nconc($$, $3);
 929                                 }
 930                         | constraint_expr
 931                                 {
 932                                         $$ = $1;
 933                                 }
 934                 ;
 935
 936 constraint_expr:  AexprConst
 937                                 {       $$ = makeConstantList((A_Const *) $1); }
 938                         | NULL_P
 939                                 {       $$ = lcons( makeString("NULL"), NIL); }
 940                         | ColId
 941                                 {
 942                                         $$ = lcons( makeString(fmtId($1)), NIL);
 943                                 }
 944                         | '-' constraint_expr %prec UMINUS
 945                                 {       $$ = lcons( makeString( "-"), $2); }
 946                         | constraint_expr '+' constraint_expr
 947                                 {       $$ = nconc( $1, lcons( makeString( "+"), $3)); }
 948                         | constraint_expr '-' constraint_expr
 949                                 {       $$ = nconc( $1, lcons( makeString( "-"), $3)); }
 950                         | constraint_expr '/' constraint_expr
 951                                 {       $$ = nconc( $1, lcons( makeString( "/"), $3)); }
 952                         | constraint_expr '*' constraint_expr
 953                                 {       $$ = nconc( $1, lcons( makeString( "*"), $3)); }
 954                         | constraint_expr '=' constraint_expr
 955                                 {       $$ = nconc( $1, lcons( makeString( "="), $3)); }
 956                         | constraint_expr '<' constraint_expr
 957                                 {       $$ = nconc( $1, lcons( makeString( "<"), $3)); }
 958                         | constraint_expr '>' constraint_expr
 959                                 {       $$ = nconc( $1, lcons( makeString( ">"), $3)); }
 960                         | ':' constraint_expr
 961                                 {       $$ = lcons( makeString( ":"), $2); }
 962                         | ';' constraint_expr
 963                                 {       $$ = lcons( makeString( ";"), $2); }
 964                         | '|' constraint_expr
 965                                 {       $$ = lcons( makeString( "|"), $2); }
 966                         | constraint_expr TYPECAST Typename
 967                                 {
 968                                         $3->name = fmtId($3->name);
 969                                         $$ = nconc( lcons( makeString( "CAST"), $1), makeList( makeString("AS"), $3, -1));
 970                                 }
 971                         | CAST constraint_expr AS Typename
 972                                 {
 973                                         $4->name = fmtId($4->name);
 974                                         $$ = nconc( lcons( makeString( "CAST"), $2), makeList( makeString("AS"), $4, -1));
 975                                 }
 976                         | '(' constraint_expr ')'
 977                                 {       $$ = lappend( lcons( makeString( "("), $2), makeString( ")")); }
 978                         | name '(' ')'
 979                                 {
 980                                         $$ = makeList( makeString($1), makeString("("), -1);
 981                                         $$ = lappend( $$, makeString(")"));
 982                                 }
 983                         | name '(' constraint_list ')'
 984                                 {
 985                                         $$ = makeList( makeString($1), makeString("("), -1);
 986                                         $$ = nconc( $$, $3);
 987                                         $$ = lappend( $$, makeString(")"));
 988                                 }
 989                         | constraint_expr Op constraint_expr
 990                                 {       $$ = nconc( $1, lcons( makeString( $2), $3)); }
 991                         | constraint_expr AND constraint_expr
 992                                 {       $$ = nconc( $1, lcons( makeString( "AND"), $3)); }
 993                         | constraint_expr OR constraint_expr
 994                                 {       $$ = nconc( $1, lcons( makeString( "OR"), $3)); }
 995                         | NOT constraint_expr
 996                                 {       $$ = lcons( makeString( "NOT"), $2); }
 997                         | Op constraint_expr
 998                                 {       $$ = lcons( makeString( $1), $2); }
 999                         | constraint_expr Op
1000                                 {       $$ = lappend( $1, makeString( $2)); }
1001                         | constraint_expr ISNULL
1002                                 {       $$ = lappend( $1, makeString( "IS NULL")); }
1003                         | constraint_expr IS NULL_P
1004                                 {       $$ = lappend( $1, makeString( "IS NULL")); }
1005                         | constraint_expr NOTNULL
1006                                 {       $$ = lappend( $1, makeString( "IS NOT NULL")); }
1007                         | constraint_expr IS NOT NULL_P
1008                                 {       $$ = lappend( $1, makeString( "IS NOT NULL")); }
1009                         | constraint_expr IS TRUE_P
1010                                 {       $$ = lappend( $1, makeString( "IS TRUE")); }
1011                         | constraint_expr IS FALSE_P
1012                                 {       $$ = lappend( $1, makeString( "IS FALSE")); }
1013                         | constraint_expr IS NOT TRUE_P
1014                                 {       $$ = lappend( $1, makeString( "IS NOT TRUE")); }
1015                         | constraint_expr IS NOT FALSE_P
1016                                 {       $$ = lappend( $1, makeString( "IS NOT FALSE")); }
1017                 ;
1018
1019 key_match:  MATCH FULL                                  { $$ = NULL; }
1020                 | MATCH PARTIAL                                 { $$ = NULL; }
1021                 | /*EMPTY*/                                             { $$ = NULL; }
1022                 ;
1023
1024 key_actions:  key_action key_action             { $$ = NIL; }
1025                 | key_action                                    { $$ = NIL; }
1026                 | /*EMPTY*/                                             { $$ = NIL; }
1027                 ;
1028
1029 key_action:  ON DELETE key_reference    { $$ = NIL; }
1030                 | ON UPDATE key_reference               { $$ = NIL; }
1031                 ;
1032
1033 key_reference:  NO ACTION                               { $$ = NULL; }
1034                 | CASCADE                                               { $$ = NULL; }
1035                 | SET DEFAULT                                   { $$ = NULL; }
1036                 | SET NULL_P                                    { $$ = NULL; }
1037                 ;
1038
1039 OptInherit:  INHERITS '(' relation_name_list ')'                { $$ = $3; }
1040                 | /*EMPTY*/                                                                             { $$ = NIL; }
1041                 ;
1042
1043 /*
1044  *      "ARCHIVE" keyword was removed in 6.3, but we keep it for now
1045  *  so people can upgrade with old pg_dump scripts. - momjian 1997-11-20(?)
1046  */
1047 OptArchiveType:  ARCHIVE '=' NONE                                               { }
1048                 | /*EMPTY*/                                                                             { }
1049                 ;
1050
1051 CreateAsStmt:  CREATE TABLE relation_name OptCreateAs AS SubSelect
1052                                 {
1053                                         SelectStmt *n = (SelectStmt *)$6;
1054                                         if ($4 != NIL)
1055                                                 mapTargetColumns($4, n->targetList);
1056                                         n->into = $3;
1057                                         $$ = (Node *)n;
1058                                 }
1059                 ;
1060
1061 OptCreateAs:  '(' CreateAsList ')'                              { $$ = $2; }
1062                         | /*EMPTY*/                                                     { $$ = NULL; }
1063                 ;
1064
1065 CreateAsList:  CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
1066                         | CreateAsElement                                       { $$ = lcons($1, NIL); }
1067                 ;
1068
1069 CreateAsElement:  ColId
1070                                 {
1071                                         ColumnDef *n = makeNode(ColumnDef);
1072                                         n->colname = $1;
1073                                         n->typename = NULL;
1074                                         n->defval = NULL;
1075                                         n->is_not_null = FALSE;
1076                                         n->constraints = NULL;
1077                                         $$ = (Node *)n;
1078                                 }
1079                 ;
1080
1081
1082 /*****************************************************************************
1083  *
1084  *              QUERY :
1085  *                              CREATE SEQUENCE seqname
1086  *
1087  *****************************************************************************/
1088
1089 CreateSeqStmt:  CREATE SEQUENCE relation_name OptSeqList
1090                                 {
1091                                         CreateSeqStmt *n = makeNode(CreateSeqStmt);
1092                                         n->seqname = $3;
1093                                         n->options = $4;
1094                                         $$ = (Node *)n;
1095                                 }
1096                 ;
1097
1098 OptSeqList:
1099                                 OptSeqList OptSeqElem
1100                                 { $$ = lappend($1, $2); }
1101                 |               { $$ = NIL; }
1102                 ;
1103
1104 OptSeqElem:             IDENT NumConst
1105                                 {
1106                                         $$ = makeNode(DefElem);
1107                                         $$->defname = $1;
1108                                         $$->arg = (Node *)$2;
1109                                 }
1110                 |               IDENT
1111                                 {
1112                                         $$ = makeNode(DefElem);
1113                                         $$->defname = $1;
1114                                         $$->arg = (Node *)NULL;
1115                                 }
1116                 ;
1117
1118 /*****************************************************************************
1119  *
1120  *              QUERIES :
1121  *                              CREATE PROCEDURAL LANGUAGE ...
1122  *                              DROP PROCEDURAL LANGUAGE ...
1123  *
1124  *****************************************************************************/
1125
1126 CreatePLangStmt:  CREATE PLangTrusted PROCEDURAL LANGUAGE Sconst
1127                         HANDLER def_name LANCOMPILER Sconst
1128                         {
1129                                 CreatePLangStmt *n = makeNode(CreatePLangStmt);
1130                                 n->plname = $5;
1131                                 n->plhandler = $7;
1132                                 n->plcompiler = $9;
1133                                 n->pltrusted = $2;
1134                                 $$ = (Node *)n;
1135                         }
1136                 ;
1137
1138 PLangTrusted:           TRUSTED { $$ = TRUE; }
1139                         |       { $$ = FALSE; }
1140
1141 DropPLangStmt:  DROP PROCEDURAL LANGUAGE Sconst
1142                         {
1143                                 DropPLangStmt *n = makeNode(DropPLangStmt);
1144                                 n->plname = $4;
1145                                 $$ = (Node *)n;
1146                         }
1147                 ;
1148
1149 /*****************************************************************************
1150  *
1151  *              QUERIES :
1152  *                              CREATE TRIGGER ...
1153  *                              DROP TRIGGER ...
1154  *
1155  *****************************************************************************/
1156
1157 CreateTrigStmt:  CREATE TRIGGER name TriggerActionTime TriggerEvents ON
1158                                 relation_name TriggerForSpec EXECUTE PROCEDURE
1159                                 name '(' TriggerFuncArgs ')'
1160                                 {
1161                                         CreateTrigStmt *n = makeNode(CreateTrigStmt);
1162                                         n->trigname = $3;
1163                                         n->relname = $7;
1164                                         n->funcname = $11;
1165                                         n->args = $13;
1166                                         n->before = $4;
1167                                         n->row = $8;
1168                                         memcpy (n->actions, $5, 4);
1169                                         $$ = (Node *)n;
1170                                 }
1171                 ;
1172
1173 TriggerActionTime:              BEFORE  { $$ = TRUE; }
1174                                 |               AFTER   { $$ = FALSE; }
1175                 ;
1176
1177 TriggerEvents:  TriggerOneEvent
1178                                         {
1179                                                         char *e = palloc (4);
1180                                                         e[0] = $1; e[1] = 0; $$ = e;
1181                                         }
1182                                 | TriggerOneEvent OR TriggerOneEvent
1183                                         {
1184                                                         char *e = palloc (4);
1185                                                         e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
1186                                         }
1187                                 | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
1188                                         {
1189                                                         char *e = palloc (4);
1190                                                         e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
1191                                                         $$ = e;
1192                                         }
1193                 ;
1194
1195 TriggerOneEvent:                INSERT  { $$ = 'i'; }
1196                                 |               DELETE  { $$ = 'd'; }
1197                                 |               UPDATE  { $$ = 'u'; }
1198                 ;
1199
1200 TriggerForSpec:  FOR name name
1201                                 {
1202                                                 if ( strcmp ($2, "each") != 0 )
1203                                                                 elog(ERROR,"parser: syntax error near %s",$2);
1204                                                 if ( strcmp ($3, "row") == 0 )
1205                                                                 $$ = TRUE;
1206                                                 else if ( strcmp ($3, "statement") == 0 )
1207                                                                 $$ = FALSE;
1208                                                 else
1209                                                                 elog(ERROR,"parser: syntax error near %s",$3);
1210                                 }
1211                 ;
1212
1213 TriggerFuncArgs:  TriggerFuncArg
1214                                 { $$ = lcons($1, NIL); }
1215                 | TriggerFuncArgs ',' TriggerFuncArg
1216                                 { $$ = lappend($1, $3); }
1217                 | /*EMPTY*/
1218                                 { $$ = NIL; }
1219                 ;
1220
1221 TriggerFuncArg:  ICONST
1222                                         {
1223                                                 char *s = (char *) palloc (256);
1224                                                 sprintf (s, "%d", $1);
1225                                                 $$ = s;
1226                                         }
1227                                 | FCONST
1228                                         {
1229                                                 char *s = (char *) palloc (256);
1230                                                 sprintf (s, "%g", $1);
1231                                                 $$ = s;
1232                                         }
1233                                 | Sconst                {  $$ = $1; }
1234                                 | IDENT                 {  $$ = $1; }
1235                 ;
1236
1237 DropTrigStmt:   DROP TRIGGER name ON relation_name
1238                                 {
1239                                         DropTrigStmt *n = makeNode(DropTrigStmt);
1240                                         n->trigname = $3;
1241                                         n->relname = $5;
1242                                         $$ = (Node *) n;
1243                                 }
1244                 ;
1245
1246
1247 /*****************************************************************************
1248  *
1249  *              QUERY :
1250  *                              define (type,operator,aggregate)
1251  *
1252  *****************************************************************************/
1253
1254 DefineStmt:  CREATE def_type def_rest
1255                                 {
1256                                         $3->defType = $2;
1257                                         $$ = (Node *)$3;
1258                                 }
1259                 ;
1260
1261 def_rest:  def_name definition
1262                                 {
1263                                         $$ = makeNode(DefineStmt);
1264                                         $$->defname = $1;
1265                                         $$->definition = $2;
1266                                 }
1267                 ;
1268
1269 def_type:  OPERATOR                                                     { $$ = OPERATOR; }
1270                 | TYPE_P                                                        { $$ = TYPE_P; }
1271                 | AGGREGATE                                                     { $$ = AGGREGATE; }
1272                 ;
1273
1274 def_name:  PROCEDURE                                            { $$ = "procedure"; }
1275                 | JOIN                                                          { $$ = "join"; }
1276                 | ColId                                                         { $$ = $1; }
1277                 | MathOp                                                        { $$ = $1; }
1278                 | Op                                                            { $$ = $1; }
1279                 ;
1280
1281 definition:  '(' def_list ')'                           { $$ = $2; }
1282                 ;
1283
1284 def_list:  def_elem                                                     { $$ = lcons($1, NIL); }
1285                 | def_list ',' def_elem                         { $$ = lappend($1, $3); }
1286                 ;
1287
1288 def_elem:  def_name '=' def_arg
1289                                 {
1290                                         $$ = makeNode(DefElem);
1291                                         $$->defname = $1;
1292                                         $$->arg = (Node *)$3;
1293                                 }
1294                 | def_name
1295                                 {
1296                                         $$ = makeNode(DefElem);
1297                                         $$->defname = $1;
1298                                         $$->arg = (Node *)NULL;
1299                                 }
1300                 | DEFAULT '=' def_arg
1301                                 {
1302                                         $$ = makeNode(DefElem);
1303                                         $$->defname = "default";
1304                                         $$->arg = (Node *)$3;
1305                                 }
1306                 ;
1307
1308 def_arg:  ColId                                                 {  $$ = (Node *)makeString($1); }
1309                 | all_Op                                                {  $$ = (Node *)makeString($1); }
1310                 | NumConst                                              {  $$ = (Node *)$1; /* already a Value */ }
1311                 | Sconst                                                {  $$ = (Node *)makeString($1); }
1312                 | SETOF ColId
1313                                 {
1314                                         TypeName *n = makeNode(TypeName);
1315                                         n->name = $2;
1316                                         n->setof = TRUE;
1317                                         n->arrayBounds = NULL;
1318                                         $$ = (Node *)n;
1319                                 }
1320                 | DOUBLE                                                {  $$ = (Node *)makeString("double"); }
1321                 ;
1322
1323
1324 /*****************************************************************************
1325  *
1326  *              QUERY:
1327  *                              destroy <relname1> [, <relname2> .. <relnameN> ]
1328  *
1329  *****************************************************************************/
1330
1331 DestroyStmt:  DROP TABLE relation_name_list
1332                                 {
1333                                         DestroyStmt *n = makeNode(DestroyStmt);
1334                                         n->relNames = $3;
1335                                         n->sequence = FALSE;
1336                                         $$ = (Node *)n;
1337                                 }
1338                 | DROP SEQUENCE relation_name_list
1339                                 {
1340                                         DestroyStmt *n = makeNode(DestroyStmt);
1341                                         n->relNames = $3;
1342                                         n->sequence = TRUE;
1343                                         $$ = (Node *)n;
1344                                 }
1345                 ;
1346
1347
1348 /*****************************************************************************
1349  *
1350  *              QUERY:
1351  *                      fetch/move [forward | backward] [number | all ] [ in <portalname> ]
1352  *
1353  *****************************************************************************/
1354
1355 FetchStmt:      FETCH opt_direction fetch_how_many opt_portal_name
1356                                 {
1357                                         FetchStmt *n = makeNode(FetchStmt);
1358                                         n->direction = $2;
1359                                         n->howMany = $3;
1360                                         n->portalname = $4;
1361                                         n->ismove = false;
1362                                         $$ = (Node *)n;
1363                                 }
1364                 |       MOVE opt_direction fetch_how_many opt_portal_name
1365                                 {
1366                                         FetchStmt *n = makeNode(FetchStmt);
1367                                         n->direction = $2;
1368                                         n->howMany = $3;
1369                                         n->portalname = $4;
1370                                         n->ismove = TRUE;
1371                                         $$ = (Node *)n;
1372                                 }
1373                 ;
1374
1375 opt_direction:  FORWARD                                                 { $$ = FORWARD; }
1376                 | BACKWARD                                                              { $$ = BACKWARD; }
1377                 | /*EMPTY*/                                                             { $$ = FORWARD; /* default */ }
1378                 ;
1379
1380 fetch_how_many:  Iconst
1381                            { $$ = $1;
1382                                  if ($1 <= 0) elog(ERROR,"Please specify nonnegative count for fetch"); }
1383                 | ALL                                                   { $$ = 0; /* 0 means fetch all tuples*/ }
1384                 | /*EMPTY*/                                             { $$ = 1; /*default*/ }
1385                 ;
1386
1387 opt_portal_name:  IN name                               { $$ = $2; }
1388                 | /*EMPTY*/                                             { $$ = NULL; }
1389                 ;
1390
1391
1392 /*****************************************************************************
1393  *
1394  *              QUERY:
1395  *                              GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
1396  *
1397  *****************************************************************************/
1398
1399 GrantStmt:  GRANT privileges ON relation_name_list TO grantee opt_with_grant
1400                                 {
1401                                         $$ = (Node*)makeAclStmt($2,$4,$6,'+');
1402                                         free($2);
1403                                         free($6);
1404                                 }
1405                 ;
1406
1407 privileges:  ALL PRIVILEGES
1408                                 {
1409                                  $$ = aclmakepriv("rwaR",0);
1410                                 }
1411                 | ALL
1412                                 {
1413                                  $$ = aclmakepriv("rwaR",0);
1414                                 }
1415                 | operation_commalist
1416                                 {
1417                                  $$ = $1;
1418                                 }
1419                 ;
1420
1421 operation_commalist:  operation
1422                                 {
1423                                                 $$ = aclmakepriv("",$1);
1424                                 }
1425                 | operation_commalist ',' operation
1426                                 {
1427                                                 $$ = aclmakepriv($1,$3);
1428                                                 free($1);
1429                                 }
1430                 ;
1431
1432 operation:  SELECT
1433                                 {
1434                                                 $$ = ACL_MODE_RD_CHR;
1435                                 }
1436                 | INSERT
1437                                 {
1438                                                 $$ = ACL_MODE_AP_CHR;
1439                                 }
1440                 | UPDATE
1441                                 {
1442                                                 $$ = ACL_MODE_WR_CHR;
1443                                 }
1444                 | DELETE
1445                                 {
1446                                                 $$ = ACL_MODE_WR_CHR;
1447                                 }
1448                 | RULE
1449                                 {
1450                                                 $$ = ACL_MODE_RU_CHR;
1451                                 }
1452                 ;
1453
1454 grantee:  PUBLIC
1455                                 {
1456                                                 $$ = aclmakeuser("A","");
1457                                 }
1458                 | GROUP ColId
1459                                 {
1460                                                 $$ = aclmakeuser("G",$2);
1461                                 }
1462                 | ColId
1463                                 {
1464                                                 $$ = aclmakeuser("U",$1);
1465                                 }
1466                 ;
1467
1468 opt_with_grant:  WITH GRANT OPTION
1469                                 {
1470                                         yyerror("WITH GRANT OPTION is not supported.  Only relation owners can set privileges");
1471                                  }
1472                 | /*EMPTY*/
1473                 ;
1474
1475
1476 /*****************************************************************************
1477  *
1478  *              QUERY:
1479  *                              REVOKE [privileges] ON [relation_name] FROM [user]
1480  *
1481  *****************************************************************************/
1482
1483 RevokeStmt:  REVOKE privileges ON relation_name_list FROM grantee
1484                                 {
1485                                         $$ = (Node*)makeAclStmt($2,$4,$6,'-');
1486                                         free($2);
1487                                         free($6);
1488                                 }
1489                 ;
1490
1491
1492 /*****************************************************************************
1493  *
1494  *              QUERY:
1495  *                              create index <indexname> on <relname>
1496  *                                using <access> "(" (<col> with <op>)+ ")" [with
1497  *                                <target_list>]
1498  *
1499  *      [where <qual>] is not supported anymore
1500  *****************************************************************************/
1501
1502 IndexStmt:      CREATE index_opt_unique INDEX index_name ON relation_name
1503                         access_method_clause '(' index_params ')' opt_with
1504                                 {
1505                                         /* should check that access_method is valid,
1506                                            etc ... but doesn't */
1507                                         IndexStmt *n = makeNode(IndexStmt);
1508                                         n->unique = $2;
1509                                         n->idxname = $4;
1510                                         n->relname = $6;
1511                                         n->accessMethod = $7;
1512                                         n->indexParams = $9;
1513                                         n->withClause = $11;
1514                                         n->whereClause = NULL;
1515                                         $$ = (Node *)n;
1516                                 }
1517                 ;
1518
1519 index_opt_unique:  UNIQUE                                               { $$ = TRUE; }
1520                 | /*EMPTY*/                                                             { $$ = FALSE; }
1521                 ;
1522
1523 access_method_clause:  USING access_method              { $$ = $2; }
1524                 | /*EMPTY*/                                                             { $$ = "btree"; }
1525                 ;
1526
1527 index_params:  index_list                                               { $$ = $1; }
1528                 | func_index                                                    { $$ = lcons($1,NIL); }
1529                 ;
1530
1531 index_list:  index_list ',' index_elem                  { $$ = lappend($1, $3); }
1532                 | index_elem                                                    { $$ = lcons($1, NIL); }
1533                 ;
1534
1535 func_index:  name '(' name_list ')' opt_type opt_class
1536                                 {
1537                                         $$ = makeNode(IndexElem);
1538                                         $$->name = $1;
1539                                         $$->args = $3;
1540                                         $$->class = $6;
1541                                         $$->tname = $5;
1542                                 }
1543                   ;
1544
1545 index_elem:  attr_name opt_type opt_class
1546                                 {
1547                                         $$ = makeNode(IndexElem);
1548                                         $$->name = $1;
1549                                         $$->args = NIL;
1550                                         $$->class = $3;
1551                                         $$->tname = $2;
1552                                 }
1553                 ;
1554
1555 opt_type:  ':' Typename                                                 { $$ = $2; }
1556                 | FOR Typename                                                  { $$ = $2; }
1557                 | /*EMPTY*/                                                             { $$ = NULL; }
1558                 ;
1559
1560 /* opt_class "WITH class" conflicts with preceeding opt_type
1561  *  for Typename of "TIMESTAMP WITH TIME ZONE"
1562  * So, remove "WITH class" from the syntax. OK??
1563  * - thomas 1997-10-12
1564  *              | WITH class                                                    { $$ = $2; }
1565  */
1566 opt_class:  class                                                               { $$ = $1; }
1567                 | USING class                                                   { $$ = $2; }
1568                 | /*EMPTY*/                                                             { $$ = NULL; }
1569                 ;
1570
1571
1572 /*****************************************************************************
1573  *
1574  *              QUERY:
1575  *                              extend index <indexname> [where <qual>]
1576  *
1577  *****************************************************************************/
1578
1579 ExtendStmt:  EXTEND INDEX index_name where_clause
1580                                 {
1581                                         ExtendStmt *n = makeNode(ExtendStmt);
1582                                         n->idxname = $3;
1583                                         n->whereClause = $4;
1584                                         $$ = (Node *)n;
1585                                 }
1586                 ;
1587
1588
1589 /*****************************************************************************
1590  *
1591  *              QUERY:
1592  *                              execute recipe <recipeName>
1593  *
1594  *****************************************************************************/
1595
1596 RecipeStmt:  EXECUTE RECIPE recipe_name
1597                                 {
1598                                         RecipeStmt *n;
1599                                         if (!IsTransactionBlock())
1600                                                 elog(ERROR,"EXECUTE RECIPE may only be used in begin/end transaction blocks");
1601
1602                                         n = makeNode(RecipeStmt);
1603                                         n->recipeName = $3;
1604                                         $$ = (Node *)n;
1605                                 }
1606                 ;
1607
1608
1609 /*****************************************************************************
1610  *
1611  *              QUERY:
1612  *                              define function <fname>
1613  *                                         (language = <lang>, returntype = <typename>
1614  *                                              [, arch_pct = <percentage | pre-defined>]
1615  *                                              [, disk_pct = <percentage | pre-defined>]
1616  *                                              [, byte_pct = <percentage | pre-defined>]
1617  *                                              [, perbyte_cpu = <int | pre-defined>]
1618  *                                              [, percall_cpu = <int | pre-defined>]
1619  *                                              [, iscachable])
1620  *                                              [arg is (<type-1> { , <type-n>})]
1621  *                                              as <filename or code in language as appropriate>
1622  *
1623  *****************************************************************************/
1624
1625 ProcedureStmt:  CREATE FUNCTION def_name def_args
1626                          RETURNS def_arg opt_with AS Sconst LANGUAGE Sconst
1627                                 {
1628                                         ProcedureStmt *n = makeNode(ProcedureStmt);
1629                                         n->funcname = $3;
1630                                         n->defArgs = $4;
1631                                         n->returnType = (Node *)$6;
1632                                         n->withClause = $7;
1633                                         n->as = $9;
1634                                         n->language = $11;
1635                                         $$ = (Node *)n;
1636                                 };
1637
1638 opt_with:  WITH definition                                              { $$ = $2; }
1639                 | /*EMPTY*/                                                     { $$ = NIL; }
1640                 ;
1641
1642 def_args:  '(' def_name_list ')'                                { $$ = $2; }
1643                 | '(' ')'                                                               { $$ = NIL; }
1644                 ;
1645
1646 def_name_list:  name_list;
1647
1648 /*****************************************************************************
1649  *
1650  *              QUERY:
1651  *
1652  *              remove function <funcname>
1653  *                              (REMOVE FUNCTION "funcname" (arg1, arg2, ...))
1654  *              remove aggregate <aggname>
1655  *                              (REMOVE AGGREGATE "aggname" "aggtype")
1656  *              remove operator <opname>
1657  *                              (REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
1658  *              remove type <typename>
1659  *                              (REMOVE TYPE "typename")
1660  *              remove rule <rulename>
1661  *                              (REMOVE RULE "rulename")
1662  *
1663  *****************************************************************************/
1664
1665 RemoveStmt:  DROP remove_type name
1666                                 {
1667                                         RemoveStmt *n = makeNode(RemoveStmt);
1668                                         n->removeType = $2;
1669                                         n->name = $3;
1670                                         $$ = (Node *)n;
1671                                 }
1672                 ;
1673
1674 remove_type:  TYPE_P                                                    {  $$ = TYPE_P; }
1675                 | INDEX                                                                 {  $$ = INDEX; }
1676                 | RULE                                                                  {  $$ = RULE; }
1677                 | VIEW                                                                  {  $$ = VIEW; }
1678                 ;
1679
1680 RemoveAggrStmt:  DROP AGGREGATE name aggr_argtype
1681                                 {
1682                                                 RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
1683                                                 n->aggname = $3;
1684                                                 n->aggtype = $4;
1685                                                 $$ = (Node *)n;
1686                                 }
1687                 ;
1688
1689 aggr_argtype:  name                                                             { $$ = $1; }
1690                 | '*'                                                                   { $$ = NULL; }
1691                 ;
1692
1693 RemoveFuncStmt:  DROP FUNCTION name '(' func_argtypes ')'
1694                                 {
1695                                         RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
1696                                         n->funcname = $3;
1697                                         n->args = $5;
1698                                         $$ = (Node *)n;
1699                                 }
1700                 ;
1701
1702 func_argtypes:  name_list                                               { $$ = $1; }
1703                 | /*EMPTY*/                                                             { $$ = NIL; }
1704                 ;
1705
1706 RemoveOperStmt:  DROP OPERATOR all_Op '(' oper_argtypes ')'
1707                                 {
1708                                         RemoveOperStmt *n = makeNode(RemoveOperStmt);
1709                                         n->opname = $3;
1710                                         n->args = $5;
1711                                         $$ = (Node *)n;
1712                                 }
1713                 ;
1714
1715 all_Op:  Op | MathOp;
1716
1717 MathOp: '+'                             { $$ = "+"; }
1718                 | '-'                   { $$ = "-"; }
1719                 | '*'                   { $$ = "*"; }
1720                 | '/'                   { $$ = "/"; }
1721                 | '<'                   { $$ = "<"; }
1722                 | '>'                   { $$ = ">"; }
1723                 | '='                   { $$ = "="; }
1724                 ;
1725
1726 oper_argtypes:  name
1727                                 {
1728                                    elog(ERROR,"parser: argument type missing (use NONE for unary operators)");
1729                                 }
1730                 | name ',' name
1731                                 { $$ = makeList(makeString($1), makeString($3), -1); }
1732                 | NONE ',' name                 /* left unary */
1733                                 { $$ = makeList(NULL, makeString($3), -1); }
1734                 | name ',' NONE                 /* right unary */
1735                                 { $$ = makeList(makeString($1), NULL, -1); }
1736                 ;
1737
1738
1739 /*****************************************************************************
1740  *
1741  *              QUERY:
1742  *                              rename <attrname1> in <relname> [*] to <attrname2>
1743  *                              rename <relname1> to <relname2>
1744  *
1745  *****************************************************************************/
1746
1747 RenameStmt:  ALTER TABLE relation_name opt_inh_star
1748                                   RENAME opt_column opt_name TO name
1749                                 {
1750                                         RenameStmt *n = makeNode(RenameStmt);
1751                                         n->relname = $3;
1752                                         n->inh = $4;
1753                                         n->column = $7;
1754                                         n->newname = $9;
1755                                         $$ = (Node *)n;
1756                                 }
1757                 ;
1758
1759 opt_name:  name                                                 { $$ = $1; }
1760                 | /*EMPTY*/                                             { $$ = NULL; }
1761                 ;
1762
1763 opt_column:  COLUMN                                             { $$ = COLUMN; }
1764                 | /*EMPTY*/                                             { $$ = 0; }
1765                 ;
1766
1767
1768 /*****************************************************************************
1769  *
1770  *              QUERY:  Define Rewrite Rule , Define Tuple Rule
1771  *                              Define Rule <old rules >
1772  *
1773  *              only rewrite rule is supported -- ay 9/94
1774  *
1775  *****************************************************************************/
1776
1777 RuleStmt:  CREATE RULE name AS
1778                    { QueryIsRule=TRUE; }
1779                    ON event TO event_object where_clause
1780                    DO opt_instead OptStmtList
1781                                 {
1782                                         RuleStmt *n = makeNode(RuleStmt);
1783                                         n->rulename = $3;
1784                                         n->event = $7;
1785                                         n->object = $9;
1786                                         n->whereClause = $10;
1787                                         n->instead = $12;
1788                                         n->actions = $13;
1789                                         $$ = (Node *)n;
1790                                 }
1791                 ;
1792
1793 OptStmtList:  NOTHING                                   { $$ = NIL; }
1794                 | OptimizableStmt                               { $$ = lcons($1, NIL); }
1795                 | '[' OptStmtBlock ']'                  { $$ = $2; }
1796                 ;
1797
1798 OptStmtBlock:  OptStmtMulti
1799                                 {  $$ = $1; }
1800                 | OptimizableStmt
1801                                 { $$ = lcons($1, NIL); }
1802                 ;
1803
1804 OptStmtMulti:  OptStmtMulti OptimizableStmt ';'
1805                                 {  $$ = lappend($1, $2); }
1806                 | OptStmtMulti OptimizableStmt
1807                                 {  $$ = lappend($1, $2); }
1808                 | OptimizableStmt ';'
1809                                 { $$ = lcons($1, NIL); }
1810                 ;
1811
1812 event_object:  relation_name '.' attr_name
1813                                 {
1814                                         $$ = makeNode(Attr);
1815                                         $$->relname = $1;
1816                                         $$->paramNo = NULL;
1817                                         $$->attrs = lcons(makeString($3), NIL);
1818                                         $$->indirection = NIL;
1819                                 }
1820                 | relation_name
1821                                 {
1822                                         $$ = makeNode(Attr);
1823                                         $$->relname = $1;
1824                                         $$->paramNo = NULL;
1825                                         $$->attrs = NIL;
1826                                         $$->indirection = NIL;
1827                                 }
1828                 ;
1829
1830 /* change me to select, update, etc. some day */
1831 event:  SELECT                                                  { $$ = CMD_SELECT; }
1832                 | UPDATE                                                { $$ = CMD_UPDATE; }
1833                 | DELETE                                                { $$ = CMD_DELETE; }
1834                 | INSERT                                                { $$ = CMD_INSERT; }
1835                  ;
1836
1837 opt_instead:  INSTEAD                                   { $$ = TRUE; }
1838                 | /*EMPTY*/                                     { $$ = FALSE; }
1839                 ;
1840
1841
1842 /*****************************************************************************
1843  *
1844  *              QUERY:
1845  *                              NOTIFY <relation_name>  can appear both in rule bodies and
1846  *                              as a query-level command
1847  *
1848  *****************************************************************************/
1849
1850 NotifyStmt:  NOTIFY relation_name
1851                                 {
1852                                         NotifyStmt *n = makeNode(NotifyStmt);
1853                                         n->relname = $2;
1854                                         $$ = (Node *)n;
1855                                 }
1856                 ;
1857
1858 ListenStmt:  LISTEN relation_name
1859                                 {
1860                                         ListenStmt *n = makeNode(ListenStmt);
1861                                         n->relname = $2;
1862                                         $$ = (Node *)n;
1863                                 }
1864 ;
1865
1866
1867 /*****************************************************************************
1868  *
1869  *              Transactions:
1870  *
1871  *              abort transaction
1872  *                              (ABORT)
1873  *              begin transaction
1874  *                              (BEGIN)
1875  *              end transaction
1876  *                              (END)
1877  *
1878  *****************************************************************************/
1879
1880 TransactionStmt:  ABORT_TRANS TRANSACTION
1881                                 {
1882                                         TransactionStmt *n = makeNode(TransactionStmt);
1883                                         n->command = ABORT_TRANS;
1884                                         $$ = (Node *)n;
1885                                 }
1886                 | BEGIN_TRANS TRANSACTION
1887                                 {
1888                                         TransactionStmt *n = makeNode(TransactionStmt);
1889                                         n->command = BEGIN_TRANS;
1890                                         $$ = (Node *)n;
1891                                 }
1892                 | BEGIN_TRANS WORK
1893                                 {
1894                                         TransactionStmt *n = makeNode(TransactionStmt);
1895                                         n->command = BEGIN_TRANS;
1896                                         $$ = (Node *)n;
1897                                 }
1898                 | COMMIT WORK
1899                                 {
1900                                         TransactionStmt *n = makeNode(TransactionStmt);
1901                                         n->command = END_TRANS;
1902                                         $$ = (Node *)n;
1903                                 }
1904                 | END_TRANS TRANSACTION
1905                                 {
1906                                         TransactionStmt *n = makeNode(TransactionStmt);
1907                                         n->command = END_TRANS;
1908                                         $$ = (Node *)n;
1909                                 }
1910                 | ROLLBACK WORK
1911                                 {
1912                                         TransactionStmt *n = makeNode(TransactionStmt);
1913                                         n->command = ABORT_TRANS;
1914                                         $$ = (Node *)n;
1915                                 }
1916
1917                 | ABORT_TRANS
1918                                 {
1919                                         TransactionStmt *n = makeNode(TransactionStmt);
1920                                         n->command = ABORT_TRANS;
1921                                         $$ = (Node *)n;
1922                                 }
1923                 | BEGIN_TRANS
1924                                 {
1925                                         TransactionStmt *n = makeNode(TransactionStmt);
1926                                         n->command = BEGIN_TRANS;
1927                                         $$ = (Node *)n;
1928                                 }
1929                 | COMMIT
1930                                 {
1931                                         TransactionStmt *n = makeNode(TransactionStmt);
1932                                         n->command = END_TRANS;
1933                                         $$ = (Node *)n;
1934                                 }
1935
1936                 | END_TRANS
1937                                 {
1938                                         TransactionStmt *n = makeNode(TransactionStmt);
1939                                         n->command = END_TRANS;
1940                                         $$ = (Node *)n;
1941                                 }
1942                 | ROLLBACK
1943                                 {
1944                                         TransactionStmt *n = makeNode(TransactionStmt);
1945                                         n->command = ABORT_TRANS;
1946                                         $$ = (Node *)n;
1947                                 }
1948                 ;
1949
1950
1951 /*****************************************************************************
1952  *
1953  *              QUERY:
1954  *                              define view <viewname> '('target-list ')' [where <quals> ]
1955  *
1956  *****************************************************************************/
1957
1958 ViewStmt:  CREATE VIEW name AS SelectStmt
1959                                 {
1960                                         ViewStmt *n = makeNode(ViewStmt);
1961                                         n->viewname = $3;
1962                                         n->query = (Query *)$5;
1963                                         if (((SelectStmt *)n->query)->unionClause != NULL)
1964                                                 elog(ERROR,"Views on unions not implemented.");
1965                                         $$ = (Node *)n;
1966                                 }
1967                 ;
1968
1969
1970 /*****************************************************************************
1971  *
1972  *              QUERY:
1973  *                              load "filename"
1974  *
1975  *****************************************************************************/
1976
1977 LoadStmt:  LOAD file_name
1978                                 {
1979                                         LoadStmt *n = makeNode(LoadStmt);
1980                                         n->filename = $2;
1981                                         $$ = (Node *)n;
1982                                 }
1983                 ;
1984
1985
1986 /*****************************************************************************
1987  *
1988  *              QUERY:
1989  *                              createdb dbname
1990  *
1991  *****************************************************************************/
1992
1993 CreatedbStmt:  CREATE DATABASE database_name opt_database
1994                                 {
1995                                         CreatedbStmt *n = makeNode(CreatedbStmt);
1996                                         n->dbname = $3;
1997                                         n->dbpath = $4;
1998                                         $$ = (Node *)n;
1999                                 }
2000                 ;
2001
2002 opt_database:  WITH LOCATION '=' location               { $$ = $4; }
2003                 | /*EMPTY*/                                                             { $$ = NULL; }
2004                 ;
2005
2006 location:  Sconst                                                               { $$ = $1; }
2007                 | DEFAULT                                                               { $$ = NULL; }
2008                 | /*EMPTY*/                                                             { $$ = NULL; }
2009                 ;
2010
2011 /*****************************************************************************
2012  *
2013  *              QUERY:
2014  *                              destroydb dbname
2015  *
2016  *****************************************************************************/
2017
2018 DestroydbStmt:  DROP DATABASE database_name
2019                                 {
2020                                         DestroydbStmt *n = makeNode(DestroydbStmt);
2021                                         n->dbname = $3;
2022                                         $$ = (Node *)n;
2023                                 }
2024                 ;
2025
2026
2027 /*****************************************************************************
2028  *
2029  *              QUERY:
2030  *                              cluster <index_name> on <relation_name>
2031  *
2032  *****************************************************************************/
2033
2034 ClusterStmt:  CLUSTER index_name ON relation_name
2035                                 {
2036                                    ClusterStmt *n = makeNode(ClusterStmt);
2037                                    n->relname = $4;
2038                                    n->indexname = $2;
2039                                    $$ = (Node*)n;
2040                                 }
2041                 ;
2042
2043
2044 /*****************************************************************************
2045  *
2046  *              QUERY:
2047  *                              vacuum
2048  *
2049  *****************************************************************************/
2050
2051 VacuumStmt:  VACUUM opt_verbose opt_analyze
2052                                 {
2053                                         VacuumStmt *n = makeNode(VacuumStmt);
2054                                         n->verbose = $2;
2055                                         n->analyze = $3;
2056                                         n->vacrel = NULL;
2057                                         n->va_spec = NIL;
2058                                         $$ = (Node *)n;
2059                                 }
2060                 | VACUUM opt_verbose opt_analyze relation_name opt_va_list
2061                                 {
2062                                         VacuumStmt *n = makeNode(VacuumStmt);
2063                                         n->verbose = $2;
2064                                         n->analyze = $3;
2065                                         n->vacrel = $4;
2066                                         n->va_spec = $5;
2067                                         if ( $5 != NIL && !$4 )
2068                                                 elog(ERROR,"parser: syntax error at or near \"(\"");
2069                                         $$ = (Node *)n;
2070                                 }
2071                 ;
2072
2073 opt_verbose:  VERBOSE                                                   { $$ = TRUE; }
2074                 | /*EMPTY*/                                                             { $$ = FALSE; }
2075                 ;
2076
2077 opt_analyze:  ANALYZE                                                   { $$ = TRUE; }
2078                 | /*EMPTY*/                                                             { $$ = FALSE; }
2079                 ;
2080
2081 opt_va_list:  '(' va_list ')'
2082                                 { $$ = $2; }
2083                 | /* EMPTY */
2084                                 { $$ = NIL; }
2085                 ;
2086
2087 va_list:  name
2088                                 { $$=lcons($1,NIL); }
2089                 | va_list ',' name
2090                                 { $$=lappend($1,$3); }
2091                 ;
2092
2093
2094 /*****************************************************************************
2095  *
2096  *              QUERY:
2097  *                              EXPLAIN query
2098  *
2099  *****************************************************************************/
2100
2101 ExplainStmt:  EXPLAIN opt_verbose OptimizableStmt
2102                                 {
2103                                         ExplainStmt *n = makeNode(ExplainStmt);
2104                                         n->verbose = $2;
2105                                         n->query = (Query*)$3;
2106                                         $$ = (Node *)n;
2107                                 }
2108                 ;
2109
2110
2111 /*****************************************************************************
2112  *                                                                                                                                                       *
2113  *              Optimizable Stmts:                                                                                                       *
2114  *                                                                                                                                                       *
2115  *              one of the five queries processed by the planner                                         *
2116  *                                                                                                                                                       *
2117  *              [ultimately] produces query-trees as specified                                           *
2118  *              in the query-spec document in ~postgres/ref                                                      *
2119  *                                                                                                                                                       *
2120  *****************************************************************************/
2121
2122 OptimizableStmt:  SelectStmt
2123                 | CursorStmt
2124                 | UpdateStmt
2125                 | InsertStmt
2126                 | NotifyStmt
2127                 | DeleteStmt                                    /* by default all are $$=$1 */
2128                 ;
2129
2130
2131 /*****************************************************************************
2132  *
2133  *              QUERY:
2134  *                              INSERT STATEMENTS
2135  *
2136  *****************************************************************************/
2137
2138 InsertStmt:  INSERT INTO relation_name opt_column_list insert_rest
2139                                 {
2140                                         $5->relname = $3;
2141                                         $5->cols = $4;
2142                                         $$ = (Node *)$5;
2143                                 }
2144                 ;
2145
2146 insert_rest:  VALUES '(' res_target_list2 ')'
2147                                 {
2148                                         $$ = makeNode(InsertStmt);
2149                                         $$->unique = NULL;
2150                                         $$->targetList = $3;
2151                                         $$->fromClause = NIL;
2152                                         $$->whereClause = NIL;
2153                                         $$->groupClause = NIL;
2154                                         $$->havingClause = NIL;
2155                                         $$->unionClause = NIL;
2156                                 }
2157                 | SELECT opt_unique res_target_list2
2158                          from_clause where_clause
2159                          group_clause having_clause
2160                          union_clause
2161                                 {
2162                                         $$ = makeNode(InsertStmt);
2163                                         $$->unique = $2;
2164                                         $$->targetList = $3;
2165                                         $$->fromClause = $4;
2166                                         $$->whereClause = $5;
2167                                         $$->groupClause = $6;
2168                                         $$->havingClause = $7;
2169                                         $$->unionClause = $8;
2170                                 }
2171                 ;
2172
2173 opt_column_list:  '(' columnList ')'                    { $$ = $2; }
2174                 | /*EMPTY*/                                                             { $$ = NIL; }
2175                 ;
2176
2177 columnList:
2178                   columnList ',' columnElem
2179                                 { $$ = lappend($1, $3); }
2180                 | columnElem
2181                                 { $$ = lcons($1, NIL); }
2182                 ;
2183
2184 columnElem:  ColId opt_indirection
2185                                 {
2186                                         Ident *id = makeNode(Ident);
2187                                         id->name = $1;
2188                                         id->indirection = $2;
2189                                         $$ = (Node *)id;
2190                                 }
2191                 ;
2192
2193
2194 /*****************************************************************************
2195  *
2196  *              QUERY:
2197  *                              DELETE STATEMENTS
2198  *
2199  *****************************************************************************/
2200
2201 DeleteStmt:  DELETE FROM relation_name
2202                          where_clause
2203                                 {
2204                                         DeleteStmt *n = makeNode(DeleteStmt);
2205                                         n->relname = $3;
2206                                         n->whereClause = $4;
2207                                         $$ = (Node *)n;
2208                                 }
2209                 ;
2210
2211
2212 /*****************************************************************************
2213  *
2214  *              QUERY:
2215  *                              UpdateStmt (UPDATE)
2216  *
2217  *****************************************************************************/
2218
2219 UpdateStmt:  UPDATE relation_name
2220                           SET res_target_list
2221                           from_clause
2222                           where_clause
2223                                 {
2224                                         UpdateStmt *n = makeNode(UpdateStmt);
2225                                         n->relname = $2;
2226                                         n->targetList = $4;
2227                                         n->fromClause = $5;
2228                                         n->whereClause = $6;
2229                                         $$ = (Node *)n;
2230                                 }
2231                 ;
2232
2233
2234 /*****************************************************************************
2235  *
2236  *              QUERY:
2237  *                              CURSOR STATEMENTS
2238  *
2239  *****************************************************************************/
2240 CursorStmt:  DECLARE name opt_binary CURSOR FOR
2241                          SELECT opt_unique res_target_list2
2242                          from_clause where_clause
2243                          group_clause having_clause
2244                          union_clause sort_clause
2245                                 {
2246                                         SelectStmt *n = makeNode(SelectStmt);
2247
2248                                         /* from PORTAL name */
2249                                         /*
2250                                          *      15 august 1991 -- since 3.0 postgres does locking
2251                                          *      right, we discovered that portals were violating
2252                                          *      locking protocol.  portal locks cannot span xacts.
2253                                          *      as a short-term fix, we installed the check here.
2254                                          *                                                      -- mao
2255                                          */
2256                                         if (!IsTransactionBlock())
2257                                                 elog(ERROR,"Named portals may only be used in begin/end transaction blocks");
2258
2259                                         n->portalname = $2;
2260                                         n->binary = $3;
2261                                         n->unique = $7;
2262                                         n->targetList = $8;
2263                                         n->fromClause = $9;
2264                                         n->whereClause = $10;
2265                                         n->groupClause = $11;
2266                                         n->havingClause = $12;
2267                                         n->unionClause = $13;
2268                                         n->sortClause = $14;
2269                                         $$ = (Node *)n;
2270                                 }
2271                 ;
2272
2273
2274 /*****************************************************************************
2275  *
2276  *              QUERY:
2277  *                              SELECT STATEMENTS
2278  *
2279  *****************************************************************************/
2280
2281 SelectStmt:  SELECT opt_unique res_target_list2
2282                          result from_clause where_clause
2283                          group_clause having_clause
2284                          union_clause sort_clause
2285                                 {
2286                                         SelectStmt *n = makeNode(SelectStmt);
2287                                         n->unique = $2;
2288                                         n->targetList = $3;
2289                                         n->into = $4;
2290                                         n->fromClause = $5;
2291                                         n->whereClause = $6;
2292                                         n->groupClause = $7;
2293                                         n->havingClause = $8;
2294                                         n->unionClause = $9;
2295                                         n->sortClause = $10;
2296                                         $$ = (Node *)n;
2297                                 }
2298                 ;
2299
2300 union_clause:  UNION opt_union select_list
2301                                 {
2302                                         SelectStmt *n = (SelectStmt *)lfirst($3);
2303                                         n->unionall = $2;
2304                                         $$ = $3;
2305                                 }
2306                 | /*EMPTY*/
2307                                 { $$ = NIL; }
2308                 ;
2309
2310 select_list:  select_list UNION opt_union SubSelect
2311                                 {
2312                                         SelectStmt *n = (SelectStmt *)$4;
2313                                         n->unionall = $3;
2314                                         $$ = lappend($1, $4);
2315                                 }
2316                 | SubSelect
2317                                 { $$ = lcons($1, NIL); }
2318                 ;
2319
2320 SubSelect:      SELECT opt_unique res_target_list2
2321                          from_clause where_clause
2322                          group_clause having_clause
2323                                 {
2324                                         SelectStmt *n = makeNode(SelectStmt);
2325                                         n->unique = $2;
2326                                         n->unionall = FALSE;
2327                                         n->targetList = $3;
2328                                         n->fromClause = $4;
2329                                         n->whereClause = $5;
2330                                         n->groupClause = $6;
2331                                         n->havingClause = $7;
2332                                         $$ = (Node *)n;
2333                                 }
2334                 ;
2335
2336 result:  INTO TABLE relation_name
2337                                 {       $$= $3; }
2338                 | /*EMPTY*/
2339                                 {       $$ = NULL; }
2340                 ;
2341
2342 opt_union:  ALL                                                                 { $$ = TRUE; }
2343                 | /*EMPTY*/                                                             { $$ = FALSE; }
2344                 ;
2345
2346 opt_unique:  DISTINCT                                                   { $$ = "*"; }
2347                 | DISTINCT ON ColId                                             { $$ = $3; }
2348                 | ALL                                                                   { $$ = NULL; }
2349                 | /*EMPTY*/                                                             { $$ = NULL; }
2350                 ;
2351
2352 sort_clause:  ORDER BY sortby_list                              { $$ = $3; }
2353                 | /*EMPTY*/                                                             { $$ = NIL; }
2354                 ;
2355
2356 sortby_list:  sortby                                                    { $$ = lcons($1, NIL); }
2357                 | sortby_list ',' sortby                                { $$ = lappend($1, $3); }
2358                 ;
2359
2360 sortby:  ColId OptUseOp
2361                                 {
2362                                         $$ = makeNode(SortGroupBy);
2363                                         $$->resno = 0;
2364                                         $$->range = NULL;
2365                                         $$->name = $1;
2366                                         $$->useOp = $2;
2367                                 }
2368                 | ColId '.' ColId OptUseOp
2369                                 {
2370                                         $$ = makeNode(SortGroupBy);
2371                                         $$->resno = 0;
2372                                         $$->range = $1;
2373                                         $$->name = $3;
2374                                         $$->useOp = $4;
2375                                 }
2376                 | Iconst OptUseOp
2377                                 {
2378                                         $$ = makeNode(SortGroupBy);
2379                                         $$->resno = $1;
2380                                         $$->range = NULL;
2381                                         $$->name = NULL;
2382                                         $$->useOp = $2;
2383                                 }
2384                 ;
2385
2386 OptUseOp:  USING Op                                                             { $$ = $2; }
2387                 | USING '<'                                                             { $$ = "<"; }
2388                 | USING '>'                                                             { $$ = ">"; }
2389                 | ASC                                                                   { $$ = "<"; }
2390                 | DESC                                                                  { $$ = ">"; }
2391                 | /*EMPTY*/                                                             { $$ = "<"; /*default*/ }
2392                 ;
2393
2394 /*
2395  *      jimmy bell-style recursive queries aren't supported in the
2396  *      current system.
2397  *
2398  *      ...however, recursive addattr and rename supported.  make special
2399  *      cases for these.
2400  */
2401 opt_inh_star:  '*'                                                              { $$ = TRUE; }
2402                 | /*EMPTY*/                                                             { $$ = FALSE; }
2403                 ;
2404
2405 relation_name_list:  name_list;
2406
2407 name_list:  name
2408                                 {       $$ = lcons(makeString($1),NIL); }
2409                 | name_list ',' name
2410                                 {       $$ = lappend($1,makeString($3)); }
2411                 ;
2412
2413 group_clause:  GROUP BY groupby_list                    { $$ = $3; }
2414                 | /*EMPTY*/                                                             { $$ = NIL; }
2415                 ;
2416
2417 groupby_list:  groupby                                                  { $$ = lcons($1, NIL); }
2418                 | groupby_list ',' groupby                              { $$ = lappend($1, $3); }
2419                 ;
2420
2421 groupby:  ColId
2422                                 {
2423                                         $$ = makeNode(SortGroupBy);
2424                                         $$->resno = 0;
2425                                         $$->range = NULL;
2426                                         $$->name = $1;
2427                                         $$->useOp = NULL;
2428                                 }
2429                 | ColId '.' ColId
2430                                 {
2431                                         $$ = makeNode(SortGroupBy);
2432                                         $$->resno = 0;
2433                                         $$->range = $1;
2434                                         $$->name = $3;
2435                                         $$->useOp = NULL;
2436                                 }
2437                 | Iconst
2438                                 {
2439                                         $$ = makeNode(SortGroupBy);
2440                                         $$->resno = $1;
2441                                         $$->range = NULL;
2442                                         $$->name = NULL;
2443                                         $$->useOp = NULL;
2444                                 }
2445                 ;
2446
2447 having_clause:  HAVING a_expr                                   { $$ = $2; }
2448                 | /*EMPTY*/                                                             { $$ = NULL; }
2449                 ;
2450
2451
2452 /*****************************************************************************
2453  *
2454  *      clauses common to all Optimizable Stmts:
2455  *              from_clause             -
2456  *              where_clause    -
2457  *
2458  *****************************************************************************/
2459
2460 from_clause:  FROM '(' relation_expr join_expr JOIN relation_expr join_spec ')'
2461                                 {
2462                                         $$ = NIL;
2463                                         elog(ERROR,"JOIN not yet implemented");
2464                                 }
2465                 | FROM from_list                                                { $$ = $2; }
2466                 | /*EMPTY*/                                                             { $$ = NIL; }
2467                 ;
2468
2469 from_list:      from_list ',' from_val
2470                                 { $$ = lappend($1, $3); }
2471                 | from_val CROSS JOIN from_val
2472                                 { elog(ERROR,"CROSS JOIN not yet implemented"); }
2473                 | from_val
2474                                 { $$ = lcons($1, NIL); }
2475                 ;
2476
2477 from_val:  relation_expr AS ColLabel
2478                                 {
2479                                         $$ = makeNode(RangeVar);
2480                                         $$->relExpr = $1;
2481                                         $$->name = $3;
2482                                 }
2483                 | relation_expr ColId
2484                                 {
2485                                         $$ = makeNode(RangeVar);
2486                                         $$->relExpr = $1;
2487                                         $$->name = $2;
2488                                 }
2489                 | relation_expr
2490                                 {
2491                                         $$ = makeNode(RangeVar);
2492                                         $$->relExpr = $1;
2493                                         $$->name = NULL;
2494                                 }
2495                 ;
2496
2497 join_expr:  NATURAL join_expr                                   { $$ = NULL; }
2498                 | FULL join_outer
2499                                 { elog(ERROR,"FULL OUTER JOIN not yet implemented"); }
2500                 | LEFT join_outer
2501                                 { elog(ERROR,"LEFT OUTER JOIN not yet implemented"); }
2502                 | RIGHT join_outer
2503                                 { elog(ERROR,"RIGHT OUTER JOIN not yet implemented"); }
2504                 | OUTER_P
2505                                 { elog(ERROR,"OUTER JOIN not yet implemented"); }
2506                 | INNER_P
2507                                 { elog(ERROR,"INNER JOIN not yet implemented"); }
2508                 | UNION
2509                                 { elog(ERROR,"UNION JOIN not yet implemented"); }
2510                 | /*EMPTY*/
2511                                 { elog(ERROR,"INNER JOIN not yet implemented"); }
2512                 ;
2513
2514 join_outer:  OUTER_P                                                    { $$ = NULL; }
2515                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2516                 ;
2517
2518 join_spec:      ON '(' a_expr ')'                                       { $$ = NULL; }
2519                 | USING '(' join_list ')'                               { $$ = NULL; }
2520                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2521                 ;
2522
2523 join_list:  join_using                                                  { $$ = lcons($1, NIL); }
2524                 | join_list ',' join_using                              { $$ = lappend($1, $3); }
2525                 ;
2526
2527 join_using:  ColId
2528                                 {
2529                                         $$ = makeNode(SortGroupBy);
2530                                         $$->resno = 0;
2531                                         $$->range = NULL;
2532                                         $$->name = $1;
2533                                         $$->useOp = NULL;
2534                                 }
2535                 | ColId '.' ColId
2536                                 {
2537                                         $$ = makeNode(SortGroupBy);
2538                                         $$->resno = 0;
2539                                         $$->range = $1;
2540                                         $$->name = $3;
2541                                         $$->useOp = NULL;
2542                                 }
2543                 | Iconst
2544                                 {
2545                                         $$ = makeNode(SortGroupBy);
2546                                         $$->resno = $1;
2547                                         $$->range = NULL;
2548                                         $$->name = NULL;
2549                                         $$->useOp = NULL;
2550                                 }
2551                 ;
2552
2553 where_clause:  WHERE a_expr                                             { $$ = $2; }
2554                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2555                 ;
2556
2557 relation_expr:  relation_name
2558                                 {
2559                                         /* normal relations */
2560                                         $$ = makeNode(RelExpr);
2561                                         $$->relname = $1;
2562                                         $$->inh = FALSE;
2563                                 }
2564                 | relation_name '*'                               %prec '='
2565                                 {
2566                                         /* inheritance query */
2567                                         $$ = makeNode(RelExpr);
2568                                         $$->relname = $1;
2569                                         $$->inh = TRUE;
2570                                 }
2571
2572 opt_array_bounds:  '[' ']' nest_array_bounds
2573                                 {  $$ = lcons(makeInteger(-1), $3); }
2574                 | '[' Iconst ']' nest_array_bounds
2575                                 {  $$ = lcons(makeInteger($2), $4); }
2576                 | /* EMPTY */
2577                                 {  $$ = NIL; }
2578                 ;
2579
2580 nest_array_bounds:      '[' ']' nest_array_bounds
2581                                 {  $$ = lcons(makeInteger(-1), $3); }
2582                 | '[' Iconst ']' nest_array_bounds
2583                                 {  $$ = lcons(makeInteger($2), $4); }
2584                 | /*EMPTY*/
2585                                 {  $$ = NIL; }
2586                 ;
2587
2588
2589 /*****************************************************************************
2590  *
2591  *      Type syntax
2592  *              SQL92 introduces a large amount of type-specific syntax.
2593  *              Define individual clauses to handle these cases, and use
2594  *               the generic case to handle regular type-extensible Postgres syntax.
2595  *              - thomas 1997-10-10
2596  *
2597  *****************************************************************************/
2598
2599 Typename:  Array opt_array_bounds
2600                                 {
2601                                         $$ = $1;
2602                                         $$->arrayBounds = $2;
2603
2604                                         /* Is this the name of a complex type? If so, implement
2605                                          * it as a set.
2606                                          */
2607                                         if (!strcmp(saved_relname, $$->name))
2608                                                 /* This attr is the same type as the relation
2609                                                  * being defined. The classic example: create
2610                                                  * emp(name=text,mgr=emp)
2611                                                  */
2612                                                 $$->setof = TRUE;
2613                                         else if (typeTypeRelid(typenameType($$->name)) != InvalidOid)
2614                                                  /* (Eventually add in here that the set can only
2615                                                   * contain one element.)
2616                                                   */
2617                                                 $$->setof = TRUE;
2618                                         else
2619                                                 $$->setof = FALSE;
2620                                 }
2621                 | Character
2622                 | SETOF Array
2623                                 {
2624                                         $$ = $2;
2625                                         $$->setof = TRUE;
2626                                 }
2627                 ;
2628
2629 Array:  Generic
2630                 | Datetime
2631                 | Numeric
2632                 ;
2633
2634 Generic:  generic
2635                                 {
2636                                         $$ = makeNode(TypeName);
2637                                         $$->name = xlateSqlType($1);
2638                                 }
2639                 ;
2640
2641 generic:  Id                                                                    { $$ = $1; }
2642                 | TYPE_P                                                                { $$ = xlateSqlType("type"); }
2643                 | DOUBLE PRECISION                                              { $$ = xlateSqlType("float8"); }
2644                 ;
2645
2646 /* SQL92 numeric data types
2647  * Check FLOAT() precision limits assuming IEEE floating types.
2648  * Provide rudimentary DECIMAL() and NUMERIC() implementations
2649  *  by checking parameters and making sure they match what is possible with INTEGER.
2650  * - thomas 1997-09-18
2651  */
2652 Numeric:  FLOAT opt_float
2653                                 {
2654                                         $$ = makeNode(TypeName);
2655                                         $$->name = xlateSqlType($2);
2656                                 }
2657                 | DECIMAL opt_decimal
2658                                 {
2659                                         $$ = makeNode(TypeName);
2660                                         $$->name = xlateSqlType("integer");
2661                                 }
2662                 | NUMERIC opt_numeric
2663                                 {
2664                                         $$ = makeNode(TypeName);
2665                                         $$->name = xlateSqlType("integer");
2666                                 }
2667                 ;
2668
2669 opt_float:  '(' Iconst ')'
2670                                 {
2671                                         if ($2 < 1)
2672                                                 elog(ERROR,"precision for FLOAT must be at least 1");
2673                                         else if ($2 < 7)
2674                                                 $$ = xlateSqlType("float4");
2675                                         else if ($2 < 16)
2676                                                 $$ = xlateSqlType("float8");
2677                                         else
2678                                                 elog(ERROR,"precision for FLOAT must be less than 16");
2679                                 }
2680                 | /*EMPTY*/
2681                                 {
2682                                         $$ = xlateSqlType("float8");
2683                                 }
2684                 ;
2685
2686 opt_numeric:  '(' Iconst ',' Iconst ')'
2687                                 {
2688                                         if ($2 != 9)
2689                                                 elog(ERROR,"NUMERIC precision %d must be 9",$2);
2690                                         if ($4 != 0)
2691                                                 elog(ERROR,"NUMERIC scale %d must be zero",$4);
2692                                 }
2693                 | '(' Iconst ')'
2694                                 {
2695                                         if ($2 != 9)
2696                                                 elog(ERROR,"NUMERIC precision %d must be 9",$2);
2697                                 }
2698                 | /*EMPTY*/
2699                                 {
2700                                         $$ = NULL;
2701                                 }
2702                 ;
2703
2704 opt_decimal:  '(' Iconst ',' Iconst ')'
2705                                 {
2706                                         if ($2 > 9)
2707                                                 elog(ERROR,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2708                                         if ($4 != 0)
2709                                                 elog(ERROR,"DECIMAL scale %d must be zero",$4);
2710                                         $$ = NULL;
2711                                 }
2712                 | '(' Iconst ')'
2713                                 {
2714                                         if ($2 > 9)
2715                                                 elog(ERROR,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2716                                         $$ = NULL;
2717                                 }
2718                 | /*EMPTY*/
2719                                 {
2720                                         $$ = NULL;
2721                                 }
2722                 ;
2723
2724 /* SQL92 character data types
2725  * The following implements CHAR() and VARCHAR().
2726  * We do it here instead of the 'Generic' production
2727  * because we don't want to allow arrays of VARCHAR().
2728  * I haven't thought about whether that will work or not.
2729  *                                                              - ay 6/95
2730  */
2731 Character:  character '(' Iconst ')'
2732                                 {
2733                                         $$ = makeNode(TypeName);
2734                                         if (!strcasecmp($1, "char"))
2735                                                 $$->name = xlateSqlType("bpchar");
2736                                         else if (!strcasecmp($1, "varchar"))
2737                                                 $$->name = xlateSqlType("varchar");
2738                                         else
2739                                                 yyerror("parse error");
2740                                         if ($3 < 1)
2741                                                 elog(ERROR,"length for '%s' type must be at least 1",$1);
2742                                         else if ($3 > 4096)
2743                                                 /* we can store a char() of length up to the size
2744                                                  * of a page (8KB) - page headers and friends but
2745                                                  * just to be safe here...      - ay 6/95
2746                                                  * XXX note this hardcoded limit - thomas 1997-07-13
2747                                                  */
2748                                                 elog(ERROR,"length for type '%s' cannot exceed 4096",$1);
2749
2750                                         /* we actually implement this sort of like a varlen, so
2751                                          * the first 4 bytes is the length. (the difference
2752                                          * between this and "text" is that we blank-pad and
2753                                          * truncate where necessary
2754                                          */
2755                                         $$->typlen = VARHDRSZ + $3;
2756                                 }
2757                 | character
2758                                 {
2759                                         $$ = makeNode(TypeName);
2760                                         $$->name = xlateSqlType($1);
2761                                 }
2762                 ;
2763
2764 character:  CHARACTER opt_varying opt_charset opt_collate
2765                                 {
2766                                         char *type, *c;
2767                                         if (($3 == NULL) || (strcasecmp($3, "sql_text") == 0)) {
2768                                                 if ($2) type = xlateSqlType("varchar");
2769                                                 else type = xlateSqlType("char");
2770                                         } else {
2771                                                 if ($2) {
2772                                                         c = palloc(strlen("var") + strlen($3) + 1);
2773                                                         strcpy(c, "var");
2774                                                         strcat(c, $3);
2775                                                         type = xlateSqlType(c);
2776                                                 } else {
2777                                                         type = xlateSqlType($3);
2778                                                 }
2779                                         };
2780                                         if ($4 != NULL)
2781                                         elog(ERROR,"COLLATE %s not yet implemented",$4);
2782                                         $$ = type;
2783                                 }
2784                 | CHAR opt_varying                                              { $$ = xlateSqlType($2? "varchar": "char"); }
2785                 | VARCHAR                                                               { $$ = xlateSqlType("varchar"); }
2786                 | NATIONAL CHARACTER opt_varying                { $$ = xlateSqlType($3? "varchar": "char"); }
2787                 | NCHAR opt_varying                                             { $$ = xlateSqlType($2? "varchar": "char"); }
2788                 ;
2789
2790 opt_varying:  VARYING                                                   { $$ = TRUE; }
2791                 | /*EMPTY*/                                                             { $$ = FALSE; }
2792                 ;
2793
2794 opt_charset:  CHARACTER SET ColId                               { $$ = $3; }
2795                 | /*EMPTY*/                                                             { $$ = NULL; }
2796                 ;
2797
2798 opt_collate:  COLLATE ColId                                             { $$ = $2; }
2799                 | /*EMPTY*/                                                             { $$ = NULL; }
2800                 ;
2801
2802 Datetime:  datetime
2803                                 {
2804                                         $$ = makeNode(TypeName);
2805                                         $$->name = xlateSqlType($1);
2806                                 }
2807                 | TIMESTAMP opt_timezone
2808                                 {
2809                                         $$ = makeNode(TypeName);
2810                                         $$->name = xlateSqlType("timestamp");
2811                                         $$->timezone = $2;
2812                                 }
2813                 | TIME
2814                                 {
2815                                         $$ = makeNode(TypeName);
2816                                         $$->name = xlateSqlType("time");
2817                                 }
2818                 | INTERVAL opt_interval
2819                                 {
2820                                         $$ = makeNode(TypeName);
2821                                         $$->name = xlateSqlType("interval");
2822                                 }
2823                 ;
2824
2825 datetime:  YEAR_P                                                               { $$ = "year"; }
2826                 | MONTH_P                                                               { $$ = "month"; }
2827                 | DAY_P                                                                 { $$ = "day"; }
2828                 | HOUR_P                                                                { $$ = "hour"; }
2829                 | MINUTE_P                                                              { $$ = "minute"; }
2830                 | SECOND_P                                                              { $$ = "second"; }
2831                 ;
2832
2833 opt_timezone:  WITH TIME ZONE                                   { $$ = TRUE; }
2834                 | /*EMPTY*/                                                             { $$ = FALSE; }
2835                 ;
2836
2837 opt_interval:  datetime                                                 { $$ = lcons($1, NIL); }
2838                 | YEAR_P TO MONTH_P                                             { $$ = NIL; }
2839                 | DAY_P TO HOUR_P                                               { $$ = NIL; }
2840                 | DAY_P TO MINUTE_P                                             { $$ = NIL; }
2841                 | DAY_P TO SECOND_P                                             { $$ = NIL; }
2842                 | HOUR_P TO MINUTE_P                                    { $$ = NIL; }
2843                 | HOUR_P TO SECOND_P                                    { $$ = NIL; }
2844                 | /*EMPTY*/                                                             { $$ = NIL; }
2845                 ;
2846
2847
2848 /*****************************************************************************
2849  *
2850  *      expression grammar, still needs some cleanup
2851  *
2852  *****************************************************************************/
2853
2854 a_expr_or_null:  a_expr
2855                                 { $$ = $1; }
2856                 | NULL_P
2857                                 {
2858                                         A_Const *n = makeNode(A_Const);
2859                                         n->val.type = T_Null;
2860                                         $$ = (Node *)n;
2861                                 }
2862                 ;
2863
2864 /* Expressions using row descriptors
2865  * Define row_descriptor to allow yacc to break the reduce/reduce conflict
2866  *  with singleton expressions.
2867  */
2868 row_expr: '(' row_descriptor ')' IN '(' SubSelect ')'
2869                                 {
2870                                         $$ = NULL;
2871                                 }
2872                 | '(' row_descriptor ')' NOT IN '(' SubSelect ')'
2873                                 {
2874                                         $$ = NULL;
2875                                 }
2876                 | '(' row_descriptor ')' '=' '(' row_descriptor ')'
2877                                 {
2878                                         $$ = makeRowExpr("=", $2, $6);
2879                                 }
2880                 | '(' row_descriptor ')' '<' '(' row_descriptor ')'
2881                                 {
2882                                         $$ = makeRowExpr("<", $2, $6);
2883                                 }
2884                 | '(' row_descriptor ')' '>' '(' row_descriptor ')'
2885                                 {
2886                                         $$ = makeRowExpr("<", $2, $6);
2887                                 }
2888                 | '(' row_descriptor ')' Op '(' row_descriptor ')'
2889                                 {
2890                                         $$ = makeRowExpr($4, $2, $6);
2891                                 }
2892                 ;
2893
2894 row_descriptor:  row_list ',' a_expr
2895                                 {
2896                                         $$ = lappend($1, $3);
2897                                 }
2898                 ;
2899
2900 row_list:  row_list ',' a_expr
2901                                 {
2902                                         $$ = lappend($1, $3);
2903                                 }
2904                 | a_expr
2905                                 {
2906                                         $$ = lcons($1, NIL);
2907                                 }
2908                 ;
2909
2910 a_expr:  attr opt_indirection
2911                                 {
2912                                         $1->indirection = $2;
2913                                         $$ = (Node *)$1;
2914                                 }
2915                 | row_expr
2916                                 {       $$ = $1;  }
2917                 | AexprConst
2918                                 {       $$ = $1;  }
2919                 | '-' a_expr %prec UMINUS
2920                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
2921                 | a_expr '+' a_expr
2922                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
2923                 | a_expr '-' a_expr
2924                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
2925                 | a_expr '/' a_expr
2926                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
2927                 | a_expr '*' a_expr
2928                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
2929                 | a_expr '<' a_expr
2930                                 {       $$ = makeA_Expr(OP, "<", $1, $3); }
2931                 | a_expr '>' a_expr
2932                                 {       $$ = makeA_Expr(OP, ">", $1, $3); }
2933                 | a_expr '=' a_expr
2934                                 {       $$ = makeA_Expr(OP, "=", $1, $3); }
2935                 | ':' a_expr
2936                                 {       $$ = makeA_Expr(OP, ":", NULL, $2); }
2937                 | ';' a_expr
2938                                 {       $$ = makeA_Expr(OP, ";", NULL, $2); }
2939                 | '|' a_expr
2940                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
2941                 | a_expr TYPECAST Typename
2942                                 {
2943                                         $$ = (Node *)$1;
2944                                         /* AexprConst can be either A_Const or ParamNo */
2945                                         if (nodeTag($1) == T_A_Const) {
2946                                                 ((A_Const *)$1)->typename = $3;
2947                                         } else if (nodeTag($1) == T_Param) {
2948                                                 ((ParamNo *)$1)->typename = $3;
2949                                         /* otherwise, try to transform to a function call */
2950                                         } else {
2951                                                 FuncCall *n = makeNode(FuncCall);
2952                                                 n->funcname = $3->name;
2953                                                 n->args = lcons($1,NIL);
2954                                                 $$ = (Node *)n;
2955                                         }
2956                                 }
2957                 | CAST a_expr AS Typename
2958                                 {
2959                                         $$ = (Node *)$2;
2960                                         /* AexprConst can be either A_Const or ParamNo */
2961                                         if (nodeTag($2) == T_A_Const) {
2962                                                 ((A_Const *)$2)->typename = $4;
2963                                         } else if (nodeTag($2) == T_Param) {
2964                                                 ((ParamNo *)$2)->typename = $4;
2965                                         /* otherwise, try to transform to a function call */
2966                                         } else {
2967                                                 FuncCall *n = makeNode(FuncCall);
2968                                                 n->funcname = $4->name;
2969                                                 n->args = lcons($2,NIL);
2970                                                 $$ = (Node *)n;
2971                                         }
2972                                 }
2973                 | '(' a_expr_or_null ')'
2974                                 {       $$ = $2; }
2975                 | a_expr Op a_expr
2976                                 {       $$ = makeIndexable($2,$1,$3);   }
2977                 | a_expr LIKE a_expr
2978                                 {       $$ = makeIndexable("~~", $1, $3); }
2979                 | a_expr NOT LIKE a_expr
2980                                 {       $$ = makeA_Expr(OP, "!~~", $1, $4); }
2981                 | Op a_expr
2982                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
2983                 | a_expr Op
2984                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
2985                 | ColId
2986                                 {
2987                                         /* could be a column name or a relation_name */
2988                                         Ident *n = makeNode(Ident);
2989                                         n->name = $1;
2990                                         n->indirection = NULL;
2991                                         $$ = (Node *)n;
2992                                 }
2993                 | name '(' '*' ')'
2994                                 {
2995                                         /* cheap hack for aggregate (eg. count) */
2996                                         FuncCall *n = makeNode(FuncCall);
2997                                         A_Const *star = makeNode(A_Const);
2998
2999                                         star->val.type = T_String;
3000                                         star->val.val.str = "";
3001                                         n->funcname = $1;
3002                                         n->args = lcons(star, NIL);
3003                                         $$ = (Node *)n;
3004                                 }
3005                 | name '(' ')'
3006                                 {
3007                                         FuncCall *n = makeNode(FuncCall);
3008                                         n->funcname = $1;
3009                                         n->args = NIL;
3010                                         $$ = (Node *)n;
3011                                 }
3012                 | name '(' expr_list ')'
3013                                 {
3014                                         FuncCall *n = makeNode(FuncCall);
3015                                         n->funcname = $1;
3016                                         n->args = $3;
3017                                         $$ = (Node *)n;
3018                                 }
3019                 | CURRENT_DATE
3020                                 {
3021                                         A_Const *n = makeNode(A_Const);
3022                                         TypeName *t = makeNode(TypeName);
3023
3024                                         n->val.type = T_String;
3025                                         n->val.val.str = "now";
3026                                         n->typename = t;
3027
3028                                         t->name = xlateSqlType("date");
3029                                         t->setof = FALSE;
3030
3031                                         $$ = (Node *)n;
3032                                 }
3033                 | CURRENT_TIME
3034                                 {
3035                                         A_Const *n = makeNode(A_Const);
3036                                         TypeName *t = makeNode(TypeName);
3037
3038                                         n->val.type = T_String;
3039                                         n->val.val.str = "now";
3040                                         n->typename = t;
3041
3042                                         t->name = xlateSqlType("time");
3043                                         t->setof = FALSE;
3044
3045                                         $$ = (Node *)n;
3046                                 }
3047                 | CURRENT_TIME '(' Iconst ')'
3048                                 {
3049                                         FuncCall *n = makeNode(FuncCall);
3050                                         A_Const *s = makeNode(A_Const);
3051                                         TypeName *t = makeNode(TypeName);
3052
3053                                         n->funcname = xlateSqlType("time");
3054                                         n->args = lcons(s, NIL);
3055
3056                                         s->val.type = T_String;
3057                                         s->val.val.str = "now";
3058                                         s->typename = t;
3059
3060                                         t->name = xlateSqlType("time");
3061                                         t->setof = FALSE;
3062
3063                                         if ($3 != 0)
3064                                                 elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
3065
3066                                         $$ = (Node *)n;
3067                                 }
3068                 | CURRENT_TIMESTAMP
3069                                 {
3070                                         A_Const *n = makeNode(A_Const);
3071                                         TypeName *t = makeNode(TypeName);
3072
3073                                         n->val.type = T_String;
3074                                         n->val.val.str = "now";
3075                                         n->typename = t;
3076
3077                                         t->name = xlateSqlType("timestamp");
3078                                         t->setof = FALSE;
3079
3080                                         $$ = (Node *)n;
3081                                 }
3082                 | CURRENT_TIMESTAMP '(' Iconst ')'
3083                                 {
3084                                         FuncCall *n = makeNode(FuncCall);
3085                                         A_Const *s = makeNode(A_Const);
3086                                         TypeName *t = makeNode(TypeName);
3087
3088                                         n->funcname = xlateSqlType("timestamp");
3089                                         n->args = lcons(s, NIL);
3090
3091                                         s->val.type = T_String;
3092                                         s->val.val.str = "now";
3093                                         s->typename = t;
3094
3095                                         t->name = xlateSqlType("timestamp");
3096                                         t->setof = FALSE;
3097
3098                                         if ($3 != 0)
3099                                                 elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
3100
3101                                         $$ = (Node *)n;
3102                                 }
3103                 | CURRENT_USER
3104                                 {
3105                                         FuncCall *n = makeNode(FuncCall);
3106                                         n->funcname = "getpgusername";
3107                                         n->args = NIL;
3108                                         $$ = (Node *)n;
3109                                 }
3110                 /* We probably need to define an "exists" node,
3111                  *      since the optimizer could choose to find only one match.
3112                  * Perhaps the first implementation could just check for
3113                  *      count(*) > 0? - thomas 1997-07-19
3114                  */
3115                 | EXISTS '(' SubSelect ')'
3116                                 {
3117                                         elog(ERROR,"EXISTS not yet implemented");
3118                                         $$ = $3;
3119                                 }
3120                 | EXTRACT '(' extract_list ')'
3121                                 {
3122                                         FuncCall *n = makeNode(FuncCall);
3123                                         n->funcname = "date_part";
3124                                         n->args = $3;
3125                                         $$ = (Node *)n;
3126                                 }
3127                 | POSITION '(' position_list ')'
3128                                 {
3129                                         FuncCall *n = makeNode(FuncCall);
3130                                         n->funcname = "strpos";
3131                                         n->args = $3;
3132                                         $$ = (Node *)n;
3133                                 }
3134                 | SUBSTRING '(' substr_list ')'
3135                                 {
3136                                         FuncCall *n = makeNode(FuncCall);
3137                                         n->funcname = "substr";
3138                                         n->args = $3;
3139                                         $$ = (Node *)n;
3140                                 }
3141                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3142                 | TRIM '(' BOTH trim_list ')'
3143                                 {
3144                                         FuncCall *n = makeNode(FuncCall);
3145                                         n->funcname = "btrim";
3146                                         n->args = $4;
3147                                         $$ = (Node *)n;
3148                                 }
3149                 | TRIM '(' LEADING trim_list ')'
3150                                 {
3151                                         FuncCall *n = makeNode(FuncCall);
3152                                         n->funcname = "ltrim";
3153                                         n->args = $4;
3154                                         $$ = (Node *)n;
3155                                 }
3156                 | TRIM '(' TRAILING trim_list ')'
3157                                 {
3158                                         FuncCall *n = makeNode(FuncCall);
3159                                         n->funcname = "rtrim";
3160                                         n->args = $4;
3161                                         $$ = (Node *)n;
3162                                 }
3163                 | TRIM '(' trim_list ')'
3164                                 {
3165                                         FuncCall *n = makeNode(FuncCall);
3166                                         n->funcname = "btrim";
3167                                         n->args = $3;
3168                                         $$ = (Node *)n;
3169                                 }
3170                 | a_expr ISNULL
3171                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3172                 | a_expr IS NULL_P
3173                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3174                 | a_expr NOTNULL
3175                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3176                 | a_expr IS NOT NULL_P
3177                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3178                 /* IS TRUE, IS FALSE, etc used to be function calls
3179                  *  but let's make them expressions to allow the optimizer
3180                  *  a chance to eliminate them if a_expr is a constant string.
3181                  * - thomas 1997-12-22
3182                  */
3183                 | a_expr IS TRUE_P
3184                                 {
3185                                         A_Const *n = makeNode(A_Const);
3186                                         n->val.type = T_String;
3187                                         n->val.val.str = "t";
3188                                         n->typename = makeNode(TypeName);
3189                                         n->typename->name = xlateSqlType("bool");
3190                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3191                                 }
3192                 | a_expr IS NOT FALSE_P
3193                                 {
3194                                         A_Const *n = makeNode(A_Const);
3195                                         n->val.type = T_String;
3196                                         n->val.val.str = "t";
3197                                         n->typename = makeNode(TypeName);
3198                                         n->typename->name = xlateSqlType("bool");
3199                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3200                                 }
3201                 | a_expr IS FALSE_P
3202                                 {
3203                                         A_Const *n = makeNode(A_Const);
3204                                         n->val.type = T_String;
3205                                         n->val.val.str = "f";
3206                                         n->typename = makeNode(TypeName);
3207                                         n->typename->name = xlateSqlType("bool");
3208                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3209                                 }
3210                 | a_expr IS NOT TRUE_P
3211                                 {
3212                                         A_Const *n = makeNode(A_Const);
3213                                         n->val.type = T_String;
3214                                         n->val.val.str = "f";
3215                                         n->typename = makeNode(TypeName);
3216                                         n->typename->name = xlateSqlType("bool");
3217                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3218                                 }
3219                 | a_expr BETWEEN AexprConst AND AexprConst
3220                                 {
3221                                         $$ = makeA_Expr(AND, NULL,
3222                                                 makeA_Expr(OP, ">=", $1, $3),
3223                                                 makeA_Expr(OP, "<=", $1, $5));
3224                                 }
3225                 | a_expr NOT BETWEEN AexprConst AND AexprConst
3226                                 {
3227                                         $$ = makeA_Expr(OR, NULL,
3228                                                 makeA_Expr(OP, "<", $1, $4),
3229                                                 makeA_Expr(OP, ">", $1, $6));
3230                                 }
3231                 | a_expr IN { saved_In_Expr = $1; } '(' in_expr ')'
3232                                 {       $$ = $5; }
3233                 | a_expr NOT IN { saved_In_Expr = $1; } '(' not_in_expr ')'
3234                                 {       $$ = $6; }
3235                 | a_expr AND a_expr
3236                                 {       $$ = makeA_Expr(AND, NULL, $1, $3); }
3237                 | a_expr OR a_expr
3238                                 {       $$ = makeA_Expr(OR, NULL, $1, $3); }
3239                 | NOT a_expr
3240                                 {       $$ = makeA_Expr(NOT, NULL, NULL, $2); }
3241                 ;
3242
3243 opt_indirection:  '[' a_expr ']' opt_indirection
3244                                 {
3245                                         A_Indices *ai = makeNode(A_Indices);
3246                                         ai->lidx = NULL;
3247                                         ai->uidx = $2;
3248                                         $$ = lcons(ai, $4);
3249                                 }
3250                 | '[' a_expr ':' a_expr ']' opt_indirection
3251                                 {
3252                                         A_Indices *ai = makeNode(A_Indices);
3253                                         ai->lidx = $2;
3254                                         ai->uidx = $4;
3255                                         $$ = lcons(ai, $6);
3256                                 }
3257                 | /* EMPTY */
3258                                 {       $$ = NIL; }
3259                 ;
3260
3261 expr_list:  a_expr_or_null
3262                                 { $$ = lcons($1, NIL); }
3263                 | expr_list ',' a_expr_or_null
3264                                 { $$ = lappend($1, $3); }
3265                 | expr_list USING a_expr
3266                                 { $$ = lappend($1, $3); }
3267                 ;
3268
3269 extract_list:  datetime FROM a_expr
3270                                 {
3271                                         A_Const *n = makeNode(A_Const);
3272                                         n->val.type = T_String;
3273                                         n->val.val.str = $1;
3274                                         $$ = lappend(lcons((Node *)n,NIL), $3);
3275                                 }
3276                 | /* EMPTY */
3277                                 {       $$ = NIL; }
3278                 ;
3279
3280 position_list:  position_expr IN position_expr
3281                                 {       $$ = makeList($3, $1, -1); }
3282                 | /* EMPTY */
3283                                 {       $$ = NIL; }
3284                 ;
3285
3286 position_expr:  attr opt_indirection
3287                                 {
3288                                         $1->indirection = $2;
3289                                         $$ = (Node *)$1;
3290                                 }
3291                 | AexprConst
3292                                 {       $$ = $1;  }
3293                 | '-' position_expr %prec UMINUS
3294                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
3295                 | position_expr '+' position_expr
3296                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
3297                 | position_expr '-' position_expr
3298                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
3299                 | position_expr '/' position_expr
3300                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
3301                 | position_expr '*' position_expr
3302                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
3303                 | '|' position_expr
3304                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
3305                 | position_expr TYPECAST Typename
3306                                 {
3307                                         $$ = (Node *)$1;
3308                                         /* AexprConst can be either A_Const or ParamNo */
3309                                         if (nodeTag($1) == T_A_Const) {
3310                                                 ((A_Const *)$1)->typename = $3;
3311                                         } else if (nodeTag($1) == T_Param) {
3312                                                 ((ParamNo *)$1)->typename = $3;
3313                                         /* otherwise, try to transform to a function call */
3314                                         } else {
3315                                                 FuncCall *n = makeNode(FuncCall);
3316                                                 n->funcname = $3->name;
3317                                                 n->args = lcons($1,NIL);
3318                                                 $$ = (Node *)n;
3319                                         }
3320                                 }
3321                 | CAST position_expr AS Typename
3322                                 {
3323                                         $$ = (Node *)$2;
3324                                         /* AexprConst can be either A_Const or ParamNo */
3325                                         if (nodeTag($2) == T_A_Const) {
3326                                                 ((A_Const *)$2)->typename = $4;
3327                                         } else if (nodeTag($2) == T_Param) {
3328                                                 ((ParamNo *)$2)->typename = $4;
3329                                         /* otherwise, try to transform to a function call */
3330                                         } else {
3331                                                 FuncCall *n = makeNode(FuncCall);
3332                                                 n->funcname = $4->name;
3333                                                 n->args = lcons($2,NIL);
3334                                                 $$ = (Node *)n;
3335                                         }
3336                                 }
3337                 | '(' position_expr ')'
3338                                 {       $$ = $2; }
3339                 | position_expr Op position_expr
3340                                 {       $$ = makeA_Expr(OP, $2, $1, $3); }
3341                 | Op position_expr
3342                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
3343                 | position_expr Op
3344                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
3345                 | ColId
3346                                 {
3347                                         /* could be a column name or a relation_name */
3348                                         Ident *n = makeNode(Ident);
3349                                         n->name = $1;
3350                                         n->indirection = NULL;
3351                                         $$ = (Node *)n;
3352                                 }
3353                 | name '(' ')'
3354                                 {
3355                                         FuncCall *n = makeNode(FuncCall);
3356                                         n->funcname = $1;
3357                                         n->args = NIL;
3358                                         $$ = (Node *)n;
3359                                 }
3360                 | name '(' expr_list ')'
3361                                 {
3362                                         FuncCall *n = makeNode(FuncCall);
3363                                         n->funcname = $1;
3364                                         n->args = $3;
3365                                         $$ = (Node *)n;
3366                                 }
3367                 | POSITION '(' position_list ')'
3368                                 {
3369                                         FuncCall *n = makeNode(FuncCall);
3370                                         n->funcname = "strpos";
3371                                         n->args = $3;
3372                                         $$ = (Node *)n;
3373                                 }
3374                 | SUBSTRING '(' substr_list ')'
3375                                 {
3376                                         FuncCall *n = makeNode(FuncCall);
3377                                         n->funcname = "substr";
3378                                         n->args = $3;
3379                                         $$ = (Node *)n;
3380                                 }
3381                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3382                 | TRIM '(' BOTH trim_list ')'
3383                                 {
3384                                         FuncCall *n = makeNode(FuncCall);
3385                                         n->funcname = "btrim";
3386                                         n->args = $4;
3387                                         $$ = (Node *)n;
3388                                 }
3389                 | TRIM '(' LEADING trim_list ')'
3390                                 {
3391                                         FuncCall *n = makeNode(FuncCall);
3392                                         n->funcname = "ltrim";
3393                                         n->args = $4;
3394                                         $$ = (Node *)n;
3395                                 }
3396                 | TRIM '(' TRAILING trim_list ')'
3397                                 {
3398                                         FuncCall *n = makeNode(FuncCall);
3399                                         n->funcname = "rtrim";
3400                                         n->args = $4;
3401                                         $$ = (Node *)n;
3402                                 }
3403                 | TRIM '(' trim_list ')'
3404                                 {
3405                                         FuncCall *n = makeNode(FuncCall);
3406                                         n->funcname = "btrim";
3407                                         n->args = $3;
3408                                         $$ = (Node *)n;
3409                                 }
3410                 ;
3411
3412 substr_list:  expr_list substr_from substr_for
3413                                 {
3414                                         $$ = nconc(nconc($1,$2),$3);
3415                                 }
3416                 | /* EMPTY */
3417                                 {       $$ = NIL; }
3418                 ;
3419
3420 substr_from:  FROM expr_list
3421                                 {       $$ = $2; }
3422                 | /* EMPTY */
3423                                 {
3424                                         A_Const *n = makeNode(A_Const);
3425                                         n->val.type = T_Integer;
3426                                         n->val.val.ival = 1;
3427                                         $$ = lcons((Node *)n,NIL);
3428                                 }
3429                 ;
3430
3431 substr_for:  FOR expr_list
3432                                 {       $$ = $2; }
3433                 | /* EMPTY */
3434                                 {       $$ = NIL; }
3435                 ;
3436
3437 trim_list:  a_expr FROM expr_list
3438                                 { $$ = lappend($3, $1); }
3439                 | FROM expr_list
3440                                 { $$ = $2; }
3441                 | expr_list
3442                                 { $$ = $1; }
3443                 ;
3444
3445 in_expr:  SubSelect
3446                                 {
3447                                         elog(ERROR,"IN (SUBSELECT) not yet implemented");
3448                                         $$ = $1;
3449                                 }
3450                 | in_expr_nodes
3451                                 {       $$ = $1; }
3452                 ;
3453
3454 in_expr_nodes:  AexprConst
3455                                 {       $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
3456                 | in_expr_nodes ',' AexprConst
3457                                 {       $$ = makeA_Expr(OR, NULL, $1,
3458                                                 makeA_Expr(OP, "=", saved_In_Expr, $3));
3459                                 }
3460                 ;
3461
3462 not_in_expr:  SubSelect
3463                                 {
3464                                         elog(ERROR,"NOT IN (SUBSELECT) not yet implemented");
3465                                         $$ = $1;
3466                                 }
3467                 | not_in_expr_nodes
3468                                 {       $$ = $1; }
3469                 ;
3470
3471 not_in_expr_nodes:  AexprConst
3472                                 {       $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
3473                 | not_in_expr_nodes ',' AexprConst
3474                                 {       $$ = makeA_Expr(AND, NULL, $1,
3475                                                 makeA_Expr(OP, "<>", saved_In_Expr, $3));
3476                                 }
3477                 ;
3478
3479 attr:  relation_name '.' attrs
3480                                 {
3481                                         $$ = makeNode(Attr);
3482                                         $$->relname = $1;
3483                                         $$->paramNo = NULL;
3484                                         $$->attrs = $3;
3485                                         $$->indirection = NULL;
3486                                 }
3487                 | ParamNo '.' attrs
3488                                 {
3489                                         $$ = makeNode(Attr);
3490                                         $$->relname = NULL;
3491                                         $$->paramNo = $1;
3492                                         $$->attrs = $3;
3493                                         $$->indirection = NULL;
3494                                 }
3495                 ;
3496
3497 attrs:    attr_name
3498                                 { $$ = lcons(makeString($1), NIL); }
3499                 | attrs '.' attr_name
3500                                 { $$ = lappend($1, makeString($3)); }
3501                 | attrs '.' '*'
3502                                 { $$ = lappend($1, makeString("*")); }
3503                 ;
3504
3505
3506 /*****************************************************************************
3507  *
3508  *      target lists
3509  *
3510  *****************************************************************************/
3511
3512 res_target_list:  res_target_list ',' res_target_el
3513                                 {       $$ = lappend($1,$3);  }
3514                 | res_target_el
3515                                 {       $$ = lcons($1, NIL);  }
3516                 | '*'
3517                                 {
3518                                         ResTarget *rt = makeNode(ResTarget);
3519                                         Attr *att = makeNode(Attr);
3520                                         att->relname = "*";
3521                                         att->paramNo = NULL;
3522                                         att->attrs = NULL;
3523                                         att->indirection = NIL;
3524                                         rt->name = NULL;
3525                                         rt->indirection = NULL;
3526                                         rt->val = (Node *)att;
3527                                         $$ = lcons(rt, NIL);
3528                                 }
3529                 ;
3530
3531 res_target_el:  ColId opt_indirection '=' a_expr_or_null
3532                                 {
3533                                         $$ = makeNode(ResTarget);
3534                                         $$->name = $1;
3535                                         $$->indirection = $2;
3536                                         $$->val = (Node *)$4;
3537                                 }
3538                 | attr opt_indirection
3539                                 {
3540                                         $$ = makeNode(ResTarget);
3541                                         $$->name = NULL;
3542                                         $$->indirection = $2;
3543                                         $$->val = (Node *)$1;
3544                                 }
3545                 | relation_name '.' '*'
3546                                 {
3547                                         Attr *att = makeNode(Attr);
3548                                         att->relname = $1;
3549                                         att->paramNo = NULL;
3550                                         att->attrs = lcons(makeString("*"), NIL);
3551                                         att->indirection = NIL;
3552                                         $$ = makeNode(ResTarget);
3553                                         $$->name = NULL;
3554                                         $$->indirection = NULL;
3555                                         $$->val = (Node *)att;
3556                                 }
3557                 ;
3558
3559 /*
3560 ** target list for select.
3561 ** should get rid of the other but is still needed by the defunct retrieve into
3562 ** and update (uses a subset)
3563 */
3564 res_target_list2:  res_target_list2 ',' res_target_el2
3565                                 {       $$ = lappend($1, $3);  }
3566                 | res_target_el2
3567                                 {       $$ = lcons($1, NIL);  }
3568                 ;
3569
3570 /* AS is not optional because shift/red conflict with unary ops */
3571 res_target_el2:  a_expr_or_null AS ColLabel
3572                                 {
3573                                         $$ = makeNode(ResTarget);
3574                                         $$->name = $3;
3575                                         $$->indirection = NULL;
3576                                         $$->val = (Node *)$1;
3577                                 }
3578                 | a_expr_or_null
3579                                 {
3580                                         $$ = makeNode(ResTarget);
3581                                         $$->name = NULL;
3582                                         $$->indirection = NULL;
3583                                         $$->val = (Node *)$1;
3584                                 }
3585                 | relation_name '.' '*'
3586                                 {
3587                                         Attr *att = makeNode(Attr);
3588                                         att->relname = $1;
3589                                         att->paramNo = NULL;
3590                                         att->attrs = lcons(makeString("*"), NIL);
3591                                         att->indirection = NIL;
3592                                         $$ = makeNode(ResTarget);
3593                                         $$->name = NULL;
3594                                         $$->indirection = NULL;
3595                                         $$->val = (Node *)att;
3596                                 }
3597                 | '*'
3598                                 {
3599                                         Attr *att = makeNode(Attr);
3600                                         att->relname = "*";
3601                                         att->paramNo = NULL;
3602                                         att->attrs = NULL;
3603                                         att->indirection = NIL;
3604                                         $$ = makeNode(ResTarget);
3605                                         $$->name = NULL;
3606                                         $$->indirection = NULL;
3607                                         $$->val = (Node *)att;
3608                                 }
3609                 ;
3610
3611 opt_id:  ColId                                                                  { $$ = $1; }
3612                 | /* EMPTY */                                                   { $$ = NULL; }
3613                 ;
3614
3615 relation_name:  SpecialRuleRelation
3616                                 {
3617                                         $$ = $1;
3618                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3619                                 }
3620                 | ColId
3621                                 {
3622                                         /* disallow refs to variable system tables */
3623                                         if (strcmp(LogRelationName, $1) == 0
3624                                            || strcmp(VariableRelationName, $1) == 0)
3625                                                 elog(ERROR,"%s cannot be accessed by users",$1);
3626                                         else
3627                                                 $$ = $1;
3628                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3629                                 }
3630                 ;
3631
3632 database_name:                  ColId                   { $$ = $1; };
3633 access_method:                  Id                              { $$ = $1; };
3634 attr_name:                              ColId                   { $$ = $1; };
3635 class:                                  Id                              { $$ = $1; };
3636 index_name:                             ColId                   { $$ = $1; };
3637
3638 /* Functions
3639  * Include date/time keywords as SQL92 extension.
3640  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3641  */
3642 name:                                   ColId                   { $$ = $1; };
3643
3644 file_name:                              Sconst                  { $$ = $1; };
3645 recipe_name:                    Id                              { $$ = $1; };
3646
3647 /* Constants
3648  * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
3649  */
3650 AexprConst:  Iconst
3651                                 {
3652                                         A_Const *n = makeNode(A_Const);
3653                                         n->val.type = T_Integer;
3654                                         n->val.val.ival = $1;
3655                                         $$ = (Node *)n;
3656                                 }
3657                 | FCONST
3658                                 {
3659                                         A_Const *n = makeNode(A_Const);
3660                                         n->val.type = T_Float;
3661                                         n->val.val.dval = $1;
3662                                         $$ = (Node *)n;
3663                                 }
3664                 | Sconst
3665                                 {
3666                                         A_Const *n = makeNode(A_Const);
3667                                         n->val.type = T_String;
3668                                         n->val.val.str = $1;
3669                                         $$ = (Node *)n;
3670                                 }
3671                 | Typename Sconst
3672                                 {
3673                                         A_Const *n = makeNode(A_Const);
3674                                         n->typename = $1;
3675                                         n->val.type = T_String;
3676                                         n->val.val.str = $2;
3677                                         $$ = (Node *)n;
3678                                 }
3679                 | ParamNo
3680                                 {       $$ = (Node *)$1;  }
3681                 | TRUE_P
3682                                 {
3683                                         A_Const *n = makeNode(A_Const);
3684                                         n->val.type = T_String;
3685                                         n->val.val.str = "t";
3686                                         n->typename = makeNode(TypeName);
3687                                         n->typename->name = xlateSqlType("bool");
3688                                         $$ = (Node *)n;
3689                                 }
3690                 | FALSE_P
3691                                 {
3692                                         A_Const *n = makeNode(A_Const);
3693                                         n->val.type = T_String;
3694                                         n->val.val.str = "f";
3695                                         n->typename = makeNode(TypeName);
3696                                         n->typename->name = xlateSqlType("bool");
3697                                         $$ = (Node *)n;
3698                                 }
3699                 ;
3700
3701 ParamNo:  PARAM
3702                                 {
3703                                         $$ = makeNode(ParamNo);
3704                                         $$->number = $1;
3705                                 }
3706                 ;
3707
3708 NumConst:  Iconst                                               { $$ = makeInteger($1); }
3709                 | FCONST                                                { $$ = makeFloat($1); }
3710                 ;
3711
3712 Iconst:  ICONST                                                 { $$ = $1; };
3713 Sconst:  SCONST                                                 { $$ = $1; };
3714
3715 /* Column and type identifier
3716  * Does not include explicit datetime types
3717  *  since these must be decoupled in Typename syntax.
3718  * Use ColId for most identifiers. - thomas 1997-10-21
3719  */
3720 Id:  IDENT                                                              { $$ = $1; };
3721
3722 /* Column identifier
3723  * Include date/time keywords as SQL92 extension.
3724  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3725  * Add other keywords. Note that as the syntax expands,
3726  *  some of these keywords will have to be removed from this
3727  *  list due to shift/reduce conflicts in yacc. If so, move
3728  *  down to the ColLabel entity. - thomas 1997-11-06
3729  */
3730 ColId:  Id                                                              { $$ = $1; }
3731                 | datetime                                              { $$ = $1; }
3732                 | ACTION                                                { $$ = "action"; }
3733                 | DATABASE                                              { $$ = "database"; }
3734                 | DELIMITERS                                    { $$ = "delimiters"; }
3735                 | FUNCTION                                              { $$ = "function"; }
3736                 | INDEX                                                 { $$ = "index"; }
3737                 | KEY                                                   { $$ = "key"; }
3738                 | LANGUAGE                                              { $$ = "language"; }
3739                 | LOCATION                                              { $$ = "location"; }
3740                 | MATCH                                                 { $$ = "match"; }
3741                 | OPERATOR                                              { $$ = "operator"; }
3742                 | OPTION                                                { $$ = "option"; }
3743                 | PRIVILEGES                                    { $$ = "privileges"; }
3744                 | RECIPE                                                { $$ = "recipe"; }
3745                 | TIME                                                  { $$ = "time"; }
3746                 | TRIGGER                                               { $$ = "trigger"; }
3747                 | TYPE_P                                                { $$ = "type"; }
3748                 | VERSION                                               { $$ = "version"; }
3749                 | ZONE                                                  { $$ = "zone"; }
3750                 ;
3751
3752 /* Column label
3753  * Allowed labels in "AS" clauses.
3754  * Include TRUE/FALSE SQL3 reserved words for Postgres backward
3755  *  compatibility. Cannot allow this for column names since the
3756  *  syntax would not distinguish between the constant value and
3757  *  a column name. - thomas 1997-10-24
3758  * Add other keywords to this list. Note that they appear here
3759  *  rather than in ColId if there was a shift/reduce conflict
3760  *  when used as a full identifier. - thomas 1997-11-06
3761  */
3762 ColLabel:  ColId                                                { $$ = $1; }
3763                 | ARCHIVE                                               { $$ = "archive"; }
3764                 | CLUSTER                                               { $$ = "cluster"; }
3765                 | CONSTRAINT                                    { $$ = "constraint"; }
3766                 | CROSS                                                 { $$ = "cross"; }
3767                 | FOREIGN                                               { $$ = "foreign"; }
3768                 | GROUP                                                 { $$ = "group"; }
3769                 | LOAD                                                  { $$ = "load"; }
3770                 | ORDER                                                 { $$ = "order"; }
3771                 | POSITION                                              { $$ = "position"; }
3772                 | PRECISION                                             { $$ = "precision"; }
3773                 | TABLE                                                 { $$ = "table"; }
3774                 | TRANSACTION                                   { $$ = "transaction"; }
3775                 | TRUE_P                                                { $$ = "true"; }
3776                 | FALSE_P                                               { $$ = "false"; }
3777                 ;
3778
3779 SpecialRuleRelation:  CURRENT
3780                                 {
3781                                         if (QueryIsRule)
3782                                                 $$ = "*CURRENT*";
3783                                         else
3784                                                 elog(ERROR,"CURRENT used in non-rule query");
3785                                 }
3786                 | NEW
3787                                 {
3788                                         if (QueryIsRule)
3789                                                 $$ = "*NEW*";
3790                                         else
3791                                                 elog(ERROR,"NEW used in non-rule query");
3792                                 }
3793                 ;
3794
3795 %%
3796
3797 static Node *
3798 makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
3799 {
3800         A_Expr *a = makeNode(A_Expr);
3801         a->oper = oper;
3802         a->opname = opname;
3803         a->lexpr = lexpr;
3804         a->rexpr = rexpr;
3805         return (Node *)a;
3806 }
3807
3808 /* makeRowExpr()
3809  * Generate separate operator nodes for a single row descriptor expression.
3810  * Perhaps this should go deeper in the parser someday... - thomas 1997-12-22
3811  */
3812 static Node *
3813 makeRowExpr(char *opr, List *largs, List *rargs)
3814 {
3815         Node *expr = NULL;
3816         Node *larg, *rarg;
3817
3818         if (length(largs) != length(rargs))
3819                 elog(ERROR,"Unequal number of entries in row expression");
3820
3821         if (lnext(largs) != NIL)
3822                 expr = makeRowExpr(opr,lnext(largs),lnext(rargs));
3823
3824         larg = lfirst(largs);
3825         rarg = lfirst(rargs);
3826
3827         if ((strcmp(opr, "=") == 0)
3828          || (strcmp(opr, "<") == 0)
3829          || (strcmp(opr, "<=") == 0)
3830          || (strcmp(opr, ">") == 0)
3831          || (strcmp(opr, ">=") == 0))
3832         {
3833                 if (expr == NULL)
3834                         expr = makeA_Expr(OP, opr, larg, rarg);
3835                 else
3836                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3837         }
3838         else if (strcmp(opr, "<>") == 0)
3839         {
3840                 if (expr == NULL)
3841                         expr = makeA_Expr(OP, opr, larg, rarg);
3842                 else
3843                         expr = makeA_Expr(OR, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3844         }
3845         else
3846         {
3847                 elog(ERROR,"Operator '%s' not implemented for row expressions",opr);
3848         }
3849
3850 #if FALSE
3851         while ((largs != NIL) && (rargs != NIL))
3852         {
3853                 larg = lfirst(largs);
3854                 rarg = lfirst(rargs);
3855
3856                 if (expr == NULL)
3857                         expr = makeA_Expr(OP, opr, larg, rarg);
3858                 else
3859                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3860
3861                 largs = lnext(largs);
3862                 rargs = lnext(rargs);
3863         }
3864         pprint(expr);
3865 #endif
3866
3867         return expr;
3868 } /* makeRowExpr() */
3869
3870 void
3871 mapTargetColumns(List *src, List *dst)
3872 {
3873         ColumnDef *s;
3874         ResTarget *d;
3875
3876         if (length(src) != length(dst))
3877                 elog(ERROR,"CREATE TABLE/AS SELECT has mismatched column count");
3878
3879         while ((src != NIL) && (dst != NIL))
3880         {
3881                 s = (ColumnDef *)lfirst(src);
3882                 d = (ResTarget *)lfirst(dst);
3883
3884                 d->name = s->colname;
3885
3886                 src = lnext(src);
3887                 dst = lnext(dst);
3888         }
3889
3890         return;
3891 } /* mapTargetColumns() */
3892
3893 static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr)
3894 {
3895         Node *result = NULL;
3896
3897         /* we do this so indexes can be used */
3898         if (strcmp(opname,"~") == 0 ||
3899                 strcmp(opname,"~*") == 0)
3900         {
3901                 if (nodeTag(rexpr) == T_A_Const &&
3902                    ((A_Const *)rexpr)->val.type == T_String &&
3903                    ((A_Const *)rexpr)->val.val.str[0] == '^')
3904                 {
3905                         A_Const *n = (A_Const *)rexpr;
3906                         char *match_least = palloc(strlen(n->val.val.str)+2);
3907                         char *match_most = palloc(strlen(n->val.val.str)+2);
3908                         int pos, match_pos=0;
3909
3910                         /* skip leading ^ */
3911                         for (pos = 1; n->val.val.str[pos]; pos++)
3912                         {
3913                                 if (n->val.val.str[pos] == '.' ||
3914                                         n->val.val.str[pos] == '?' ||
3915                                         n->val.val.str[pos] == '*' ||
3916                                         n->val.val.str[pos] == '[' ||
3917                                         n->val.val.str[pos] == '$' ||
3918                                         (strcmp(opname,"~*") == 0 && isalpha(n->val.val.str[pos])))
3919                                 break;
3920                         if (n->val.val.str[pos] == '\\')
3921                                         pos++;
3922                                 match_least[match_pos] = n->val.val.str[pos];
3923                                 match_most[match_pos++] = n->val.val.str[pos];
3924                         }
3925
3926                         if (match_pos != 0)
3927                         {
3928                                 A_Const *least = makeNode(A_Const);
3929                                 A_Const *most = makeNode(A_Const);
3930
3931                                 /* make strings to be used in index use */
3932                                 match_least[match_pos] = '\0';
3933                                 match_most[match_pos] = '\377';
3934                                 match_most[match_pos+1] = '\0';
3935                                 least->val.type = T_String;
3936                                 least->val.val.str = match_least;
3937                                 most->val.type = T_String;
3938                                 most->val.val.str = match_most;
3939                                 result = makeA_Expr(AND, NULL,
3940                                                 makeA_Expr(OP, "~", lexpr, rexpr),
3941                                                 makeA_Expr(AND, NULL,
3942                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3943                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3944                         }
3945                 }
3946         }
3947         else if (strcmp(opname,"~~") == 0)
3948         {
3949                 if (nodeTag(rexpr) == T_A_Const &&
3950                    ((A_Const *)rexpr)->val.type == T_String)
3951                 {
3952                         A_Const *n = (A_Const *)rexpr;
3953                         char *match_least = palloc(strlen(n->val.val.str)+2);
3954                         char *match_most = palloc(strlen(n->val.val.str)+2);
3955                         int pos, match_pos=0;
3956
3957                         for (pos = 0; n->val.val.str[pos]; pos++)
3958                         {
3959                                 if ((n->val.val.str[pos] == '%' &&
3960                                          n->val.val.str[pos+1] != '%') ||
3961                                     (n->val.val.str[pos] == '_' &&
3962                                  n->val.val.str[pos+1] != '_'))
3963                                 break;
3964                         if (n->val.val.str[pos] == '%' ||
3965                                     n->val.val.str[pos] == '_' ||
3966                                     n->val.val.str[pos] == '\\')
3967                                         pos++;
3968                                 match_least[match_pos] = n->val.val.str[pos];
3969                                 match_most[match_pos++] = n->val.val.str[pos];
3970                         }
3971
3972                         if (match_pos != 0)
3973                         {
3974                                 A_Const *least = makeNode(A_Const);
3975                                 A_Const *most = makeNode(A_Const);
3976
3977                                 /* make strings to be used in index use */
3978                                 match_least[match_pos] = '\0';
3979                                 match_most[match_pos] = '\377';
3980                                 match_most[match_pos+1] = '\0';
3981                                 least->val.type = T_String;
3982                                 least->val.val.str = match_least;
3983                                 most->val.type = T_String;
3984                                 most->val.val.str = match_most;
3985                                 result = makeA_Expr(AND, NULL,
3986                                                 makeA_Expr(OP, "~~", lexpr, rexpr),
3987                                                 makeA_Expr(AND, NULL,
3988                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3989                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3990                         }
3991                 }
3992         }
3993
3994         if (result == NULL)
3995                 result = makeA_Expr(OP, opname, lexpr, rexpr);
3996         return result;
3997 } /* makeIndexable() */
3998
3999
4000 /* xlateSqlType()
4001  * Convert alternate type names to internal Postgres types.
4002  * Do not convert "float", since that is handled elsewhere
4003  *  for FLOAT(p) syntax.
4004  */
4005 static char *
4006 xlateSqlType(char *name)
4007 {
4008         if (!strcasecmp(name,"int")
4009          || !strcasecmp(name,"integer"))
4010                 return "int4";
4011         else if (!strcasecmp(name, "smallint"))
4012                 return "int2";
4013         else if (!strcasecmp(name, "real"))
4014                 return "float8";
4015         else if (!strcasecmp(name, "interval"))
4016                 return "timespan";
4017         else if (!strcasecmp(name, "boolean"))
4018                 return "bool";
4019         else
4020                 return name;
4021 } /* xlateSqlName() */
4022
4023
4024 void parser_init(Oid *typev, int nargs)
4025 {
4026         QueryIsRule = FALSE;
4027         saved_relname[0]= '\0';
4028         saved_In_Expr = NULL;
4029
4030         param_type_init(typev, nargs);
4031 }
4032
4033
4034 /* FlattenStringList()
4035  * Traverse list of string nodes and convert to a single string.
4036  * Used for reconstructing string form of complex expressions.
4037  *
4038  * Allocate at least one byte for terminator.
4039  */
4040 static char *
4041 FlattenStringList(List *list)
4042 {
4043         List *l;
4044         Value *v;
4045         char *s;
4046         char *sp;
4047         int nlist, len = 0;
4048
4049         nlist = length(list);
4050         l = list;
4051         while(l != NIL) {
4052                 v = (Value *)lfirst(l);
4053                 sp = v->val.str;
4054                 l = lnext(l);
4055                 len += strlen(sp);
4056         };
4057         len += nlist;
4058
4059         s = (char*) palloc(len+1);
4060         *s = '\0';
4061
4062         l = list;
4063         while(l != NIL) {
4064                 v = (Value *)lfirst(l);
4065                 sp = v->val.str;
4066                 l = lnext(l);
4067                 strcat(s,sp);
4068                 if (l != NIL) strcat(s," ");
4069         };
4070         *(s+len) = '\0';
4071
4072 #ifdef PARSEDEBUG
4073 printf( "flattened string is \"%s\"\n", s);
4074 #endif
4075
4076         return(s);
4077 } /* FlattenStringList() */
4078
4079
4080 /* makeConstantList()
4081  * Convert constant value node into string node.
4082  */
4083 static List *
4084 makeConstantList( A_Const *n)
4085 {
4086         char *defval = NULL;
4087         if (nodeTag(n) != T_A_Const) {
4088                 elog(ERROR,"Cannot handle non-constant parameter");
4089
4090         } else if (n->val.type == T_Float) {
4091                 defval = (char*) palloc(20+1);
4092                 sprintf( defval, "%g", n->val.val.dval);
4093
4094         } else if (n->val.type == T_Integer) {
4095                 defval = (char*) palloc(20+1);
4096                 sprintf( defval, "%ld", n->val.val.ival);
4097
4098         } else if (n->val.type == T_String) {
4099                 defval = (char*) palloc(strlen( ((A_Const *) n)->val.val.str) + 3);
4100                 strcpy( defval, "'");
4101                 strcat( defval, ((A_Const *) n)->val.val.str);
4102                 strcat( defval, "'");
4103
4104         } else {
4105                 elog(ERROR,"Internal error in makeConstantList(): cannot encode node");
4106         };
4107
4108 #ifdef PARSEDEBUG
4109 printf( "AexprConst argument is \"%s\"\n", defval);
4110 #endif
4111
4112         return( lcons( makeString(defval), NIL));
4113 } /* makeConstantList() */
4114
4115
4116 /* fmtId()
4117  * Check input string for non-lowercase/non-numeric characters.
4118  * Returns either input string or input surrounded by double quotes.
4119  */
4120 static char *
4121 fmtId(char *rawid)
4122 {
4123         static char *cp;
4124
4125         for (cp = rawid; *cp != '\0'; cp++)
4126                 if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;
4127
4128         if (*cp != '\0') {
4129                 cp = palloc(strlen(rawid)+1);
4130                 strcpy(cp,"\"");
4131                 strcat(cp,rawid);
4132                 strcat(cp,"\"");
4133         } else {
4134                 cp = rawid;
4135         };
4136
4137 #ifdef PARSEDEBUG
4138 printf("fmtId- %sconvert %s to %s\n", ((cp == rawid)? "do not ": ""), rawid, cp);
4139 #endif
4140
4141         return(cp);
4142 }
4143
4144 /*
4145  * param_type_init()
4146  *
4147  * keep enough information around fill out the type of param nodes
4148  * used in postquel functions
4149  */
4150 static void
4151 param_type_init(Oid *typev, int nargs)
4152 {
4153         pfunc_num_args = nargs;
4154         param_type_info = typev;
4155 }
4156
4157 Oid param_type(int t)
4158 {
4159         if ((t > pfunc_num_args) || (t == 0))
4160                 return InvalidOid;
4161         return param_type_info[t - 1];
4162 }