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.83 1998/01/04 04:31:08 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         AppendStmt                      *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                 ReplaceStmt, AppendStmt, RetrieveStmt, 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(WARN,"ALTER TABLE/ADD() allows one column only",NULL);
 594                                         $$ = lp;
 595                                 }
 596                         | DROP opt_column ColId
 597                                 {       elog(WARN,"ALTER TABLE/DROP COLUMN not yet implemented",NULL); }
 598                         | ALTER opt_column ColId SET DEFAULT default_expr
 599                                 {       elog(WARN,"ALTER TABLE/ALTER COLUMN/SET DEFAULT not yet implemented",NULL); }
 600                         | ALTER opt_column ColId DROP DEFAULT
 601                                 {       elog(WARN,"ALTER TABLE/ALTER COLUMN/DROP DEFAULT not yet implemented",NULL); }
 602                         | ADD ConstraintElem
 603                                 {       elog(WARN,"ALTER TABLE/ADD CONSTRAINT not yet implemented",NULL); }
 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",NULL);
 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(WARN,"boolean expressions not supported in DEFAULT",NULL); }
 815                         | default_expr '<' default_expr
 816                                 {       elog(WARN,"boolean expressions not supported in DEFAULT",NULL); }
 817                         | default_expr '>' default_expr
 818                                 {       elog(WARN,"boolean expressions not supported in DEFAULT",NULL); }
 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(WARN,"boolean expressions not supported in DEFAULT",NULL);
 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",NULL); }
 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                                         RetrieveStmt *n = (RetrieveStmt *)$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(WARN,"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(WARN,"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(WARN,"Please specify nonnegative count for fetch",NULL); }
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(WARN,"EXECUTE RECIPE may only be used in begin/end transaction blocks",NULL);
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(WARN,"parser: argument type missing (use NONE for unary operators)",NULL);
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 RetrieveStmt
1959                                 {
1960                                         ViewStmt *n = makeNode(ViewStmt);
1961                                         n->viewname = $3;
1962                                         n->query = (Query *)$5;
1963                                         $$ = (Node *)n;
1964                                 }
1965                 ;
1966
1967
1968 /*****************************************************************************
1969  *
1970  *              QUERY:
1971  *                              load "filename"
1972  *
1973  *****************************************************************************/
1974
1975 LoadStmt:  LOAD file_name
1976                                 {
1977                                         LoadStmt *n = makeNode(LoadStmt);
1978                                         n->filename = $2;
1979                                         $$ = (Node *)n;
1980                                 }
1981                 ;
1982
1983
1984 /*****************************************************************************
1985  *
1986  *              QUERY:
1987  *                              createdb dbname
1988  *
1989  *****************************************************************************/
1990
1991 CreatedbStmt:  CREATE DATABASE database_name opt_database
1992                                 {
1993                                         CreatedbStmt *n = makeNode(CreatedbStmt);
1994                                         n->dbname = $3;
1995                                         n->dbpath = $4;
1996                                         $$ = (Node *)n;
1997                                 }
1998                 ;
1999
2000 opt_database:  WITH LOCATION '=' location               { $$ = $4; }
2001                 | /*EMPTY*/                                                             { $$ = NULL; }
2002                 ;
2003
2004 location:  Sconst                                                               { $$ = $1; }
2005                 | DEFAULT                                                               { $$ = NULL; }
2006                 | /*EMPTY*/                                                             { $$ = NULL; }
2007                 ;
2008
2009 /*****************************************************************************
2010  *
2011  *              QUERY:
2012  *                              destroydb dbname
2013  *
2014  *****************************************************************************/
2015
2016 DestroydbStmt:  DROP DATABASE database_name
2017                                 {
2018                                         DestroydbStmt *n = makeNode(DestroydbStmt);
2019                                         n->dbname = $3;
2020                                         $$ = (Node *)n;
2021                                 }
2022                 ;
2023
2024
2025 /*****************************************************************************
2026  *
2027  *              QUERY:
2028  *                              cluster <index_name> on <relation_name>
2029  *
2030  *****************************************************************************/
2031
2032 ClusterStmt:  CLUSTER index_name ON relation_name
2033                                 {
2034                                    ClusterStmt *n = makeNode(ClusterStmt);
2035                                    n->relname = $4;
2036                                    n->indexname = $2;
2037                                    $$ = (Node*)n;
2038                                 }
2039                 ;
2040
2041
2042 /*****************************************************************************
2043  *
2044  *              QUERY:
2045  *                              vacuum
2046  *
2047  *****************************************************************************/
2048
2049 VacuumStmt:  VACUUM opt_verbose opt_analyze
2050                                 {
2051                                         VacuumStmt *n = makeNode(VacuumStmt);
2052                                         n->verbose = $2;
2053                                         n->analyze = $3;
2054                                         n->vacrel = NULL;
2055                                         n->va_spec = NIL;
2056                                         $$ = (Node *)n;
2057                                 }
2058                 | VACUUM opt_verbose opt_analyze relation_name opt_va_list
2059                                 {
2060                                         VacuumStmt *n = makeNode(VacuumStmt);
2061                                         n->verbose = $2;
2062                                         n->analyze = $3;
2063                                         n->vacrel = $4;
2064                                         n->va_spec = $5;
2065                                         if ( $5 != NIL && !$4 )
2066                                                 elog(WARN,"parser: syntax error at or near \"(\"",NULL);
2067                                         $$ = (Node *)n;
2068                                 }
2069                 ;
2070
2071 opt_verbose:  VERBOSE                                                   { $$ = TRUE; }
2072                 | /*EMPTY*/                                                             { $$ = FALSE; }
2073                 ;
2074
2075 opt_analyze:  ANALYZE                                                   { $$ = TRUE; }
2076                 | /*EMPTY*/                                                             { $$ = FALSE; }
2077                 ;
2078
2079 opt_va_list:  '(' va_list ')'
2080                                 { $$ = $2; }
2081                 | /* EMPTY */
2082                                 { $$ = NIL; }
2083                 ;
2084
2085 va_list:  name
2086                                 { $$=lcons($1,NIL); }
2087                 | va_list ',' name
2088                                 { $$=lappend($1,$3); }
2089                 ;
2090
2091
2092 /*****************************************************************************
2093  *
2094  *              QUERY:
2095  *                              EXPLAIN query
2096  *
2097  *****************************************************************************/
2098
2099 ExplainStmt:  EXPLAIN opt_verbose OptimizableStmt
2100                                 {
2101                                         ExplainStmt *n = makeNode(ExplainStmt);
2102                                         n->verbose = $2;
2103                                         n->query = (Query*)$3;
2104                                         $$ = (Node *)n;
2105                                 }
2106                 ;
2107
2108
2109 /*****************************************************************************
2110  *                                                                                                                                                       *
2111  *              Optimizable Stmts:                                                                                                       *
2112  *                                                                                                                                                       *
2113  *              one of the five queries processed by the planner                                         *
2114  *                                                                                                                                                       *
2115  *              [ultimately] produces query-trees as specified                                           *
2116  *              in the query-spec document in ~postgres/ref                                                      *
2117  *                                                                                                                                                       *
2118  *****************************************************************************/
2119
2120 OptimizableStmt:  RetrieveStmt
2121                 | CursorStmt
2122                 | ReplaceStmt
2123                 | AppendStmt
2124                 | NotifyStmt
2125                 | DeleteStmt                                    /* by default all are $$=$1 */
2126                 ;
2127
2128
2129 /*****************************************************************************
2130  *
2131  *              QUERY:
2132  *                              INSERT STATEMENTS
2133  *
2134  *****************************************************************************/
2135
2136 AppendStmt:  INSERT INTO relation_name opt_column_list insert_rest
2137                                 {
2138                                         $5->relname = $3;
2139                                         $5->cols = $4;
2140                                         $$ = (Node *)$5;
2141                                 }
2142                 ;
2143
2144 insert_rest:  VALUES '(' res_target_list2 ')'
2145                                 {
2146                                         $$ = makeNode(AppendStmt);
2147                                         $$->targetList = $3;
2148                                         $$->fromClause = NIL;
2149                                         $$->whereClause = NULL;
2150                                 }
2151                 | SELECT res_target_list2 from_clause where_clause
2152                                 {
2153                                         $$ = makeNode(AppendStmt);
2154                                         $$->targetList = $2;
2155                                         $$->fromClause = $3;
2156                                         $$->whereClause = $4;
2157                                 }
2158                 ;
2159
2160 opt_column_list:  '(' columnList ')'                    { $$ = $2; }
2161                 | /*EMPTY*/                                                             { $$ = NIL; }
2162                 ;
2163
2164 columnList:
2165                   columnList ',' columnElem
2166                                 { $$ = lappend($1, $3); }
2167                 | columnElem
2168                                 { $$ = lcons($1, NIL); }
2169                 ;
2170
2171 columnElem:  ColId opt_indirection
2172                                 {
2173                                         Ident *id = makeNode(Ident);
2174                                         id->name = $1;
2175                                         id->indirection = $2;
2176                                         $$ = (Node *)id;
2177                                 }
2178                 ;
2179
2180
2181 /*****************************************************************************
2182  *
2183  *              QUERY:
2184  *                              DELETE STATEMENTS
2185  *
2186  *****************************************************************************/
2187
2188 DeleteStmt:  DELETE FROM relation_name
2189                          where_clause
2190                                 {
2191                                         DeleteStmt *n = makeNode(DeleteStmt);
2192                                         n->relname = $3;
2193                                         n->whereClause = $4;
2194                                         $$ = (Node *)n;
2195                                 }
2196                 ;
2197
2198
2199 /*****************************************************************************
2200  *
2201  *              QUERY:
2202  *                              ReplaceStmt (UPDATE)
2203  *
2204  *****************************************************************************/
2205
2206 ReplaceStmt:  UPDATE relation_name
2207                           SET res_target_list
2208                           from_clause
2209                           where_clause
2210                                 {
2211                                         ReplaceStmt *n = makeNode(ReplaceStmt);
2212                                         n->relname = $2;
2213                                         n->targetList = $4;
2214                                         n->fromClause = $5;
2215                                         n->whereClause = $6;
2216                                         $$ = (Node *)n;
2217                                 }
2218                 ;
2219
2220
2221 /*****************************************************************************
2222  *
2223  *              QUERY:
2224  *                              CURSOR STATEMENTS
2225  *
2226  *****************************************************************************/
2227
2228 CursorStmt:  DECLARE name opt_binary CURSOR FOR
2229                          SELECT opt_unique res_target_list2
2230                          from_clause where_clause group_clause sort_clause
2231                                 {
2232                                         CursorStmt *n = makeNode(CursorStmt);
2233
2234                                         /* from PORTAL name */
2235                                         /*
2236                                          *      15 august 1991 -- since 3.0 postgres does locking
2237                                          *      right, we discovered that portals were violating
2238                                          *      locking protocol.  portal locks cannot span xacts.
2239                                          *      as a short-term fix, we installed the check here.
2240                                          *                                                      -- mao
2241                                          */
2242                                         if (!IsTransactionBlock())
2243                                                 elog(WARN,"Named portals may only be used in begin/end transaction blocks",NULL);
2244
2245                                         n->portalname = $2;
2246                                         n->binary = $3;
2247                                         n->unique = $7;
2248                                         n->targetList = $8;
2249                                         n->fromClause = $9;
2250                                         n->whereClause = $10;
2251                                         n->groupClause = $11;
2252                                         n->sortClause = $12;
2253                                         $$ = (Node *)n;
2254                                 }
2255                 ;
2256
2257
2258 /*****************************************************************************
2259  *
2260  *              QUERY:
2261  *                              SELECT STATEMENTS
2262  *
2263  *****************************************************************************/
2264
2265 RetrieveStmt:  SELECT opt_unique res_target_list2
2266                          result from_clause where_clause
2267                          group_clause having_clause
2268                          union_clause sort_clause
2269                                 {
2270                                         RetrieveStmt *n = makeNode(RetrieveStmt);
2271                                         n->unique = $2;
2272                                         n->targetList = $3;
2273                                         n->into = $4;
2274                                         n->fromClause = $5;
2275                                         n->whereClause = $6;
2276                                         n->groupClause = $7;
2277                                         n->havingClause = $8;
2278                                         n->unionClause = $9;
2279                                         n->sortClause = $10;
2280                                         $$ = (Node *)n;
2281                                 }
2282                 ;
2283
2284 union_clause:  UNION opt_union select_list
2285                                 {
2286                                         RetrieveStmt *n = (RetrieveStmt *)lfirst($3);
2287                                         n->unionall = $2;
2288                                         $$ = $3;
2289                                 }
2290                 | /*EMPTY*/
2291                                 { $$ = NIL; }
2292                 ;
2293
2294 select_list:  select_list UNION opt_union SubSelect
2295                                 {
2296                                         RetrieveStmt *n = (RetrieveStmt *)$4;
2297                                         n->unionall = $3;
2298                                         $$ = lappend($1, $4);
2299                                 }
2300                 | SubSelect
2301                                 { $$ = lcons($1, NIL); }
2302                 ;
2303
2304 SubSelect:      SELECT opt_unique res_target_list2
2305                          from_clause where_clause
2306                          group_clause having_clause
2307                                 {
2308                                         RetrieveStmt *n = makeNode(RetrieveStmt);
2309                                         n->unique = $2;
2310                                         n->unionall = FALSE;
2311                                         n->targetList = $3;
2312                                         n->fromClause = $4;
2313                                         n->whereClause = $5;
2314                                         n->groupClause = $6;
2315                                         n->havingClause = $7;
2316                                         $$ = (Node *)n;
2317                                 }
2318                 ;
2319
2320 result:  INTO TABLE relation_name
2321                                 {       $$= $3; }
2322                 | /*EMPTY*/
2323                                 {       $$ = NULL; }
2324                 ;
2325
2326 opt_union:  ALL                                                                 { $$ = TRUE; }
2327                 | /*EMPTY*/                                                             { $$ = FALSE; }
2328                 ;
2329
2330 opt_unique:  DISTINCT                                                   { $$ = "*"; }
2331                 | DISTINCT ON ColId                                             { $$ = $3; }
2332                 | ALL                                                                   { $$ = NULL; }
2333                 | /*EMPTY*/                                                             { $$ = NULL; }
2334                 ;
2335
2336 sort_clause:  ORDER BY sortby_list                              { $$ = $3; }
2337                 | /*EMPTY*/                                                             { $$ = NIL; }
2338                 ;
2339
2340 sortby_list:  sortby                                                    { $$ = lcons($1, NIL); }
2341                 | sortby_list ',' sortby                                { $$ = lappend($1, $3); }
2342                 ;
2343
2344 sortby:  ColId OptUseOp
2345                                 {
2346                                         $$ = makeNode(SortGroupBy);
2347                                         $$->resno = 0;
2348                                         $$->range = NULL;
2349                                         $$->name = $1;
2350                                         $$->useOp = $2;
2351                                 }
2352                 | ColId '.' ColId OptUseOp
2353                                 {
2354                                         $$ = makeNode(SortGroupBy);
2355                                         $$->resno = 0;
2356                                         $$->range = $1;
2357                                         $$->name = $3;
2358                                         $$->useOp = $4;
2359                                 }
2360                 | Iconst OptUseOp
2361                                 {
2362                                         $$ = makeNode(SortGroupBy);
2363                                         $$->resno = $1;
2364                                         $$->range = NULL;
2365                                         $$->name = NULL;
2366                                         $$->useOp = $2;
2367                                 }
2368                 ;
2369
2370 OptUseOp:  USING Op                                                             { $$ = $2; }
2371                 | USING '<'                                                             { $$ = "<"; }
2372                 | USING '>'                                                             { $$ = ">"; }
2373                 | ASC                                                                   { $$ = "<"; }
2374                 | DESC                                                                  { $$ = ">"; }
2375                 | /*EMPTY*/                                                             { $$ = "<"; /*default*/ }
2376                 ;
2377
2378 /*
2379  *      jimmy bell-style recursive queries aren't supported in the
2380  *      current system.
2381  *
2382  *      ...however, recursive addattr and rename supported.  make special
2383  *      cases for these.
2384  */
2385 opt_inh_star:  '*'                                                              { $$ = TRUE; }
2386                 | /*EMPTY*/                                                             { $$ = FALSE; }
2387                 ;
2388
2389 relation_name_list:  name_list;
2390
2391 name_list:  name
2392                                 {       $$ = lcons(makeString($1),NIL); }
2393                 | name_list ',' name
2394                                 {       $$ = lappend($1,makeString($3)); }
2395                 ;
2396
2397 group_clause:  GROUP BY groupby_list                    { $$ = $3; }
2398                 | /*EMPTY*/                                                             { $$ = NIL; }
2399                 ;
2400
2401 groupby_list:  groupby                                                  { $$ = lcons($1, NIL); }
2402                 | groupby_list ',' groupby                              { $$ = lappend($1, $3); }
2403                 ;
2404
2405 groupby:  ColId
2406                                 {
2407                                         $$ = makeNode(SortGroupBy);
2408                                         $$->resno = 0;
2409                                         $$->range = NULL;
2410                                         $$->name = $1;
2411                                         $$->useOp = NULL;
2412                                 }
2413                 | ColId '.' ColId
2414                                 {
2415                                         $$ = makeNode(SortGroupBy);
2416                                         $$->resno = 0;
2417                                         $$->range = $1;
2418                                         $$->name = $3;
2419                                         $$->useOp = NULL;
2420                                 }
2421                 | Iconst
2422                                 {
2423                                         $$ = makeNode(SortGroupBy);
2424                                         $$->resno = $1;
2425                                         $$->range = NULL;
2426                                         $$->name = NULL;
2427                                         $$->useOp = NULL;
2428                                 }
2429                 ;
2430
2431 having_clause:  HAVING a_expr                                   { $$ = $2; }
2432                 | /*EMPTY*/                                                             { $$ = NULL; }
2433                 ;
2434
2435
2436 /*****************************************************************************
2437  *
2438  *      clauses common to all Optimizable Stmts:
2439  *              from_clause             -
2440  *              where_clause    -
2441  *
2442  *****************************************************************************/
2443
2444 from_clause:  FROM '(' relation_expr join_expr JOIN relation_expr join_spec ')'
2445                                 {
2446                                         $$ = NIL;
2447                                         elog(WARN,"JOIN not yet implemented",NULL);
2448                                 }
2449                 | FROM from_list                                                { $$ = $2; }
2450                 | /*EMPTY*/                                                             { $$ = NIL; }
2451                 ;
2452
2453 from_list:      from_list ',' from_val
2454                                 { $$ = lappend($1, $3); }
2455                 | from_val CROSS JOIN from_val
2456                                 { elog(WARN,"CROSS JOIN not yet implemented",NULL); }
2457                 | from_val
2458                                 { $$ = lcons($1, NIL); }
2459                 ;
2460
2461 from_val:  relation_expr AS ColLabel
2462                                 {
2463                                         $$ = makeNode(RangeVar);
2464                                         $$->relExpr = $1;
2465                                         $$->name = $3;
2466                                 }
2467                 | relation_expr ColId
2468                                 {
2469                                         $$ = makeNode(RangeVar);
2470                                         $$->relExpr = $1;
2471                                         $$->name = $2;
2472                                 }
2473                 | relation_expr
2474                                 {
2475                                         $$ = makeNode(RangeVar);
2476                                         $$->relExpr = $1;
2477                                         $$->name = NULL;
2478                                 }
2479                 ;
2480
2481 join_expr:  NATURAL join_expr                                   { $$ = NULL; }
2482                 | FULL join_outer
2483                                 { elog(WARN,"FULL OUTER JOIN not yet implemented",NULL); }
2484                 | LEFT join_outer
2485                                 { elog(WARN,"LEFT OUTER JOIN not yet implemented",NULL); }
2486                 | RIGHT join_outer
2487                                 { elog(WARN,"RIGHT OUTER JOIN not yet implemented",NULL); }
2488                 | OUTER_P
2489                                 { elog(WARN,"OUTER JOIN not yet implemented",NULL); }
2490                 | INNER_P
2491                                 { elog(WARN,"INNER JOIN not yet implemented",NULL); }
2492                 | UNION
2493                                 { elog(WARN,"UNION JOIN not yet implemented",NULL); }
2494                 | /*EMPTY*/
2495                                 { elog(WARN,"INNER JOIN not yet implemented",NULL); }
2496                 ;
2497
2498 join_outer:  OUTER_P                                                    { $$ = NULL; }
2499                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2500                 ;
2501
2502 join_spec:      ON '(' a_expr ')'                                       { $$ = NULL; }
2503                 | USING '(' join_list ')'                               { $$ = NULL; }
2504                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2505                 ;
2506
2507 join_list:  join_using                                                  { $$ = lcons($1, NIL); }
2508                 | join_list ',' join_using                              { $$ = lappend($1, $3); }
2509                 ;
2510
2511 join_using:  ColId
2512                                 {
2513                                         $$ = makeNode(SortGroupBy);
2514                                         $$->resno = 0;
2515                                         $$->range = NULL;
2516                                         $$->name = $1;
2517                                         $$->useOp = NULL;
2518                                 }
2519                 | ColId '.' ColId
2520                                 {
2521                                         $$ = makeNode(SortGroupBy);
2522                                         $$->resno = 0;
2523                                         $$->range = $1;
2524                                         $$->name = $3;
2525                                         $$->useOp = NULL;
2526                                 }
2527                 | Iconst
2528                                 {
2529                                         $$ = makeNode(SortGroupBy);
2530                                         $$->resno = $1;
2531                                         $$->range = NULL;
2532                                         $$->name = NULL;
2533                                         $$->useOp = NULL;
2534                                 }
2535                 ;
2536
2537 where_clause:  WHERE a_expr                                             { $$ = $2; }
2538                 | /*EMPTY*/                                                             { $$ = NULL;  /* no qualifiers */ }
2539                 ;
2540
2541 relation_expr:  relation_name
2542                                 {
2543                                         /* normal relations */
2544                                         $$ = makeNode(RelExpr);
2545                                         $$->relname = $1;
2546                                         $$->inh = FALSE;
2547                                 }
2548                 | relation_name '*'                               %prec '='
2549                                 {
2550                                         /* inheritance query */
2551                                         $$ = makeNode(RelExpr);
2552                                         $$->relname = $1;
2553                                         $$->inh = TRUE;
2554                                 }
2555
2556 opt_array_bounds:  '[' ']' nest_array_bounds
2557                                 {  $$ = lcons(makeInteger(-1), $3); }
2558                 | '[' Iconst ']' nest_array_bounds
2559                                 {  $$ = lcons(makeInteger($2), $4); }
2560                 | /* EMPTY */
2561                                 {  $$ = NIL; }
2562                 ;
2563
2564 nest_array_bounds:      '[' ']' nest_array_bounds
2565                                 {  $$ = lcons(makeInteger(-1), $3); }
2566                 | '[' Iconst ']' nest_array_bounds
2567                                 {  $$ = lcons(makeInteger($2), $4); }
2568                 | /*EMPTY*/
2569                                 {  $$ = NIL; }
2570                 ;
2571
2572
2573 /*****************************************************************************
2574  *
2575  *      Type syntax
2576  *              SQL92 introduces a large amount of type-specific syntax.
2577  *              Define individual clauses to handle these cases, and use
2578  *               the generic case to handle regular type-extensible Postgres syntax.
2579  *              - thomas 1997-10-10
2580  *
2581  *****************************************************************************/
2582
2583 Typename:  Array opt_array_bounds
2584                                 {
2585                                         $$ = $1;
2586                                         $$->arrayBounds = $2;
2587
2588                                         /* Is this the name of a complex type? If so, implement
2589                                          * it as a set.
2590                                          */
2591                                         if (!strcmp(saved_relname, $$->name))
2592                                                 /* This attr is the same type as the relation
2593                                                  * being defined. The classic example: create
2594                                                  * emp(name=text,mgr=emp)
2595                                                  */
2596                                                 $$->setof = TRUE;
2597                                         else if (typeTypeRelid(typenameType($$->name)) != InvalidOid)
2598                                                  /* (Eventually add in here that the set can only
2599                                                   * contain one element.)
2600                                                   */
2601                                                 $$->setof = TRUE;
2602                                         else
2603                                                 $$->setof = FALSE;
2604                                 }
2605                 | Character
2606                 | SETOF Array
2607                                 {
2608                                         $$ = $2;
2609                                         $$->setof = TRUE;
2610                                 }
2611                 ;
2612
2613 Array:  Generic
2614                 | Datetime
2615                 | Numeric
2616                 ;
2617
2618 Generic:  generic
2619                                 {
2620                                         $$ = makeNode(TypeName);
2621                                         $$->name = xlateSqlType($1);
2622                                 }
2623                 ;
2624
2625 generic:  Id                                                                    { $$ = $1; }
2626                 | TYPE_P                                                                { $$ = xlateSqlType("type"); }
2627                 | DOUBLE PRECISION                                              { $$ = xlateSqlType("float8"); }
2628                 ;
2629
2630 /* SQL92 numeric data types
2631  * Check FLOAT() precision limits assuming IEEE floating types.
2632  * Provide rudimentary DECIMAL() and NUMERIC() implementations
2633  *  by checking parameters and making sure they match what is possible with INTEGER.
2634  * - thomas 1997-09-18
2635  */
2636 Numeric:  FLOAT opt_float
2637                                 {
2638                                         $$ = makeNode(TypeName);
2639                                         $$->name = xlateSqlType($2);
2640                                 }
2641                 | DECIMAL opt_decimal
2642                                 {
2643                                         $$ = makeNode(TypeName);
2644                                         $$->name = xlateSqlType("integer");
2645                                 }
2646                 | NUMERIC opt_numeric
2647                                 {
2648                                         $$ = makeNode(TypeName);
2649                                         $$->name = xlateSqlType("integer");
2650                                 }
2651                 ;
2652
2653 opt_float:  '(' Iconst ')'
2654                                 {
2655                                         if ($2 < 1)
2656                                                 elog(WARN,"precision for FLOAT must be at least 1",NULL);
2657                                         else if ($2 < 7)
2658                                                 $$ = xlateSqlType("float4");
2659                                         else if ($2 < 16)
2660                                                 $$ = xlateSqlType("float8");
2661                                         else
2662                                                 elog(WARN,"precision for FLOAT must be less than 16",NULL);
2663                                 }
2664                 | /*EMPTY*/
2665                                 {
2666                                         $$ = xlateSqlType("float8");
2667                                 }
2668                 ;
2669
2670 opt_numeric:  '(' Iconst ',' Iconst ')'
2671                                 {
2672                                         if ($2 != 9)
2673                                                 elog(WARN,"NUMERIC precision %d must be 9",$2);
2674                                         if ($4 != 0)
2675                                                 elog(WARN,"NUMERIC scale %d must be zero",$4);
2676                                 }
2677                 | '(' Iconst ')'
2678                                 {
2679                                         if ($2 != 9)
2680                                                 elog(WARN,"NUMERIC precision %d must be 9",$2);
2681                                 }
2682                 | /*EMPTY*/
2683                                 {
2684                                         $$ = NULL;
2685                                 }
2686                 ;
2687
2688 opt_decimal:  '(' Iconst ',' Iconst ')'
2689                                 {
2690                                         if ($2 > 9)
2691                                                 elog(WARN,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2692                                         if ($4 != 0)
2693                                                 elog(WARN,"DECIMAL scale %d must be zero",$4);
2694                                         $$ = NULL;
2695                                 }
2696                 | '(' Iconst ')'
2697                                 {
2698                                         if ($2 > 9)
2699                                                 elog(WARN,"DECIMAL precision %d exceeds implementation limit of 9",$2);
2700                                         $$ = NULL;
2701                                 }
2702                 | /*EMPTY*/
2703                                 {
2704                                         $$ = NULL;
2705                                 }
2706                 ;
2707
2708 /* SQL92 character data types
2709  * The following implements CHAR() and VARCHAR().
2710  * We do it here instead of the 'Generic' production
2711  * because we don't want to allow arrays of VARCHAR().
2712  * I haven't thought about whether that will work or not.
2713  *                                                              - ay 6/95
2714  */
2715 Character:  character '(' Iconst ')'
2716                                 {
2717                                         $$ = makeNode(TypeName);
2718                                         if (!strcasecmp($1, "char"))
2719                                                 $$->name = xlateSqlType("bpchar");
2720                                         else if (!strcasecmp($1, "varchar"))
2721                                                 $$->name = xlateSqlType("varchar");
2722                                         else
2723                                                 yyerror("parse error");
2724                                         if ($3 < 1)
2725                                                 elog(WARN,"length for '%s' type must be at least 1",$1);
2726                                         else if ($3 > 4096)
2727                                                 /* we can store a char() of length up to the size
2728                                                  * of a page (8KB) - page headers and friends but
2729                                                  * just to be safe here...      - ay 6/95
2730                                                  * XXX note this hardcoded limit - thomas 1997-07-13
2731                                                  */
2732                                                 elog(WARN,"length for type '%s' cannot exceed 4096",$1);
2733
2734                                         /* we actually implement this sort of like a varlen, so
2735                                          * the first 4 bytes is the length. (the difference
2736                                          * between this and "text" is that we blank-pad and
2737                                          * truncate where necessary
2738                                          */
2739                                         $$->typlen = VARHDRSZ + $3;
2740                                 }
2741                 | character
2742                                 {
2743                                         $$ = makeNode(TypeName);
2744                                         $$->name = xlateSqlType($1);
2745                                 }
2746                 ;
2747
2748 character:  CHARACTER opt_varying opt_charset opt_collate
2749                                 {
2750                                         char *type, *c;
2751                                         if (($3 == NULL) || (strcasecmp($3, "sql_text") == 0)) {
2752                                                 if ($2) type = xlateSqlType("varchar");
2753                                                 else type = xlateSqlType("char");
2754                                         } else {
2755                                                 if ($2) {
2756                                                         c = palloc(strlen("var") + strlen($3) + 1);
2757                                                         strcpy(c, "var");
2758                                                         strcat(c, $3);
2759                                                         type = xlateSqlType(c);
2760                                                 } else {
2761                                                         type = xlateSqlType($3);
2762                                                 }
2763                                         };
2764                                         if ($4 != NULL)
2765                                         elog(WARN,"COLLATE %s not yet implemented",$4);
2766                                         $$ = type;
2767                                 }
2768                 | CHAR opt_varying                                              { $$ = xlateSqlType($2? "varchar": "char"); }
2769                 | VARCHAR                                                               { $$ = xlateSqlType("varchar"); }
2770                 | NATIONAL CHARACTER opt_varying                { $$ = xlateSqlType($3? "varchar": "char"); }
2771                 | NCHAR opt_varying                                             { $$ = xlateSqlType($2? "varchar": "char"); }
2772                 ;
2773
2774 opt_varying:  VARYING                                                   { $$ = TRUE; }
2775                 | /*EMPTY*/                                                             { $$ = FALSE; }
2776                 ;
2777
2778 opt_charset:  CHARACTER SET ColId                               { $$ = $3; }
2779                 | /*EMPTY*/                                                             { $$ = NULL; }
2780                 ;
2781
2782 opt_collate:  COLLATE ColId                                             { $$ = $2; }
2783                 | /*EMPTY*/                                                             { $$ = NULL; }
2784                 ;
2785
2786 Datetime:  datetime
2787                                 {
2788                                         $$ = makeNode(TypeName);
2789                                         $$->name = xlateSqlType($1);
2790                                 }
2791                 | TIMESTAMP opt_timezone
2792                                 {
2793                                         $$ = makeNode(TypeName);
2794                                         $$->name = xlateSqlType("timestamp");
2795                                         $$->timezone = $2;
2796                                 }
2797                 | TIME
2798                                 {
2799                                         $$ = makeNode(TypeName);
2800                                         $$->name = xlateSqlType("time");
2801                                 }
2802                 | INTERVAL opt_interval
2803                                 {
2804                                         $$ = makeNode(TypeName);
2805                                         $$->name = xlateSqlType("interval");
2806                                 }
2807                 ;
2808
2809 datetime:  YEAR_P                                                               { $$ = "year"; }
2810                 | MONTH_P                                                               { $$ = "month"; }
2811                 | DAY_P                                                                 { $$ = "day"; }
2812                 | HOUR_P                                                                { $$ = "hour"; }
2813                 | MINUTE_P                                                              { $$ = "minute"; }
2814                 | SECOND_P                                                              { $$ = "second"; }
2815                 ;
2816
2817 opt_timezone:  WITH TIME ZONE                                   { $$ = TRUE; }
2818                 | /*EMPTY*/                                                             { $$ = FALSE; }
2819                 ;
2820
2821 opt_interval:  datetime                                                 { $$ = lcons($1, NIL); }
2822                 | YEAR_P TO MONTH_P                                             { $$ = NIL; }
2823                 | DAY_P TO HOUR_P                                               { $$ = NIL; }
2824                 | DAY_P TO MINUTE_P                                             { $$ = NIL; }
2825                 | DAY_P TO SECOND_P                                             { $$ = NIL; }
2826                 | HOUR_P TO MINUTE_P                                    { $$ = NIL; }
2827                 | HOUR_P TO SECOND_P                                    { $$ = NIL; }
2828                 | /*EMPTY*/                                                             { $$ = NIL; }
2829                 ;
2830
2831
2832 /*****************************************************************************
2833  *
2834  *      expression grammar, still needs some cleanup
2835  *
2836  *****************************************************************************/
2837
2838 a_expr_or_null:  a_expr
2839                                 { $$ = $1; }
2840                 | NULL_P
2841                                 {
2842                                         A_Const *n = makeNode(A_Const);
2843                                         n->val.type = T_Null;
2844                                         $$ = (Node *)n;
2845                                 }
2846                 ;
2847
2848 /* Expressions using row descriptors
2849  * Define row_descriptor to allow yacc to break the reduce/reduce conflict
2850  *  with singleton expressions.
2851  */
2852 row_expr: '(' row_descriptor ')' IN '(' SubSelect ')'
2853                                 {
2854                                         $$ = NULL;
2855                                 }
2856                 | '(' row_descriptor ')' NOT IN '(' SubSelect ')'
2857                                 {
2858                                         $$ = NULL;
2859                                 }
2860                 | '(' row_descriptor ')' '=' '(' row_descriptor ')'
2861                                 {
2862                                         $$ = makeRowExpr("=", $2, $6);
2863                                 }
2864                 | '(' row_descriptor ')' '<' '(' row_descriptor ')'
2865                                 {
2866                                         $$ = makeRowExpr("<", $2, $6);
2867                                 }
2868                 | '(' row_descriptor ')' '>' '(' row_descriptor ')'
2869                                 {
2870                                         $$ = makeRowExpr("<", $2, $6);
2871                                 }
2872                 | '(' row_descriptor ')' Op '(' row_descriptor ')'
2873                                 {
2874                                         $$ = makeRowExpr($4, $2, $6);
2875                                 }
2876                 ;
2877
2878 row_descriptor:  row_list ',' a_expr
2879                                 {
2880                                         $$ = lappend($1, $3);
2881                                 }
2882                 ;
2883
2884 row_list:  row_list ',' a_expr
2885                                 {
2886                                         $$ = lappend($1, $3);
2887                                 }
2888                 | a_expr
2889                                 {
2890                                         $$ = lcons($1, NIL);
2891                                 }
2892                 ;
2893
2894 a_expr:  attr opt_indirection
2895                                 {
2896                                         $1->indirection = $2;
2897                                         $$ = (Node *)$1;
2898                                 }
2899                 | row_expr
2900                                 {       $$ = $1;  }
2901                 | AexprConst
2902                                 {       $$ = $1;  }
2903                 | '-' a_expr %prec UMINUS
2904                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
2905                 | a_expr '+' a_expr
2906                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
2907                 | a_expr '-' a_expr
2908                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
2909                 | a_expr '/' a_expr
2910                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
2911                 | a_expr '*' a_expr
2912                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
2913                 | a_expr '<' a_expr
2914                                 {       $$ = makeA_Expr(OP, "<", $1, $3); }
2915                 | a_expr '>' a_expr
2916                                 {       $$ = makeA_Expr(OP, ">", $1, $3); }
2917                 | a_expr '=' a_expr
2918                                 {       $$ = makeA_Expr(OP, "=", $1, $3); }
2919                 | ':' a_expr
2920                                 {       $$ = makeA_Expr(OP, ":", NULL, $2); }
2921                 | ';' a_expr
2922                                 {       $$ = makeA_Expr(OP, ";", NULL, $2); }
2923                 | '|' a_expr
2924                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
2925                 | a_expr TYPECAST Typename
2926                                 {
2927                                         $$ = (Node *)$1;
2928                                         /* AexprConst can be either A_Const or ParamNo */
2929                                         if (nodeTag($1) == T_A_Const) {
2930                                                 ((A_Const *)$1)->typename = $3;
2931                                         } else if (nodeTag($1) == T_Param) {
2932                                                 ((ParamNo *)$1)->typename = $3;
2933                                         /* otherwise, try to transform to a function call */
2934                                         } else {
2935                                                 FuncCall *n = makeNode(FuncCall);
2936                                                 n->funcname = $3->name;
2937                                                 n->args = lcons($1,NIL);
2938                                                 $$ = (Node *)n;
2939                                         }
2940                                 }
2941                 | CAST a_expr AS Typename
2942                                 {
2943                                         $$ = (Node *)$2;
2944                                         /* AexprConst can be either A_Const or ParamNo */
2945                                         if (nodeTag($2) == T_A_Const) {
2946                                                 ((A_Const *)$2)->typename = $4;
2947                                         } else if (nodeTag($2) == T_Param) {
2948                                                 ((ParamNo *)$2)->typename = $4;
2949                                         /* otherwise, try to transform to a function call */
2950                                         } else {
2951                                                 FuncCall *n = makeNode(FuncCall);
2952                                                 n->funcname = $4->name;
2953                                                 n->args = lcons($2,NIL);
2954                                                 $$ = (Node *)n;
2955                                         }
2956                                 }
2957                 | '(' a_expr_or_null ')'
2958                                 {       $$ = $2; }
2959                 | a_expr Op a_expr
2960                                 {       $$ = makeIndexable($2,$1,$3);   }
2961                 | a_expr LIKE a_expr
2962                                 {       $$ = makeIndexable("~~", $1, $3); }
2963                 | a_expr NOT LIKE a_expr
2964                                 {       $$ = makeA_Expr(OP, "!~~", $1, $4); }
2965                 | Op a_expr
2966                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
2967                 | a_expr Op
2968                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
2969                 | ColId
2970                                 {
2971                                         /* could be a column name or a relation_name */
2972                                         Ident *n = makeNode(Ident);
2973                                         n->name = $1;
2974                                         n->indirection = NULL;
2975                                         $$ = (Node *)n;
2976                                 }
2977                 | name '(' '*' ')'
2978                                 {
2979                                         /* cheap hack for aggregate (eg. count) */
2980                                         FuncCall *n = makeNode(FuncCall);
2981                                         A_Const *star = makeNode(A_Const);
2982
2983                                         star->val.type = T_String;
2984                                         star->val.val.str = "";
2985                                         n->funcname = $1;
2986                                         n->args = lcons(star, NIL);
2987                                         $$ = (Node *)n;
2988                                 }
2989                 | name '(' ')'
2990                                 {
2991                                         FuncCall *n = makeNode(FuncCall);
2992                                         n->funcname = $1;
2993                                         n->args = NIL;
2994                                         $$ = (Node *)n;
2995                                 }
2996                 | name '(' expr_list ')'
2997                                 {
2998                                         FuncCall *n = makeNode(FuncCall);
2999                                         n->funcname = $1;
3000                                         n->args = $3;
3001                                         $$ = (Node *)n;
3002                                 }
3003                 | CURRENT_DATE
3004                                 {
3005                                         A_Const *n = makeNode(A_Const);
3006                                         TypeName *t = makeNode(TypeName);
3007
3008                                         n->val.type = T_String;
3009                                         n->val.val.str = "now";
3010                                         n->typename = t;
3011
3012                                         t->name = xlateSqlType("date");
3013                                         t->setof = FALSE;
3014
3015                                         $$ = (Node *)n;
3016                                 }
3017                 | CURRENT_TIME
3018                                 {
3019                                         A_Const *n = makeNode(A_Const);
3020                                         TypeName *t = makeNode(TypeName);
3021
3022                                         n->val.type = T_String;
3023                                         n->val.val.str = "now";
3024                                         n->typename = t;
3025
3026                                         t->name = xlateSqlType("time");
3027                                         t->setof = FALSE;
3028
3029                                         $$ = (Node *)n;
3030                                 }
3031                 | CURRENT_TIME '(' Iconst ')'
3032                                 {
3033                                         FuncCall *n = makeNode(FuncCall);
3034                                         A_Const *s = makeNode(A_Const);
3035                                         TypeName *t = makeNode(TypeName);
3036
3037                                         n->funcname = xlateSqlType("time");
3038                                         n->args = lcons(s, NIL);
3039
3040                                         s->val.type = T_String;
3041                                         s->val.val.str = "now";
3042                                         s->typename = t;
3043
3044                                         t->name = xlateSqlType("time");
3045                                         t->setof = FALSE;
3046
3047                                         if ($3 != 0)
3048                                                 elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",$3);
3049
3050                                         $$ = (Node *)n;
3051                                 }
3052                 | CURRENT_TIMESTAMP
3053                                 {
3054                                         A_Const *n = makeNode(A_Const);
3055                                         TypeName *t = makeNode(TypeName);
3056
3057                                         n->val.type = T_String;
3058                                         n->val.val.str = "now";
3059                                         n->typename = t;
3060
3061                                         t->name = xlateSqlType("timestamp");
3062                                         t->setof = FALSE;
3063
3064                                         $$ = (Node *)n;
3065                                 }
3066                 | CURRENT_TIMESTAMP '(' Iconst ')'
3067                                 {
3068                                         FuncCall *n = makeNode(FuncCall);
3069                                         A_Const *s = makeNode(A_Const);
3070                                         TypeName *t = makeNode(TypeName);
3071
3072                                         n->funcname = xlateSqlType("timestamp");
3073                                         n->args = lcons(s, NIL);
3074
3075                                         s->val.type = T_String;
3076                                         s->val.val.str = "now";
3077                                         s->typename = t;
3078
3079                                         t->name = xlateSqlType("timestamp");
3080                                         t->setof = FALSE;
3081
3082                                         if ($3 != 0)
3083                                                 elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",$3);
3084
3085                                         $$ = (Node *)n;
3086                                 }
3087                 | CURRENT_USER
3088                                 {
3089                                         FuncCall *n = makeNode(FuncCall);
3090                                         n->funcname = "getpgusername";
3091                                         n->args = NIL;
3092                                         $$ = (Node *)n;
3093                                 }
3094                 /* We probably need to define an "exists" node,
3095                  *      since the optimizer could choose to find only one match.
3096                  * Perhaps the first implementation could just check for
3097                  *      count(*) > 0? - thomas 1997-07-19
3098                  */
3099                 | EXISTS '(' SubSelect ')'
3100                                 {
3101                                         elog(WARN,"EXISTS not yet implemented",NULL);
3102                                         $$ = $3;
3103                                 }
3104                 | EXTRACT '(' extract_list ')'
3105                                 {
3106                                         FuncCall *n = makeNode(FuncCall);
3107                                         n->funcname = "date_part";
3108                                         n->args = $3;
3109                                         $$ = (Node *)n;
3110                                 }
3111                 | POSITION '(' position_list ')'
3112                                 {
3113                                         FuncCall *n = makeNode(FuncCall);
3114                                         n->funcname = "strpos";
3115                                         n->args = $3;
3116                                         $$ = (Node *)n;
3117                                 }
3118                 | SUBSTRING '(' substr_list ')'
3119                                 {
3120                                         FuncCall *n = makeNode(FuncCall);
3121                                         n->funcname = "substr";
3122                                         n->args = $3;
3123                                         $$ = (Node *)n;
3124                                 }
3125                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3126                 | TRIM '(' BOTH trim_list ')'
3127                                 {
3128                                         FuncCall *n = makeNode(FuncCall);
3129                                         n->funcname = "btrim";
3130                                         n->args = $4;
3131                                         $$ = (Node *)n;
3132                                 }
3133                 | TRIM '(' LEADING trim_list ')'
3134                                 {
3135                                         FuncCall *n = makeNode(FuncCall);
3136                                         n->funcname = "ltrim";
3137                                         n->args = $4;
3138                                         $$ = (Node *)n;
3139                                 }
3140                 | TRIM '(' TRAILING trim_list ')'
3141                                 {
3142                                         FuncCall *n = makeNode(FuncCall);
3143                                         n->funcname = "rtrim";
3144                                         n->args = $4;
3145                                         $$ = (Node *)n;
3146                                 }
3147                 | TRIM '(' trim_list ')'
3148                                 {
3149                                         FuncCall *n = makeNode(FuncCall);
3150                                         n->funcname = "btrim";
3151                                         n->args = $3;
3152                                         $$ = (Node *)n;
3153                                 }
3154                 | a_expr ISNULL
3155                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3156                 | a_expr IS NULL_P
3157                                 {       $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
3158                 | a_expr NOTNULL
3159                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3160                 | a_expr IS NOT NULL_P
3161                                 {       $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
3162                 /* IS TRUE, IS FALSE, etc used to be function calls
3163                  *  but let's make them expressions to allow the optimizer
3164                  *  a chance to eliminate them if a_expr is a constant string.
3165                  * - thomas 1997-12-22
3166                  */
3167                 | a_expr IS TRUE_P
3168                                 {
3169                                         A_Const *n = makeNode(A_Const);
3170                                         n->val.type = T_String;
3171                                         n->val.val.str = "t";
3172                                         n->typename = makeNode(TypeName);
3173                                         n->typename->name = xlateSqlType("bool");
3174                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3175                                 }
3176                 | a_expr IS NOT FALSE_P
3177                                 {
3178                                         A_Const *n = makeNode(A_Const);
3179                                         n->val.type = T_String;
3180                                         n->val.val.str = "t";
3181                                         n->typename = makeNode(TypeName);
3182                                         n->typename->name = xlateSqlType("bool");
3183                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3184                                 }
3185                 | a_expr IS FALSE_P
3186                                 {
3187                                         A_Const *n = makeNode(A_Const);
3188                                         n->val.type = T_String;
3189                                         n->val.val.str = "f";
3190                                         n->typename = makeNode(TypeName);
3191                                         n->typename->name = xlateSqlType("bool");
3192                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3193                                 }
3194                 | a_expr IS NOT TRUE_P
3195                                 {
3196                                         A_Const *n = makeNode(A_Const);
3197                                         n->val.type = T_String;
3198                                         n->val.val.str = "f";
3199                                         n->typename = makeNode(TypeName);
3200                                         n->typename->name = xlateSqlType("bool");
3201                                         $$ = makeA_Expr(OP, "=", $1,(Node *)n);
3202                                 }
3203                 | a_expr BETWEEN AexprConst AND AexprConst
3204                                 {
3205                                         $$ = makeA_Expr(AND, NULL,
3206                                                 makeA_Expr(OP, ">=", $1, $3),
3207                                                 makeA_Expr(OP, "<=", $1, $5));
3208                                 }
3209                 | a_expr NOT BETWEEN AexprConst AND AexprConst
3210                                 {
3211                                         $$ = makeA_Expr(OR, NULL,
3212                                                 makeA_Expr(OP, "<", $1, $4),
3213                                                 makeA_Expr(OP, ">", $1, $6));
3214                                 }
3215                 | a_expr IN { saved_In_Expr = $1; } '(' in_expr ')'
3216                                 {       $$ = $5; }
3217                 | a_expr NOT IN { saved_In_Expr = $1; } '(' not_in_expr ')'
3218                                 {       $$ = $6; }
3219                 | a_expr AND a_expr
3220                                 {       $$ = makeA_Expr(AND, NULL, $1, $3); }
3221                 | a_expr OR a_expr
3222                                 {       $$ = makeA_Expr(OR, NULL, $1, $3); }
3223                 | NOT a_expr
3224                                 {       $$ = makeA_Expr(NOT, NULL, NULL, $2); }
3225                 ;
3226
3227 opt_indirection:  '[' a_expr ']' opt_indirection
3228                                 {
3229                                         A_Indices *ai = makeNode(A_Indices);
3230                                         ai->lidx = NULL;
3231                                         ai->uidx = $2;
3232                                         $$ = lcons(ai, $4);
3233                                 }
3234                 | '[' a_expr ':' a_expr ']' opt_indirection
3235                                 {
3236                                         A_Indices *ai = makeNode(A_Indices);
3237                                         ai->lidx = $2;
3238                                         ai->uidx = $4;
3239                                         $$ = lcons(ai, $6);
3240                                 }
3241                 | /* EMPTY */
3242                                 {       $$ = NIL; }
3243                 ;
3244
3245 expr_list:  a_expr_or_null
3246                                 { $$ = lcons($1, NIL); }
3247                 | expr_list ',' a_expr_or_null
3248                                 { $$ = lappend($1, $3); }
3249                 | expr_list USING a_expr
3250                                 { $$ = lappend($1, $3); }
3251                 ;
3252
3253 extract_list:  datetime FROM a_expr
3254                                 {
3255                                         A_Const *n = makeNode(A_Const);
3256                                         n->val.type = T_String;
3257                                         n->val.val.str = $1;
3258                                         $$ = lappend(lcons((Node *)n,NIL), $3);
3259                                 }
3260                 | /* EMPTY */
3261                                 {       $$ = NIL; }
3262                 ;
3263
3264 position_list:  position_expr IN position_expr
3265                                 {       $$ = makeList($3, $1, -1); }
3266                 | /* EMPTY */
3267                                 {       $$ = NIL; }
3268                 ;
3269
3270 position_expr:  attr opt_indirection
3271                                 {
3272                                         $1->indirection = $2;
3273                                         $$ = (Node *)$1;
3274                                 }
3275                 | AexprConst
3276                                 {       $$ = $1;  }
3277                 | '-' position_expr %prec UMINUS
3278                                 {       $$ = makeA_Expr(OP, "-", NULL, $2); }
3279                 | position_expr '+' position_expr
3280                                 {       $$ = makeA_Expr(OP, "+", $1, $3); }
3281                 | position_expr '-' position_expr
3282                                 {       $$ = makeA_Expr(OP, "-", $1, $3); }
3283                 | position_expr '/' position_expr
3284                                 {       $$ = makeA_Expr(OP, "/", $1, $3); }
3285                 | position_expr '*' position_expr
3286                                 {       $$ = makeA_Expr(OP, "*", $1, $3); }
3287                 | '|' position_expr
3288                                 {       $$ = makeA_Expr(OP, "|", NULL, $2); }
3289                 | position_expr TYPECAST Typename
3290                                 {
3291                                         $$ = (Node *)$1;
3292                                         /* AexprConst can be either A_Const or ParamNo */
3293                                         if (nodeTag($1) == T_A_Const) {
3294                                                 ((A_Const *)$1)->typename = $3;
3295                                         } else if (nodeTag($1) == T_Param) {
3296                                                 ((ParamNo *)$1)->typename = $3;
3297                                         /* otherwise, try to transform to a function call */
3298                                         } else {
3299                                                 FuncCall *n = makeNode(FuncCall);
3300                                                 n->funcname = $3->name;
3301                                                 n->args = lcons($1,NIL);
3302                                                 $$ = (Node *)n;
3303                                         }
3304                                 }
3305                 | CAST position_expr AS Typename
3306                                 {
3307                                         $$ = (Node *)$2;
3308                                         /* AexprConst can be either A_Const or ParamNo */
3309                                         if (nodeTag($2) == T_A_Const) {
3310                                                 ((A_Const *)$2)->typename = $4;
3311                                         } else if (nodeTag($2) == T_Param) {
3312                                                 ((ParamNo *)$2)->typename = $4;
3313                                         /* otherwise, try to transform to a function call */
3314                                         } else {
3315                                                 FuncCall *n = makeNode(FuncCall);
3316                                                 n->funcname = $4->name;
3317                                                 n->args = lcons($2,NIL);
3318                                                 $$ = (Node *)n;
3319                                         }
3320                                 }
3321                 | '(' position_expr ')'
3322                                 {       $$ = $2; }
3323                 | position_expr Op position_expr
3324                                 {       $$ = makeA_Expr(OP, $2, $1, $3); }
3325                 | Op position_expr
3326                                 {       $$ = makeA_Expr(OP, $1, NULL, $2); }
3327                 | position_expr Op
3328                                 {       $$ = makeA_Expr(OP, $2, $1, NULL); }
3329                 | ColId
3330                                 {
3331                                         /* could be a column name or a relation_name */
3332                                         Ident *n = makeNode(Ident);
3333                                         n->name = $1;
3334                                         n->indirection = NULL;
3335                                         $$ = (Node *)n;
3336                                 }
3337                 | name '(' ')'
3338                                 {
3339                                         FuncCall *n = makeNode(FuncCall);
3340                                         n->funcname = $1;
3341                                         n->args = NIL;
3342                                         $$ = (Node *)n;
3343                                 }
3344                 | name '(' expr_list ')'
3345                                 {
3346                                         FuncCall *n = makeNode(FuncCall);
3347                                         n->funcname = $1;
3348                                         n->args = $3;
3349                                         $$ = (Node *)n;
3350                                 }
3351                 | POSITION '(' position_list ')'
3352                                 {
3353                                         FuncCall *n = makeNode(FuncCall);
3354                                         n->funcname = "strpos";
3355                                         n->args = $3;
3356                                         $$ = (Node *)n;
3357                                 }
3358                 | SUBSTRING '(' substr_list ')'
3359                                 {
3360                                         FuncCall *n = makeNode(FuncCall);
3361                                         n->funcname = "substr";
3362                                         n->args = $3;
3363                                         $$ = (Node *)n;
3364                                 }
3365                 /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
3366                 | TRIM '(' BOTH trim_list ')'
3367                                 {
3368                                         FuncCall *n = makeNode(FuncCall);
3369                                         n->funcname = "btrim";
3370                                         n->args = $4;
3371                                         $$ = (Node *)n;
3372                                 }
3373                 | TRIM '(' LEADING trim_list ')'
3374                                 {
3375                                         FuncCall *n = makeNode(FuncCall);
3376                                         n->funcname = "ltrim";
3377                                         n->args = $4;
3378                                         $$ = (Node *)n;
3379                                 }
3380                 | TRIM '(' TRAILING trim_list ')'
3381                                 {
3382                                         FuncCall *n = makeNode(FuncCall);
3383                                         n->funcname = "rtrim";
3384                                         n->args = $4;
3385                                         $$ = (Node *)n;
3386                                 }
3387                 | TRIM '(' trim_list ')'
3388                                 {
3389                                         FuncCall *n = makeNode(FuncCall);
3390                                         n->funcname = "btrim";
3391                                         n->args = $3;
3392                                         $$ = (Node *)n;
3393                                 }
3394                 ;
3395
3396 substr_list:  expr_list substr_from substr_for
3397                                 {
3398                                         $$ = nconc(nconc($1,$2),$3);
3399                                 }
3400                 | /* EMPTY */
3401                                 {       $$ = NIL; }
3402                 ;
3403
3404 substr_from:  FROM expr_list
3405                                 {       $$ = $2; }
3406                 | /* EMPTY */
3407                                 {
3408                                         A_Const *n = makeNode(A_Const);
3409                                         n->val.type = T_Integer;
3410                                         n->val.val.ival = 1;
3411                                         $$ = lcons((Node *)n,NIL);
3412                                 }
3413                 ;
3414
3415 substr_for:  FOR expr_list
3416                                 {       $$ = $2; }
3417                 | /* EMPTY */
3418                                 {       $$ = NIL; }
3419                 ;
3420
3421 trim_list:  a_expr FROM expr_list
3422                                 { $$ = lappend($3, $1); }
3423                 | FROM expr_list
3424                                 { $$ = $2; }
3425                 | expr_list
3426                                 { $$ = $1; }
3427                 ;
3428
3429 in_expr:  SubSelect
3430                                 {
3431                                         elog(WARN,"IN (SUBSELECT) not yet implemented",NULL);
3432                                         $$ = $1;
3433                                 }
3434                 | in_expr_nodes
3435                                 {       $$ = $1; }
3436                 ;
3437
3438 in_expr_nodes:  AexprConst
3439                                 {       $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
3440                 | in_expr_nodes ',' AexprConst
3441                                 {       $$ = makeA_Expr(OR, NULL, $1,
3442                                                 makeA_Expr(OP, "=", saved_In_Expr, $3));
3443                                 }
3444                 ;
3445
3446 not_in_expr:  SubSelect
3447                                 {
3448                                         elog(WARN,"NOT IN (SUBSELECT) not yet implemented",NULL);
3449                                         $$ = $1;
3450                                 }
3451                 | not_in_expr_nodes
3452                                 {       $$ = $1; }
3453                 ;
3454
3455 not_in_expr_nodes:  AexprConst
3456                                 {       $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
3457                 | not_in_expr_nodes ',' AexprConst
3458                                 {       $$ = makeA_Expr(AND, NULL, $1,
3459                                                 makeA_Expr(OP, "<>", saved_In_Expr, $3));
3460                                 }
3461                 ;
3462
3463 attr:  relation_name '.' attrs
3464                                 {
3465                                         $$ = makeNode(Attr);
3466                                         $$->relname = $1;
3467                                         $$->paramNo = NULL;
3468                                         $$->attrs = $3;
3469                                         $$->indirection = NULL;
3470                                 }
3471                 | ParamNo '.' attrs
3472                                 {
3473                                         $$ = makeNode(Attr);
3474                                         $$->relname = NULL;
3475                                         $$->paramNo = $1;
3476                                         $$->attrs = $3;
3477                                         $$->indirection = NULL;
3478                                 }
3479                 ;
3480
3481 attrs:    attr_name
3482                                 { $$ = lcons(makeString($1), NIL); }
3483                 | attrs '.' attr_name
3484                                 { $$ = lappend($1, makeString($3)); }
3485                 | attrs '.' '*'
3486                                 { $$ = lappend($1, makeString("*")); }
3487                 ;
3488
3489
3490 /*****************************************************************************
3491  *
3492  *      target lists
3493  *
3494  *****************************************************************************/
3495
3496 res_target_list:  res_target_list ',' res_target_el
3497                                 {       $$ = lappend($1,$3);  }
3498                 | res_target_el
3499                                 {       $$ = lcons($1, NIL);  }
3500                 | '*'
3501                                 {
3502                                         ResTarget *rt = makeNode(ResTarget);
3503                                         Attr *att = makeNode(Attr);
3504                                         att->relname = "*";
3505                                         att->paramNo = NULL;
3506                                         att->attrs = NULL;
3507                                         att->indirection = NIL;
3508                                         rt->name = NULL;
3509                                         rt->indirection = NULL;
3510                                         rt->val = (Node *)att;
3511                                         $$ = lcons(rt, NIL);
3512                                 }
3513                 ;
3514
3515 res_target_el:  ColId opt_indirection '=' a_expr_or_null
3516                                 {
3517                                         $$ = makeNode(ResTarget);
3518                                         $$->name = $1;
3519                                         $$->indirection = $2;
3520                                         $$->val = (Node *)$4;
3521                                 }
3522                 | attr opt_indirection
3523                                 {
3524                                         $$ = makeNode(ResTarget);
3525                                         $$->name = NULL;
3526                                         $$->indirection = $2;
3527                                         $$->val = (Node *)$1;
3528                                 }
3529                 | relation_name '.' '*'
3530                                 {
3531                                         Attr *att = makeNode(Attr);
3532                                         att->relname = $1;
3533                                         att->paramNo = NULL;
3534                                         att->attrs = lcons(makeString("*"), NIL);
3535                                         att->indirection = NIL;
3536                                         $$ = makeNode(ResTarget);
3537                                         $$->name = NULL;
3538                                         $$->indirection = NULL;
3539                                         $$->val = (Node *)att;
3540                                 }
3541                 ;
3542
3543 /*
3544 ** target list for select.
3545 ** should get rid of the other but is still needed by the defunct retrieve into
3546 ** and update (uses a subset)
3547 */
3548 res_target_list2:  res_target_list2 ',' res_target_el2
3549                                 {       $$ = lappend($1, $3);  }
3550                 | res_target_el2
3551                                 {       $$ = lcons($1, NIL);  }
3552                 ;
3553
3554 /* AS is not optional because shift/red conflict with unary ops */
3555 res_target_el2:  a_expr_or_null AS ColLabel
3556                                 {
3557                                         $$ = makeNode(ResTarget);
3558                                         $$->name = $3;
3559                                         $$->indirection = NULL;
3560                                         $$->val = (Node *)$1;
3561                                 }
3562                 | a_expr_or_null
3563                                 {
3564                                         $$ = makeNode(ResTarget);
3565                                         $$->name = NULL;
3566                                         $$->indirection = NULL;
3567                                         $$->val = (Node *)$1;
3568                                 }
3569                 | relation_name '.' '*'
3570                                 {
3571                                         Attr *att = makeNode(Attr);
3572                                         att->relname = $1;
3573                                         att->paramNo = NULL;
3574                                         att->attrs = lcons(makeString("*"), NIL);
3575                                         att->indirection = NIL;
3576                                         $$ = makeNode(ResTarget);
3577                                         $$->name = NULL;
3578                                         $$->indirection = NULL;
3579                                         $$->val = (Node *)att;
3580                                 }
3581                 | '*'
3582                                 {
3583                                         Attr *att = makeNode(Attr);
3584                                         att->relname = "*";
3585                                         att->paramNo = NULL;
3586                                         att->attrs = NULL;
3587                                         att->indirection = NIL;
3588                                         $$ = makeNode(ResTarget);
3589                                         $$->name = NULL;
3590                                         $$->indirection = NULL;
3591                                         $$->val = (Node *)att;
3592                                 }
3593                 ;
3594
3595 opt_id:  ColId                                                                  { $$ = $1; }
3596                 | /* EMPTY */                                                   { $$ = NULL; }
3597                 ;
3598
3599 relation_name:  SpecialRuleRelation
3600                                 {
3601                                         $$ = $1;
3602                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3603                                 }
3604                 | ColId
3605                                 {
3606                                         /* disallow refs to variable system tables */
3607                                         if (strcmp(LogRelationName, $1) == 0
3608                                            || strcmp(VariableRelationName, $1) == 0)
3609                                                 elog(WARN,"%s cannot be accessed by users",$1);
3610                                         else
3611                                                 $$ = $1;
3612                                         StrNCpy(saved_relname, $1, NAMEDATALEN);
3613                                 }
3614                 ;
3615
3616 database_name:                  ColId                   { $$ = $1; };
3617 access_method:                  Id                              { $$ = $1; };
3618 attr_name:                              ColId                   { $$ = $1; };
3619 class:                                  Id                              { $$ = $1; };
3620 index_name:                             ColId                   { $$ = $1; };
3621
3622 /* Functions
3623  * Include date/time keywords as SQL92 extension.
3624  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3625  */
3626 name:                                   ColId                   { $$ = $1; };
3627
3628 file_name:                              Sconst                  { $$ = $1; };
3629 recipe_name:                    Id                              { $$ = $1; };
3630
3631 /* Constants
3632  * Include TRUE/FALSE for SQL3 support. - thomas 1997-10-24
3633  */
3634 AexprConst:  Iconst
3635                                 {
3636                                         A_Const *n = makeNode(A_Const);
3637                                         n->val.type = T_Integer;
3638                                         n->val.val.ival = $1;
3639                                         $$ = (Node *)n;
3640                                 }
3641                 | FCONST
3642                                 {
3643                                         A_Const *n = makeNode(A_Const);
3644                                         n->val.type = T_Float;
3645                                         n->val.val.dval = $1;
3646                                         $$ = (Node *)n;
3647                                 }
3648                 | Sconst
3649                                 {
3650                                         A_Const *n = makeNode(A_Const);
3651                                         n->val.type = T_String;
3652                                         n->val.val.str = $1;
3653                                         $$ = (Node *)n;
3654                                 }
3655                 | Typename Sconst
3656                                 {
3657                                         A_Const *n = makeNode(A_Const);
3658                                         n->typename = $1;
3659                                         n->val.type = T_String;
3660                                         n->val.val.str = $2;
3661                                         $$ = (Node *)n;
3662                                 }
3663                 | ParamNo
3664                                 {       $$ = (Node *)$1;  }
3665                 | TRUE_P
3666                                 {
3667                                         A_Const *n = makeNode(A_Const);
3668                                         n->val.type = T_String;
3669                                         n->val.val.str = "t";
3670                                         n->typename = makeNode(TypeName);
3671                                         n->typename->name = xlateSqlType("bool");
3672                                         $$ = (Node *)n;
3673                                 }
3674                 | FALSE_P
3675                                 {
3676                                         A_Const *n = makeNode(A_Const);
3677                                         n->val.type = T_String;
3678                                         n->val.val.str = "f";
3679                                         n->typename = makeNode(TypeName);
3680                                         n->typename->name = xlateSqlType("bool");
3681                                         $$ = (Node *)n;
3682                                 }
3683                 ;
3684
3685 ParamNo:  PARAM
3686                                 {
3687                                         $$ = makeNode(ParamNo);
3688                                         $$->number = $1;
3689                                 }
3690                 ;
3691
3692 NumConst:  Iconst                                               { $$ = makeInteger($1); }
3693                 | FCONST                                                { $$ = makeFloat($1); }
3694                 ;
3695
3696 Iconst:  ICONST                                                 { $$ = $1; };
3697 Sconst:  SCONST                                                 { $$ = $1; };
3698
3699 /* Column and type identifier
3700  * Does not include explicit datetime types
3701  *  since these must be decoupled in Typename syntax.
3702  * Use ColId for most identifiers. - thomas 1997-10-21
3703  */
3704 Id:  IDENT                                                              { $$ = $1; };
3705
3706 /* Column identifier
3707  * Include date/time keywords as SQL92 extension.
3708  * Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
3709  * Add other keywords. Note that as the syntax expands,
3710  *  some of these keywords will have to be removed from this
3711  *  list due to shift/reduce conflicts in yacc. If so, move
3712  *  down to the ColLabel entity. - thomas 1997-11-06
3713  */
3714 ColId:  Id                                                              { $$ = $1; }
3715                 | datetime                                              { $$ = $1; }
3716                 | ACTION                                                { $$ = "action"; }
3717                 | DATABASE                                              { $$ = "database"; }
3718                 | DELIMITERS                                    { $$ = "delimiters"; }
3719                 | FUNCTION                                              { $$ = "function"; }
3720                 | INDEX                                                 { $$ = "index"; }
3721                 | KEY                                                   { $$ = "key"; }
3722                 | LANGUAGE                                              { $$ = "language"; }
3723                 | LOCATION                                              { $$ = "location"; }
3724                 | MATCH                                                 { $$ = "match"; }
3725                 | OPERATOR                                              { $$ = "operator"; }
3726                 | OPTION                                                { $$ = "option"; }
3727                 | PRIVILEGES                                    { $$ = "privileges"; }
3728                 | RECIPE                                                { $$ = "recipe"; }
3729                 | TIME                                                  { $$ = "time"; }
3730                 | TRIGGER                                               { $$ = "trigger"; }
3731                 | TYPE_P                                                { $$ = "type"; }
3732                 | VERSION                                               { $$ = "version"; }
3733                 | ZONE                                                  { $$ = "zone"; }
3734                 ;
3735
3736 /* Column label
3737  * Allowed labels in "AS" clauses.
3738  * Include TRUE/FALSE SQL3 reserved words for Postgres backward
3739  *  compatibility. Cannot allow this for column names since the
3740  *  syntax would not distinguish between the constant value and
3741  *  a column name. - thomas 1997-10-24
3742  * Add other keywords to this list. Note that they appear here
3743  *  rather than in ColId if there was a shift/reduce conflict
3744  *  when used as a full identifier. - thomas 1997-11-06
3745  */
3746 ColLabel:  ColId                                                { $$ = $1; }
3747                 | ARCHIVE                                               { $$ = "archive"; }
3748                 | CLUSTER                                               { $$ = "cluster"; }
3749                 | CONSTRAINT                                    { $$ = "constraint"; }
3750                 | CROSS                                                 { $$ = "cross"; }
3751                 | FOREIGN                                               { $$ = "foreign"; }
3752                 | GROUP                                                 { $$ = "group"; }
3753                 | LOAD                                                  { $$ = "load"; }
3754                 | ORDER                                                 { $$ = "order"; }
3755                 | POSITION                                              { $$ = "position"; }
3756                 | PRECISION                                             { $$ = "precision"; }
3757                 | TABLE                                                 { $$ = "table"; }
3758                 | TRANSACTION                                   { $$ = "transaction"; }
3759                 | TRUE_P                                                { $$ = "true"; }
3760                 | FALSE_P                                               { $$ = "false"; }
3761                 ;
3762
3763 SpecialRuleRelation:  CURRENT
3764                                 {
3765                                         if (QueryIsRule)
3766                                                 $$ = "*CURRENT*";
3767                                         else
3768                                                 elog(WARN,"CURRENT used in non-rule query",NULL);
3769                                 }
3770                 | NEW
3771                                 {
3772                                         if (QueryIsRule)
3773                                                 $$ = "*NEW*";
3774                                         else
3775                                                 elog(WARN,"NEW used in non-rule query",NULL);
3776                                 }
3777                 ;
3778
3779 %%
3780
3781 static Node *
3782 makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
3783 {
3784         A_Expr *a = makeNode(A_Expr);
3785         a->oper = oper;
3786         a->opname = opname;
3787         a->lexpr = lexpr;
3788         a->rexpr = rexpr;
3789         return (Node *)a;
3790 }
3791
3792 /* makeRowExpr()
3793  * Generate separate operator nodes for a single row descriptor expression.
3794  * Perhaps this should go deeper in the parser someday... - thomas 1997-12-22
3795  */
3796 static Node *
3797 makeRowExpr(char *opr, List *largs, List *rargs)
3798 {
3799         Node *expr = NULL;
3800         Node *larg, *rarg;
3801
3802         if (length(largs) != length(rargs))
3803                 elog(WARN,"Unequal number of entries in row expression",NULL);
3804
3805         if (lnext(largs) != NIL)
3806                 expr = makeRowExpr(opr,lnext(largs),lnext(rargs));
3807
3808         larg = lfirst(largs);
3809         rarg = lfirst(rargs);
3810
3811         if ((strcmp(opr, "=") == 0)
3812          || (strcmp(opr, "<") == 0)
3813          || (strcmp(opr, "<=") == 0)
3814          || (strcmp(opr, ">") == 0)
3815          || (strcmp(opr, ">=") == 0))
3816         {
3817                 if (expr == NULL)
3818                         expr = makeA_Expr(OP, opr, larg, rarg);
3819                 else
3820                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3821         }
3822         else if (strcmp(opr, "<>") == 0)
3823         {
3824                 if (expr == NULL)
3825                         expr = makeA_Expr(OP, opr, larg, rarg);
3826                 else
3827                         expr = makeA_Expr(OR, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3828         }
3829         else
3830         {
3831                 elog(WARN,"Operator '%s' not implemented for row expressions",opr);
3832         }
3833
3834 #if FALSE
3835         while ((largs != NIL) && (rargs != NIL))
3836         {
3837                 larg = lfirst(largs);
3838                 rarg = lfirst(rargs);
3839
3840                 if (expr == NULL)
3841                         expr = makeA_Expr(OP, opr, larg, rarg);
3842                 else
3843                         expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
3844
3845                 largs = lnext(largs);
3846                 rargs = lnext(rargs);
3847         }
3848         pprint(expr);
3849 #endif
3850
3851         return expr;
3852 } /* makeRowExpr() */
3853
3854 void
3855 mapTargetColumns(List *src, List *dst)
3856 {
3857         ColumnDef *s;
3858         ResTarget *d;
3859
3860         if (length(src) != length(dst))
3861                 elog(WARN,"CREATE TABLE/AS SELECT has mismatched column count",NULL);
3862
3863         while ((src != NIL) && (dst != NIL))
3864         {
3865                 s = (ColumnDef *)lfirst(src);
3866                 d = (ResTarget *)lfirst(dst);
3867
3868                 d->name = s->colname;
3869
3870                 src = lnext(src);
3871                 dst = lnext(dst);
3872         }
3873
3874         return;
3875 } /* mapTargetColumns() */
3876
3877 static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr)
3878 {
3879         Node *result = NULL;
3880
3881         /* we do this so indexes can be used */
3882         if (strcmp(opname,"~") == 0 ||
3883                 strcmp(opname,"~*") == 0)
3884         {
3885                 if (nodeTag(rexpr) == T_A_Const &&
3886                    ((A_Const *)rexpr)->val.type == T_String &&
3887                    ((A_Const *)rexpr)->val.val.str[0] == '^')
3888                 {
3889                         A_Const *n = (A_Const *)rexpr;
3890                         char *match_least = palloc(strlen(n->val.val.str)+2);
3891                         char *match_most = palloc(strlen(n->val.val.str)+2);
3892                         int pos, match_pos=0;
3893
3894                         /* skip leading ^ */
3895                         for (pos = 1; n->val.val.str[pos]; pos++)
3896                         {
3897                                 if (n->val.val.str[pos] == '.' ||
3898                                         n->val.val.str[pos] == '?' ||
3899                                         n->val.val.str[pos] == '*' ||
3900                                         n->val.val.str[pos] == '[' ||
3901                                         n->val.val.str[pos] == '$' ||
3902                                         (strcmp(opname,"~*") == 0 && isalpha(n->val.val.str[pos])))
3903                                 break;
3904                         if (n->val.val.str[pos] == '\\')
3905                                         pos++;
3906                                 match_least[match_pos] = n->val.val.str[pos];
3907                                 match_most[match_pos++] = n->val.val.str[pos];
3908                         }
3909
3910                         if (match_pos != 0)
3911                         {
3912                                 A_Const *least = makeNode(A_Const);
3913                                 A_Const *most = makeNode(A_Const);
3914
3915                                 /* make strings to be used in index use */
3916                                 match_least[match_pos] = '\0';
3917                                 match_most[match_pos] = '\377';
3918                                 match_most[match_pos+1] = '\0';
3919                                 least->val.type = T_String;
3920                                 least->val.val.str = match_least;
3921                                 most->val.type = T_String;
3922                                 most->val.val.str = match_most;
3923                                 result = makeA_Expr(AND, NULL,
3924                                                 makeA_Expr(OP, "~", lexpr, rexpr),
3925                                                 makeA_Expr(AND, NULL,
3926                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3927                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3928                         }
3929                 }
3930         }
3931         else if (strcmp(opname,"~~") == 0)
3932         {
3933                 if (nodeTag(rexpr) == T_A_Const &&
3934                    ((A_Const *)rexpr)->val.type == T_String)
3935                 {
3936                         A_Const *n = (A_Const *)rexpr;
3937                         char *match_least = palloc(strlen(n->val.val.str)+2);
3938                         char *match_most = palloc(strlen(n->val.val.str)+2);
3939                         int pos, match_pos=0;
3940
3941                         for (pos = 0; n->val.val.str[pos]; pos++)
3942                         {
3943                                 if ((n->val.val.str[pos] == '%' &&
3944                                          n->val.val.str[pos+1] != '%') ||
3945                                     (n->val.val.str[pos] == '_' &&
3946                                  n->val.val.str[pos+1] != '_'))
3947                                 break;
3948                         if (n->val.val.str[pos] == '%' ||
3949                                     n->val.val.str[pos] == '_' ||
3950                                     n->val.val.str[pos] == '\\')
3951                                         pos++;
3952                                 match_least[match_pos] = n->val.val.str[pos];
3953                                 match_most[match_pos++] = n->val.val.str[pos];
3954                         }
3955
3956                         if (match_pos != 0)
3957                         {
3958                                 A_Const *least = makeNode(A_Const);
3959                                 A_Const *most = makeNode(A_Const);
3960
3961                                 /* make strings to be used in index use */
3962                                 match_least[match_pos] = '\0';
3963                                 match_most[match_pos] = '\377';
3964                                 match_most[match_pos+1] = '\0';
3965                                 least->val.type = T_String;
3966                                 least->val.val.str = match_least;
3967                                 most->val.type = T_String;
3968                                 most->val.val.str = match_most;
3969                                 result = makeA_Expr(AND, NULL,
3970                                                 makeA_Expr(OP, "~~", lexpr, rexpr),
3971                                                 makeA_Expr(AND, NULL,
3972                                                         makeA_Expr(OP, ">=", lexpr, (Node *)least),
3973                                                         makeA_Expr(OP, "<=", lexpr, (Node *)most)));
3974                         }
3975                 }
3976         }
3977
3978         if (result == NULL)
3979                 result = makeA_Expr(OP, opname, lexpr, rexpr);
3980         return result;
3981 } /* makeIndexable() */
3982
3983
3984 /* xlateSqlType()
3985  * Convert alternate type names to internal Postgres types.
3986  * Do not convert "float", since that is handled elsewhere
3987  *  for FLOAT(p) syntax.
3988  */
3989 static char *
3990 xlateSqlType(char *name)
3991 {
3992         if (!strcasecmp(name,"int")
3993          || !strcasecmp(name,"integer"))
3994                 return "int4";
3995         else if (!strcasecmp(name, "smallint"))
3996                 return "int2";
3997         else if (!strcasecmp(name, "real"))
3998                 return "float8";
3999         else if (!strcasecmp(name, "interval"))
4000                 return "timespan";
4001         else if (!strcasecmp(name, "boolean"))
4002                 return "bool";
4003         else
4004                 return name;
4005 } /* xlateSqlName() */
4006
4007
4008 void parser_init(Oid *typev, int nargs)
4009 {
4010         QueryIsRule = FALSE;
4011         saved_relname[0]= '\0';
4012         saved_In_Expr = NULL;
4013
4014         param_type_init(typev, nargs);
4015 }
4016
4017
4018 /* FlattenStringList()
4019  * Traverse list of string nodes and convert to a single string.
4020  * Used for reconstructing string form of complex expressions.
4021  *
4022  * Allocate at least one byte for terminator.
4023  */
4024 static char *
4025 FlattenStringList(List *list)
4026 {
4027         List *l;
4028         Value *v;
4029         char *s;
4030         char *sp;
4031         int nlist, len = 0;
4032
4033         nlist = length(list);
4034         l = list;
4035         while(l != NIL) {
4036                 v = (Value *)lfirst(l);
4037                 sp = v->val.str;
4038                 l = lnext(l);
4039                 len += strlen(sp);
4040         };
4041         len += nlist;
4042
4043         s = (char*) palloc(len+1);
4044         *s = '\0';
4045
4046         l = list;
4047         while(l != NIL) {
4048                 v = (Value *)lfirst(l);
4049                 sp = v->val.str;
4050                 l = lnext(l);
4051                 strcat(s,sp);
4052                 if (l != NIL) strcat(s," ");
4053         };
4054         *(s+len) = '\0';
4055
4056 #ifdef PARSEDEBUG
4057 printf( "flattened string is \"%s\"\n", s);
4058 #endif
4059
4060         return(s);
4061 } /* FlattenStringList() */
4062
4063
4064 /* makeConstantList()
4065  * Convert constant value node into string node.
4066  */
4067 static List *
4068 makeConstantList( A_Const *n)
4069 {
4070         char *defval = NULL;
4071         if (nodeTag(n) != T_A_Const) {
4072                 elog(WARN,"Cannot handle non-constant parameter",NULL);
4073
4074         } else if (n->val.type == T_Float) {
4075                 defval = (char*) palloc(20+1);
4076                 sprintf( defval, "%g", n->val.val.dval);
4077
4078         } else if (n->val.type == T_Integer) {
4079                 defval = (char*) palloc(20+1);
4080                 sprintf( defval, "%ld", n->val.val.ival);
4081
4082         } else if (n->val.type == T_String) {
4083                 defval = (char*) palloc(strlen( ((A_Const *) n)->val.val.str) + 3);
4084                 strcpy( defval, "'");
4085                 strcat( defval, ((A_Const *) n)->val.val.str);
4086                 strcat( defval, "'");
4087
4088         } else {
4089                 elog(WARN,"Internal error in makeConstantList(): cannot encode node",NULL);
4090         };
4091
4092 #ifdef PARSEDEBUG
4093 printf( "AexprConst argument is \"%s\"\n", defval);
4094 #endif
4095
4096         return( lcons( makeString(defval), NIL));
4097 } /* makeConstantList() */
4098
4099
4100 /* fmtId()
4101  * Check input string for non-lowercase/non-numeric characters.
4102  * Returns either input string or input surrounded by double quotes.
4103  */
4104 static char *
4105 fmtId(char *rawid)
4106 {
4107         static char *cp;
4108
4109         for (cp = rawid; *cp != '\0'; cp++)
4110                 if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;
4111
4112         if (*cp != '\0') {
4113                 cp = palloc(strlen(rawid)+1);
4114                 strcpy(cp,"\"");
4115                 strcat(cp,rawid);
4116                 strcat(cp,"\"");
4117         } else {
4118                 cp = rawid;
4119         };
4120
4121 #ifdef PARSEDEBUG
4122 printf("fmtId- %sconvert %s to %s\n", ((cp == rawid)? "do not ": ""), rawid, cp);
4123 #endif
4124
4125         return(cp);
4126 }
4127
4128 /*
4129  * param_type_init()
4130  *
4131  * keep enough information around fill out the type of param nodes
4132  * used in postquel functions
4133  */
4134 static void
4135 param_type_init(Oid *typev, int nargs)
4136 {
4137         pfunc_num_args = nargs;
4138         param_type_info = typev;
4139 }
4140
4141 Oid param_type(int t)
4142 {
4143         if ((t > pfunc_num_args) || (t == 0))
4144                 return InvalidOid;
4145         return param_type_info[t - 1];
4146 }