/*-------------------------------------------------------------------------
*
* gram.y--
- * POSTGRES SQL YACC rules/actions
+ * POSTGRES SQL YACC rules/actions
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.42 1997/09/04 13:24:25 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.43 1997/09/08 03:19:57 momjian Exp $
*
* HISTORY
- * AUTHOR DATE MAJOR EVENT
- * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion
- * Andrew Yu Oct, 1994 lispy code conversion
+ * AUTHOR DATE MAJOR EVENT
+ * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion
+ * Andrew Yu Oct, 1994 lispy code conversion
*
* NOTES
- * CAPITALS are used to represent terminal symbols.
- * non-capitals are used to represent non-terminals.
+ * CAPITALS are used to represent terminal symbols.
+ * non-capitals are used to represent non-terminals.
*
- * if you use list, make sure the datum is a node so that the printing
- * routines work
+ * if you use list, make sure the datum is a node so that the printing
+ * routines work
*
* WARNING
- * sometimes we assign constants to makeStrings. Make sure we don't free
- * those.
+ * sometimes we assign constants to makeStrings. Make sure we don't free
+ * those.
*
*-------------------------------------------------------------------------
*/
extern char *parseString;
/*
- * If you need access to certain yacc-generated variables and find that
+ * If you need access to certain yacc-generated variables and find that
* they're static by default, uncomment the next line. (this is not a
* problem, yet.)
*/
%}
-%union {
- double dval;
- int ival;
- char chr;
- char *str;
- bool boolean;
- List *list;
- Node *node;
- Value *value;
-
- Attr *attr;
-
- ColumnDef *coldef;
- ConstraintDef *constrdef;
- TypeName *typnam;
- DefElem *defelt;
- ParamString *param;
- SortGroupBy *sortgroupby;
- IndexElem *ielem;
- RangeVar *range;
- RelExpr *relexp;
- TimeRange *trange;
- A_Indices *aind;
- ResTarget *target;
- ParamNo *paramno;
-
- VersionStmt *vstmt;
- DefineStmt *dstmt;
- PurgeStmt *pstmt;
- RuleStmt *rstmt;
- AppendStmt *astmt;
+%union
+{
+ double dval;
+ int ival;
+ char chr;
+ char *str;
+ bool boolean;
+ List *list;
+ Node *node;
+ Value *value;
+
+ Attr *attr;
+
+ ColumnDef *coldef;
+ ConstraintDef *constrdef;
+ TypeName *typnam;
+ DefElem *defelt;
+ ParamString *param;
+ SortGroupBy *sortgroupby;
+ IndexElem *ielem;
+ RangeVar *range;
+ RelExpr *relexp;
+ TimeRange *trange;
+ A_Indices *aind;
+ ResTarget *target;
+ ParamNo *paramno;
+
+ VersionStmt *vstmt;
+ DefineStmt *dstmt;
+ PurgeStmt *pstmt;
+ RuleStmt *rstmt;
+ AppendStmt *astmt;
}
%type <node> stmt,
- AddAttrStmt, ClosePortalStmt,
- CopyStmt, CreateStmt, CreateSeqStmt, DefineStmt, DestroyStmt,
- ExtendStmt, FetchStmt, GrantStmt, CreateTrigStmt, DropTrigStmt,
- IndexStmt, MoveStmt, ListenStmt, OptimizableStmt,
- ProcedureStmt, PurgeStmt,
- RecipeStmt, RemoveAggrStmt, RemoveOperStmt, RemoveFuncStmt, RemoveStmt,
- RenameStmt, RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
- CreatedbStmt, DestroydbStmt, VacuumStmt, RetrieveStmt, CursorStmt,
- ReplaceStmt, AppendStmt, NotifyStmt, DeleteStmt, ClusterStmt,
- ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt
-
-%type <str> txname
+ AddAttrStmt, ClosePortalStmt,
+ CopyStmt, CreateStmt, CreateSeqStmt, DefineStmt, DestroyStmt,
+ ExtendStmt, FetchStmt, GrantStmt, CreateTrigStmt, DropTrigStmt,
+ IndexStmt, MoveStmt, ListenStmt, OptimizableStmt,
+ ProcedureStmt, PurgeStmt,
+ RecipeStmt, RemoveAggrStmt, RemoveOperStmt, RemoveFuncStmt, RemoveStmt,
+ RenameStmt, RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
+ CreatedbStmt, DestroydbStmt, VacuumStmt, RetrieveStmt, CursorStmt,
+ ReplaceStmt, AppendStmt, NotifyStmt, DeleteStmt, ClusterStmt,
+ ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt
+
+%type <str> txname
%type <node> SubSelect
-%type <str> join_clause, join_type, join_outer, join_spec
-%type <boolean> join_qual, TriggerActionTime, TriggerForSpec
+%type <str> join_clause, join_type, join_outer, join_spec
+%type <boolean> join_qual, TriggerActionTime, TriggerForSpec
-%type <str> datetime, TriggerEvents, TriggerFuncArg
+%type <str> datetime, TriggerEvents, TriggerFuncArg
-%type <str> relation_name, copy_file_name, copy_delimiter, def_name,
- database_name, access_method_clause, access_method, attr_name,
- class, index_name, name, file_name, recipe_name,
- var_name, aggr_argtype, OptDefault
+%type <str> relation_name, copy_file_name, copy_delimiter, def_name,
+ database_name, access_method_clause, access_method, attr_name,
+ class, index_name, name, file_name, recipe_name,
+ var_name, aggr_argtype, OptDefault
-%type <constrdef> ConstraintElem, ConstraintDef
+%type <constrdef> ConstraintElem, ConstraintDef
-%type <str> opt_id, opt_portal_name,
- before_clause, after_clause, all_Op, MathOp, opt_name, opt_unique,
- result, OptUseOp, opt_class, opt_range_start, opt_range_end,
- SpecialRuleRelation
+%type <str> opt_id, opt_portal_name,
+ before_clause, after_clause, all_Op, MathOp, opt_name, opt_unique,
+ result, OptUseOp, opt_class, opt_range_start, opt_range_end,
+ SpecialRuleRelation
-%type <str> privileges, operation_commalist, grantee
-%type <chr> operation, TriggerOneEvent
+%type <str> privileges, operation_commalist, grantee
+%type <chr> operation, TriggerOneEvent
%type <list> stmtblock, stmtmulti,
- relation_name_list, OptTableElementList, tableElementList,
- OptInherit, OptConstraint, ConstraintList, definition,
- opt_with, def_args, def_name_list, func_argtypes,
- oper_argtypes, OptStmtList, OptStmtBlock, OptStmtMulti,
- opt_column_list, columnList, opt_va_list, va_list,
- sort_clause, sortby_list, index_params, index_list, name_list,
- from_clause, from_list, opt_array_bounds, nest_array_bounds,
- expr_list, default_expr_list, attrs, res_target_list, res_target_list2,
- def_list, opt_indirection, group_clause, groupby_list, TriggerFuncArgs
+ relation_name_list, OptTableElementList, tableElementList,
+ OptInherit, OptConstraint, ConstraintList, definition,
+ opt_with, def_args, def_name_list, func_argtypes,
+ oper_argtypes, OptStmtList, OptStmtBlock, OptStmtMulti,
+ opt_column_list, columnList, opt_va_list, va_list,
+ sort_clause, sortby_list, index_params, index_list, name_list,
+ from_clause, from_list, opt_array_bounds, nest_array_bounds,
+ expr_list, default_expr_list, attrs, res_target_list, res_target_list2,
+ def_list, opt_indirection, group_clause, groupby_list, TriggerFuncArgs
%type <list> union_clause, select_list
%type <list> join_list
-%type <sortgroupby> join_using
+%type <sortgroupby> join_using
%type <list> extract_list, position_list
%type <list> substr_list, substr_from, substr_for, trim_list
%type <list> interval_opts
-%type <boolean> opt_inh_star, opt_binary, opt_instead, opt_with_col, opt_with_copy,
- index_opt_unique, opt_verbose, opt_analyze, opt_null
+%type <boolean> opt_inh_star, opt_binary, opt_instead, opt_with_col, opt_with_copy,
+ index_opt_unique, opt_verbose, opt_analyze, opt_null
%type <ival> copy_dirn, archive_type, OptArchiveType, OptArchiveLocation,
- def_type, opt_direction, remove_type, opt_column, event
+ def_type, opt_direction, remove_type, opt_column, event
%type <ival> OptLocation, opt_move_where, fetch_how_many
%type <coldef> columnDef
%type <defelt> def_elem
%type <node> def_arg, columnElem, where_clause,
- a_expr, a_expr_or_null, AexprConst,
- default_expr, default_expr_or_null,
- in_expr_nodes, not_in_expr_nodes,
- having_clause
+ a_expr, a_expr_or_null, AexprConst,
+ default_expr, default_expr_or_null,
+ in_expr_nodes, not_in_expr_nodes,
+ having_clause
%type <value> NumConst
%type <attr> event_object, attr
-%type <sortgroupby> groupby
-%type <sortgroupby> sortby
+%type <sortgroupby> groupby
+%type <sortgroupby> sortby
%type <ielem> index_elem, func_index
%type <range> from_val
%type <relexp> relation_expr
%type <trange> time_range
%type <target> res_target_el, res_target_el2
-%type <paramno> ParamNo
+%type <paramno> ParamNo
%type <ival> Iconst
-%type <str> Sconst
-%type <str> Id, date, var_value, zone_value
-%type <str> ColId
+%type <str> Sconst
+%type <str> Id, date, var_value, zone_value
+%type <str> ColId
/*
* If you make any token changes, remember to:
- * - use "yacc -d" and update parse.h
- * - update the keyword table in parser/keywords.c
+ * - use "yacc -d" and update parse.h
+ * - update the keyword table in parser/keywords.c
*/
/* Keywords */
%token ABORT_TRANS, ACL, ADD, AFTER, AGGREGATE, ALL, ALTER, ANALYZE,
- AND, APPEND, ARCHIVE, ARCH_STORE, AS, ASC,
- BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BINARY, BOTH, BY,
- CAST, CHANGE, CHECK, CLOSE, CLUSTER, COLUMN, COMMIT, CONSTRAINT, COPY, CREATE, CROSS,
- CURRENT, CURSOR, DATABASE, DAYINTERVAL, DECLARE, DEFAULT, DELETE, DELIMITERS, DESC,
- DISTINCT, DO, DROP, END_TRANS, EXISTS, EXTEND, EXTRACT,
- FETCH, FOR, FORWARD, FROM, FULL, FUNCTION, GRANT, GROUP,
- HAVING, HEAVY, HOURINTERVAL,
- IN, INDEX, INHERITS, INNERJOIN, INSERT, INSTEAD, INTERVAL, INTO, IS, ISNULL,
- JOIN, LANGUAGE, LEADING, LEFT, LIGHT, LISTEN, LOAD, LOCAL,
- MERGE, MINUTEINTERVAL, MONTHINTERVAL, MOVE,
- NATURAL, NEW, NONE, NOT, NOTHING, NOTIFY, NOTNULL,
- OIDS, ON, OPERATOR, OPTION, OR, ORDER, OUTERJOIN,
- PNULL, POSITION, PRIVILEGES, PROCEDURE, PUBLIC, PURGE, P_TYPE,
- RENAME, REPLACE, RESET, RETRIEVE, RETURNS, REVOKE, RIGHT, ROLLBACK, RULE,
- SECONDINTERVAL, SELECT, SET, SETOF, SHOW, STDIN, STDOUT, STORE, SUBSTRING,
- TABLE, TIME, TO, TRAILING, TRANSACTION, TRIGGER, TRIM,
- UNION, UNIQUE, UPDATE, USING, VACUUM, VALUES,
- VERBOSE, VERSION, VIEW, WHERE, WITH, WORK, YEARINTERVAL, ZONE
+ AND, APPEND, ARCHIVE, ARCH_STORE, AS, ASC,
+ BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BINARY, BOTH, BY,
+ CAST, CHANGE, CHECK, CLOSE, CLUSTER, COLUMN, COMMIT, CONSTRAINT, COPY, CREATE, CROSS,
+ CURRENT, CURSOR, DATABASE, DAYINTERVAL, DECLARE, DEFAULT, DELETE, DELIMITERS, DESC,
+ DISTINCT, DO, DROP, END_TRANS, EXISTS, EXTEND, EXTRACT,
+ FETCH, FOR, FORWARD, FROM, FULL, FUNCTION, GRANT, GROUP,
+ HAVING, HEAVY, HOURINTERVAL,
+ IN, INDEX, INHERITS, INNERJOIN, INSERT, INSTEAD, INTERVAL, INTO, IS, ISNULL,
+ JOIN, LANGUAGE, LEADING, LEFT, LIGHT, LISTEN, LOAD, LOCAL,
+ MERGE, MINUTEINTERVAL, MONTHINTERVAL, MOVE,
+ NATURAL, NEW, NONE, NOT, NOTHING, NOTIFY, NOTNULL,
+ OIDS, ON, OPERATOR, OPTION, OR, ORDER, OUTERJOIN,
+ PNULL, POSITION, PRIVILEGES, PROCEDURE, PUBLIC, PURGE, P_TYPE,
+ RENAME, REPLACE, RESET, RETRIEVE, RETURNS, REVOKE, RIGHT, ROLLBACK, RULE,
+ SECONDINTERVAL, SELECT, SET, SETOF, SHOW, STDIN, STDOUT, STORE, SUBSTRING,
+ TABLE, TIME, TO, TRAILING, TRANSACTION, TRIGGER, TRIM,
+ UNION, UNIQUE, UPDATE, USING, VACUUM, VALUES,
+ VERBOSE, VERSION, VIEW, WHERE, WITH, WORK, YEARINTERVAL, ZONE
%token EXECUTE, RECIPE, EXPLAIN, LIKE, SEQUENCE
/* Special keywords, not in the query language - see the "lex" file */
%token <dval> FCONST
/* these are not real. they are here so that they gets generated as #define's*/
-%token OP
+%token OP
/* precedence */
%left OR
%nonassoc IS
%left '+' '-'
%left '*' '/'
-%left '|' /* this is the relation union op, not logical or */
-%right ':' /* Unary Operators */
-%left ';' /* end of statement or natural log */
+%left '|' /* this is the relation union op, not logical or */
+%right ':' /* Unary Operators */
+%left ';' /* end of statement or natural log */
%nonassoc '<' '>'
-%right UMINUS
+%right UMINUS
%left '.'
%left '[' ']'
%nonassoc TYPECAST
%%
stmtblock: stmtmulti
- { parsetree = $1; }
- | stmt
- { parsetree = lcons($1,NIL); }
- ;
+ { parsetree = $1; }
+ | stmt
+ { parsetree = lcons($1,NIL); }
+ ;
stmtmulti: stmtmulti stmt ';'
- { $$ = lappend($1, $2); }
- | stmtmulti stmt
- { $$ = lappend($1, $2); }
- | stmt ';'
- { $$ = lcons($1,NIL); }
- ;
+ { $$ = lappend($1, $2); }
+ | stmtmulti stmt
+ { $$ = lappend($1, $2); }
+ | stmt ';'
+ { $$ = lcons($1,NIL); }
+ ;
stmt : AddAttrStmt
- | ClosePortalStmt
- | CopyStmt
- | CreateStmt
- | CreateSeqStmt
- | CreateTrigStmt
- | ClusterStmt
- | DefineStmt
- | DestroyStmt
- | DropTrigStmt
- | ExtendStmt
- | ExplainStmt
- | FetchStmt
- | GrantStmt
- | IndexStmt
- | MoveStmt
- | ListenStmt
- | ProcedureStmt
- | PurgeStmt
- | RecipeStmt
- | RemoveAggrStmt
- | RemoveOperStmt
- | RemoveFuncStmt
- | RemoveStmt
- | RenameStmt
- | RevokeStmt
- | OptimizableStmt
- | RuleStmt
- | TransactionStmt
- | ViewStmt
- | LoadStmt
- | CreatedbStmt
- | DestroydbStmt
- | VacuumStmt
- | VariableSetStmt
- | VariableShowStmt
- | VariableResetStmt
- ;
+ | ClosePortalStmt
+ | CopyStmt
+ | CreateStmt
+ | CreateSeqStmt
+ | CreateTrigStmt
+ | ClusterStmt
+ | DefineStmt
+ | DestroyStmt
+ | DropTrigStmt
+ | ExtendStmt
+ | ExplainStmt
+ | FetchStmt
+ | GrantStmt
+ | IndexStmt
+ | MoveStmt
+ | ListenStmt
+ | ProcedureStmt
+ | PurgeStmt
+ | RecipeStmt
+ | RemoveAggrStmt
+ | RemoveOperStmt
+ | RemoveFuncStmt
+ | RemoveStmt
+ | RenameStmt
+ | RevokeStmt
+ | OptimizableStmt
+ | RuleStmt
+ | TransactionStmt
+ | ViewStmt
+ | LoadStmt
+ | CreatedbStmt
+ | DestroydbStmt
+ | VacuumStmt
+ | VariableSetStmt
+ | VariableShowStmt
+ | VariableResetStmt
+ ;
/*****************************************************************************
*
* Set PG internal variable
- * SET var_name TO 'var_value'
+ * SET var_name TO 'var_value'
*
*****************************************************************************/
VariableSetStmt: SET var_name TO var_value
- {
- VariableSetStmt *n = makeNode(VariableSetStmt);
- n->name = $2;
- n->value = $4;
- $$ = (Node *) n;
- }
- | SET var_name '=' var_value
- {
- VariableSetStmt *n = makeNode(VariableSetStmt);
- n->name = $2;
- n->value = $4;
- $$ = (Node *) n;
- }
- | SET TIME ZONE zone_value
- {
- VariableSetStmt *n = makeNode(VariableSetStmt);
- n->name = "timezone";
- n->value = $4;
- $$ = (Node *) n;
- }
- ;
-
-var_value: Sconst { $$ = $1; }
- ;
-
-zone_value: Sconst { $$ = $1; }
- | LOCAL { $$ = NULL; }
- ;
+ {
+ VariableSetStmt *n = makeNode(VariableSetStmt);
+ n->name = $2;
+ n->value = $4;
+ $$ = (Node *) n;
+ }
+ | SET var_name '=' var_value
+ {
+ VariableSetStmt *n = makeNode(VariableSetStmt);
+ n->name = $2;
+ n->value = $4;
+ $$ = (Node *) n;
+ }
+ | SET TIME ZONE zone_value
+ {
+ VariableSetStmt *n = makeNode(VariableSetStmt);
+ n->name = "timezone";
+ n->value = $4;
+ $$ = (Node *) n;
+ }
+ ;
+
+var_value: Sconst { $$ = $1; }
+ ;
+
+zone_value: Sconst { $$ = $1; }
+ | LOCAL { $$ = NULL; }
+ ;
VariableShowStmt: SHOW var_name
- {
- VariableShowStmt *n = makeNode(VariableShowStmt);
- n->name = $2;
- $$ = (Node *) n;
- }
- ;
-
-VariableResetStmt: RESET var_name
- {
- VariableResetStmt *n = makeNode(VariableResetStmt);
- n->name = $2;
- $$ = (Node *) n;
- }
- ;
+ {
+ VariableShowStmt *n = makeNode(VariableShowStmt);
+ n->name = $2;
+ $$ = (Node *) n;
+ }
+ ;
+
+VariableResetStmt: RESET var_name
+ {
+ VariableResetStmt *n = makeNode(VariableResetStmt);
+ n->name = $2;
+ $$ = (Node *) n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY :
- * addattr ( attr1 = type1 .. attrn = typen ) to <relname> [*]
+ * QUERY :
+ * addattr ( attr1 = type1 .. attrn = typen ) to <relname> [*]
*
*****************************************************************************/
AddAttrStmt: ALTER TABLE relation_name opt_inh_star ADD COLUMN columnDef
- {
- AddAttrStmt *n = makeNode(AddAttrStmt);
- n->relname = $3;
- n->inh = $4;
- n->colDef = $7;
- $$ = (Node *)n;
- }
- ;
+ {
+ AddAttrStmt *n = makeNode(AddAttrStmt);
+ n->relname = $3;
+ n->inh = $4;
+ n->colDef = $7;
+ $$ = (Node *)n;
+ }
+ ;
/* Column definition might include WITH TIME ZONE, but only for the data types
- * called out in SQL92 date/time definitions. So, check explicitly for "timestamp"
+ * called out in SQL92 date/time definitions. So, check explicitly for "timestamp"
* and "time". - thomas 1997-07-14
*/
-columnDef: Id Typename opt_with_col OptDefault opt_null
- {
- $$ = makeNode(ColumnDef);
- $$->colname = $1;
- $$->typename = $2;
- $$->typename->timezone = $3;
- $$->defval = $4;
- $$->is_not_null = $5;
- if ($$->typename->timezone
- && (strcasecmp($$->typename->name, "timestamp")
- && strcasecmp($$->typename->name, "time")))
- elog(NOTICE,"%s does not use WITH TIME ZONE",$$->typename->name);
- }
- ;
+columnDef: Id Typename opt_with_col OptDefault opt_null
+ {
+ $$ = makeNode(ColumnDef);
+ $$->colname = $1;
+ $$->typename = $2;
+ $$->typename->timezone = $3;
+ $$->defval = $4;
+ $$->is_not_null = $5;
+ if ($$->typename->timezone
+ && (strcasecmp($$->typename->name, "timestamp")
+ && strcasecmp($$->typename->name, "time")))
+ elog(NOTICE,"%s does not use WITH TIME ZONE",$$->typename->name);
+ }
+ ;
OptDefault: DEFAULT default_expr
- {
- int deflen = CurScanPosition() - DefaultStartPosition;
- char *defval;
-
- defval = (char*) palloc (deflen + 1);
- memcpy (defval,
- parseString + DefaultStartPosition,
- deflen);
- defval[deflen] = 0;
- $$ = defval;
- }
- | /*EMPTY*/ { $$ = NULL; }
- ;
+ {
+ int deflen = CurScanPosition() - DefaultStartPosition;
+ char *defval;
+
+ defval = (char*) palloc (deflen + 1);
+ memcpy (defval, parseString + DefaultStartPosition,
+ deflen);
+ defval[deflen] = 0;
+ $$ = defval;
+ }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
default_expr_or_null: default_expr
- { $$ = $1;}
- | Pnull
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_Null;
- $$ = (Node *)n;
- }
+ { $$ = $1;}
+ | Pnull
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Null;
+ $$ = (Node *)n;
+ }
default_expr: AexprConst
- {
- if (nodeTag($1) != T_A_Const)
- elog (WARN, "Cannot handle parameter in DEFAULT");
- $$ = $1;
- }
- | '-' default_expr %prec UMINUS
- { $$ = makeA_Expr(OP, "-", NULL, $2); }
- | default_expr '+' default_expr
- { $$ = makeA_Expr(OP, "+", $1, $3); }
- | default_expr '-' default_expr
- { $$ = makeA_Expr(OP, "-", $1, $3); }
- | default_expr '/' default_expr
- { $$ = makeA_Expr(OP, "/", $1, $3); }
- | default_expr '*' default_expr
- { $$ = makeA_Expr(OP, "*", $1, $3); }
- | default_expr '<' default_expr
- { $$ = makeA_Expr(OP, "<", $1, $3); }
- | default_expr '>' default_expr
- { $$ = makeA_Expr(OP, ">", $1, $3); }
- | default_expr '=' default_expr
- { $$ = makeA_Expr(OP, "=", $1, $3); }
- | ':' default_expr
- { $$ = makeA_Expr(OP, ":", NULL, $2); }
- | ';' default_expr
- { $$ = makeA_Expr(OP, ";", NULL, $2); }
- | '|' default_expr
- { $$ = makeA_Expr(OP, "|", NULL, $2); }
- | AexprConst TYPECAST Typename
- {
- /* AexprConst can be either A_Const or ParamNo */
- if (nodeTag($1) == T_A_Const) {
- ((A_Const *)$1)->typename = $3;
- }else {
- elog (WARN, "Cannot handle parameter in DEFAULT");
- }
- $$ = (Node *)$1;
- }
- | CAST AexprConst AS Typename
- {
- /* AexprConst can be either A_Const or ParamNo */
- if (nodeTag($2) == T_A_Const) {
- ((A_Const *)$2)->typename = $4;
- }else {
- elog (WARN, "Cannot handle parameter in DEFAULT");
- }
- $$ = (Node *)$2;
- }
- | '(' default_expr ')'
- { $$ = $2; }
- | default_expr Op default_expr
- { $$ = makeA_Expr(OP, $2, $1, $3); }
- | Op default_expr
- { $$ = makeA_Expr(OP, $1, NULL, $2); }
- | default_expr Op
- { $$ = makeA_Expr(OP, $2, $1, NULL); }
- | name '(' ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = $1;
- n->args = NIL;
- $$ = (Node *)n;
- }
- | name '(' default_expr_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = $1;
- n->args = $3;
- $$ = (Node *)n;
- }
- ;
+ {
+ if (nodeTag($1) != T_A_Const)
+ elog (WARN, "Cannot handle parameter in DEFAULT");
+ $$ = $1;
+ }
+ | '-' default_expr %prec UMINUS
+ { $$ = makeA_Expr(OP, "-", NULL, $2); }
+ | default_expr '+' default_expr
+ { $$ = makeA_Expr(OP, "+", $1, $3); }
+ | default_expr '-' default_expr
+ { $$ = makeA_Expr(OP, "-", $1, $3); }
+ | default_expr '/' default_expr
+ { $$ = makeA_Expr(OP, "/", $1, $3); }
+ | default_expr '*' default_expr
+ { $$ = makeA_Expr(OP, "*", $1, $3); }
+ | default_expr '<' default_expr
+ { $$ = makeA_Expr(OP, "<", $1, $3); }
+ | default_expr '>' default_expr
+ { $$ = makeA_Expr(OP, ">", $1, $3); }
+ | default_expr '=' default_expr
+ { $$ = makeA_Expr(OP, "=", $1, $3); }
+ | ':' default_expr
+ { $$ = makeA_Expr(OP, ":", NULL, $2); }
+ | ';' default_expr
+ { $$ = makeA_Expr(OP, ";", NULL, $2); }
+ | '|' default_expr
+ { $$ = makeA_Expr(OP, "|", NULL, $2); }
+ | AexprConst TYPECAST Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($1) == T_A_Const)
+ ((A_Const *)$1)->typename = $3;
+ else
+ elog (WARN, "Cannot handle parameter in DEFAULT");
+ $$ = (Node *)$1;
+ }
+ | CAST AexprConst AS Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($2) == T_A_Const)
+ ((A_Const *)$2)->typename = $4;
+ else
+ elog (WARN, "Cannot handle parameter in DEFAULT");
+ $$ = (Node *)$2;
+ }
+ | '(' default_expr ')'
+ { $$ = $2; }
+ | default_expr Op default_expr
+ { $$ = makeA_Expr(OP, $2, $1, $3); }
+ | Op default_expr
+ { $$ = makeA_Expr(OP, $1, NULL, $2); }
+ | default_expr Op
+ { $$ = makeA_Expr(OP, $2, $1, NULL); }
+ | name '(' ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = NIL;
+ $$ = (Node *)n;
+ }
+ | name '(' default_expr_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ ;
default_expr_list: default_expr_or_null
- { $$ = lcons($1, NIL); }
- | default_expr_list ',' default_expr_or_null
- { $$ = lappend($1, $3); }
- ;
-
-opt_null: NOT PNULL { $$ = true; }
- | NOTNULL { $$ = true; }
- | /* EMPTY */ { $$ = false; }
- ;
-
-opt_with_col: WITH TIME ZONE { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
- ;
+ { $$ = lcons($1, NIL); }
+ | default_expr_list ',' default_expr_or_null
+ { $$ = lappend($1, $3); }
+ ;
+
+opt_null: NOT PNULL { $$ = true; }
+ | NOTNULL { $$ = true; }
+ | /* EMPTY */ { $$ = false; }
+ ;
+
+opt_with_col: WITH TIME ZONE { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
/*****************************************************************************
*
- * QUERY :
- * close <optname>
+ * QUERY :
+ * close <optname>
*
*****************************************************************************/
ClosePortalStmt: CLOSE opt_id
- {
- ClosePortalStmt *n = makeNode(ClosePortalStmt);
- n->portalname = $2;
- $$ = (Node *)n;
- }
- ;
+ {
+ ClosePortalStmt *n = makeNode(ClosePortalStmt);
+ n->portalname = $2;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY :
- * COPY [BINARY] <relname> FROM/TO
- * [USING DELIMITERS <delimiter>]
+ * QUERY :
+ * COPY [BINARY] <relname> FROM/TO
+ * [USING DELIMITERS <delimiter>]
*
*****************************************************************************/
CopyStmt: COPY opt_binary relation_name opt_with_copy copy_dirn copy_file_name copy_delimiter
- {
- CopyStmt *n = makeNode(CopyStmt);
- n->binary = $2;
- n->relname = $3;
- n->oids = $4;
- n->direction = $5;
- n->filename = $6;
- n->delimiter = $7;
- $$ = (Node *)n;
- }
- ;
-
-copy_dirn: TO
- { $$ = TO; }
- | FROM
- { $$ = FROM; }
- ;
+ {
+ CopyStmt *n = makeNode(CopyStmt);
+ n->binary = $2;
+ n->relname = $3;
+ n->oids = $4;
+ n->direction = $5;
+ n->filename = $6;
+ n->delimiter = $7;
+ $$ = (Node *)n;
+ }
+ ;
+
+copy_dirn: TO
+ { $$ = TO; }
+ | FROM
+ { $$ = FROM; }
+ ;
/*
* copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
* used depends on the direction. (It really doesn't make sense to copy from
- * stdout. We silently correct the "typo". - AY 9/94
+ * stdout. We silently correct the "typo". - AY 9/94
*/
-copy_file_name: Sconst { $$ = $1; }
- | STDIN { $$ = NULL; }
- | STDOUT { $$ = NULL; }
- ;
+copy_file_name: Sconst { $$ = $1; }
+ | STDIN { $$ = NULL; }
+ | STDOUT { $$ = NULL; }
+ ;
-opt_binary: BINARY { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
- ;
+opt_binary: BINARY { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
+ ;
-opt_with_copy: WITH OIDS { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
- ;
+opt_with_copy: WITH OIDS { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
/*
* the default copy delimiter is tab but the user can configure it
*/
copy_delimiter: USING DELIMITERS Sconst { $$ = $3;}
- | /* EMPTY */ { $$ = "\t"; }
- ;
+ | /* EMPTY */ { $$ = "\t"; }
+ ;
/*****************************************************************************
*
- * QUERY :
- * CREATE relname
+ * QUERY :
+ * CREATE relname
*
*****************************************************************************/
CreateStmt: CREATE TABLE relation_name '(' OptTableElementList ')'
- OptInherit OptConstraint OptArchiveType OptLocation
- OptArchiveLocation
- {
- CreateStmt *n = makeNode(CreateStmt);
- n->relname = $3;
- n->tableElts = $5;
- n->inhRelnames = $7;
- n->constraints = $8;
- n->archiveType = $9;
- n->location = $10;
- n->archiveLoc = $11;
- $$ = (Node *)n;
- }
- ;
-
-OptTableElementList: tableElementList { $$ = $1; }
- | /* EMPTY */ { $$ = NULL; }
- ;
+ OptInherit OptConstraint OptArchiveType OptLocation
+ OptArchiveLocation
+ {
+ CreateStmt *n = makeNode(CreateStmt);
+ n->relname = $3;
+ n->tableElts = $5;
+ n->inhRelnames = $7;
+ n->constraints = $8;
+ n->archiveType = $9;
+ n->location = $10;
+ n->archiveLoc = $11;
+ $$ = (Node *)n;
+ }
+ ;
+
+OptTableElementList: tableElementList { $$ = $1; }
+ | /* EMPTY */ { $$ = NULL; }
+ ;
tableElementList :
- tableElementList ',' columnDef
- { $$ = lappend($1, $3); }
- | columnDef
- { $$ = lcons($1, NIL); }
- ;
+ tableElementList ',' columnDef
+ { $$ = lappend($1, $3); }
+ | columnDef
+ { $$ = lcons($1, NIL); }
+ ;
-OptArchiveType: ARCHIVE '=' archive_type { $$ = $3; }
- | /*EMPTY*/ { $$ = ARCH_NONE; }
- ;
+OptArchiveType: ARCHIVE '=' archive_type { $$ = $3; }
+ | /*EMPTY*/ { $$ = ARCH_NONE; }
+ ;
-archive_type: HEAVY { $$ = ARCH_HEAVY; }
- | LIGHT { $$ = ARCH_LIGHT; }
- | NONE { $$ = ARCH_NONE; }
- ;
+archive_type: HEAVY { $$ = ARCH_HEAVY; }
+ | LIGHT { $$ = ARCH_LIGHT; }
+ | NONE { $$ = ARCH_NONE; }
+ ;
OptLocation: STORE '=' Sconst
- { $$ = smgrin($3); }
- | /*EMPTY*/
- { $$ = -1; }
- ;
+ { $$ = smgrin($3); }
+ | /*EMPTY*/
+ { $$ = -1; }
+ ;
OptArchiveLocation: ARCH_STORE '=' Sconst
- { $$ = smgrin($3); }
- | /*EMPTY*/
- { $$ = -1; }
- ;
+ { $$ = smgrin($3); }
+ | /*EMPTY*/
+ { $$ = -1; }
+ ;
-OptInherit: INHERITS '(' relation_name_list ')' { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+OptInherit: INHERITS '(' relation_name_list ')' { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
-OptConstraint: ConstraintList { $$ = $1; }
- | { $$ = NULL; }
- ;
+OptConstraint: ConstraintList { $$ = $1; }
+ | { $$ = NULL; }
+ ;
ConstraintList :
- ConstraintList ',' ConstraintElem
- { $$ = lappend($1, $3); }
- | ConstraintElem
- { $$ = lcons($1, NIL); }
- ;
-
-ConstraintElem:
- CONSTRAINT name ConstraintDef
- {
- $3->name = $2;
- $$ = $3;
- }
- | ConstraintDef { $$ = $1; }
- ;
-
-ConstraintDef: CHECK a_expr {
- ConstraintDef *constr = palloc (sizeof(ConstraintDef));
- int chklen = CurScanPosition() - CheckStartPosition;
- char *check;
-
- check = (char*) palloc (chklen + 1);
- memcpy (check,
- parseString + CheckStartPosition,
- chklen);
- check[chklen] = 0;
- constr->type = CONSTR_CHECK;
- constr->name = NULL;
- constr->def = (void*) check;
- $$ = constr;
- }
- ;
+ ConstraintList ',' ConstraintElem
+ { $$ = lappend($1, $3); }
+ | ConstraintElem
+ { $$ = lcons($1, NIL); }
+ ;
+
+ConstraintElem:
+ CONSTRAINT name ConstraintDef
+ {
+ $3->name = $2;
+ $$ = $3;
+ }
+ | ConstraintDef { $$ = $1; }
+ ;
+
+ConstraintDef: CHECK a_expr
+ {
+ ConstraintDef *constr = palloc (sizeof(ConstraintDef));
+ int chklen = CurScanPosition() - CheckStartPosition;
+ char *check;
+
+ check = (char*) palloc (chklen + 1);
+ memcpy (check,
+ parseString + CheckStartPosition,
+ chklen);
+ check[chklen] = 0;
+ constr->type = CONSTR_CHECK;
+ constr->name = NULL;
+ constr->def = (void*) check;
+ $$ = constr;
+ }
+ ;
/*****************************************************************************
*
- * QUERY :
- * CREATE SEQUENCE seqname
+ * QUERY :
+ * CREATE SEQUENCE seqname
*
*****************************************************************************/
-CreateSeqStmt: CREATE SEQUENCE relation_name OptSeqList
- {
- CreateSeqStmt *n = makeNode(CreateSeqStmt);
- n->seqname = $3;
- n->options = $4;
- $$ = (Node *)n;
- }
- ;
+CreateSeqStmt: CREATE SEQUENCE relation_name OptSeqList
+ {
+ CreateSeqStmt *n = makeNode(CreateSeqStmt);
+ n->seqname = $3;
+ n->options = $4;
+ $$ = (Node *)n;
+ }
+ ;
OptSeqList:
- OptSeqList OptSeqElem
- { $$ = lappend($1, $2); }
- | { $$ = NIL; }
- ;
-
-OptSeqElem: IDENT NumConst
- {
- $$ = makeNode(DefElem);
- $$->defname = $1;
- $$->arg = (Node *)$2;
- }
- | IDENT
- {
- $$ = makeNode(DefElem);
- $$->defname = $1;
- $$->arg = (Node *)NULL;
- }
- ;
+ OptSeqList OptSeqElem
+ { $$ = lappend($1, $2); }
+ | { $$ = NIL; }
+ ;
+
+OptSeqElem: IDENT NumConst
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)$2;
+ }
+ | IDENT
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)NULL;
+ }
+ ;
/*****************************************************************************
*
- * QUERIES :
- * CREATE TRIGGER ...
- * DROP TRIGGER ...
+ * QUERIES :
+ * CREATE TRIGGER ...
+ * DROP TRIGGER ...
*
*****************************************************************************/
CreateTrigStmt: CREATE TRIGGER name TriggerActionTime TriggerEvents ON
- relation_name TriggerForSpec EXECUTE PROCEDURE
- name '(' TriggerFuncArgs ')'
- {
- CreateTrigStmt *n = makeNode(CreateTrigStmt);
- n->trigname = $3;
- n->relname = $7;
- n->funcname = $11;
- n->args = $13;
- n->before = $4;
- n->row = $8;
- memcpy (n->actions, $5, 4);
- $$ = (Node *)n;
- }
- ;
-
-TriggerActionTime: BEFORE { $$ = true; }
- | AFTER { $$ = false; }
- ;
-
-TriggerEvents: TriggerOneEvent
- {
- char *e = palloc (4);
- e[0] = $1; e[1] = 0; $$ = e;
- }
- | TriggerOneEvent OR TriggerOneEvent
- {
- char *e = palloc (4);
- e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
- }
- | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
- {
- char *e = palloc (4);
- e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
- $$ = e;
- }
- ;
-
-TriggerOneEvent: INSERT { $$ = 'i'; }
- | DELETE { $$ = 'd'; }
- | UPDATE { $$ = 'u'; }
- ;
-
-TriggerForSpec: FOR name name
- {
- if ( strcmp ($2, "each") != 0 )
- elog (WARN, "parser: syntax error near %s", $2);
- if ( strcmp ($3, "row") == 0 )
- $$ = true;
- else if ( strcmp ($3, "statement") == 0 )
- $$ = false;
- else
- elog (WARN, "parser: syntax error near %s", $3);
- }
- ;
+ relation_name TriggerForSpec EXECUTE PROCEDURE
+ name '(' TriggerFuncArgs ')'
+ {
+ CreateTrigStmt *n = makeNode(CreateTrigStmt);
+ n->trigname = $3;
+ n->relname = $7;
+ n->funcname = $11;
+ n->args = $13;
+ n->before = $4;
+ n->row = $8;
+ memcpy (n->actions, $5, 4);
+ $$ = (Node *)n;
+ }
+ ;
+
+TriggerActionTime: BEFORE { $$ = true; }
+ | AFTER { $$ = false; }
+ ;
+
+TriggerEvents: TriggerOneEvent
+ {
+ char *e = palloc (4);
+ e[0] = $1; e[1] = 0; $$ = e;
+ }
+ | TriggerOneEvent OR TriggerOneEvent
+ {
+ char *e = palloc (4);
+ e[0] = $1; e[1] = $3; e[2] = 0; $$ = e;
+ }
+ | TriggerOneEvent OR TriggerOneEvent OR TriggerOneEvent
+ {
+ char *e = palloc (4);
+ e[0] = $1; e[1] = $3; e[2] = $5; e[3] = 0;
+ $$ = e;
+ }
+ ;
+
+TriggerOneEvent: INSERT { $$ = 'i'; }
+ | DELETE { $$ = 'd'; }
+ | UPDATE { $$ = 'u'; }
+ ;
+
+TriggerForSpec: FOR name name
+ {
+ if ( strcmp ($2, "each") != 0 )
+ elog (WARN, "parser: syntax error near %s", $2);
+ if ( strcmp ($3, "row") == 0 )
+ $$ = true;
+ else if ( strcmp ($3, "statement") == 0 )
+ $$ = false;
+ else
+ elog (WARN, "parser: syntax error near %s", $3);
+ }
+ ;
TriggerFuncArgs: TriggerFuncArg
- { $$ = lcons($1, NIL); }
- | TriggerFuncArgs ',' TriggerFuncArg
- { $$ = lappend($1, $3); }
- | /* EMPTY */ { $$ = NIL; }
- ;
-
-TriggerFuncArg: ICONST
- {
- char *s = (char *) palloc (256);
- sprintf (s, "%d", $1);
- $$ = s;
- }
- | Sconst { $$ = $1; }
- ;
+ { $$ = lcons($1, NIL); }
+ | TriggerFuncArgs ',' TriggerFuncArg
+ { $$ = lappend($1, $3); }
+ | /* EMPTY */ { $$ = NIL; }
+ ;
+
+TriggerFuncArg: ICONST
+ {
+ char *s = (char *) palloc (256);
+ sprintf (s, "%d", $1);
+ $$ = s;
+ }
+ | Sconst { $$ = $1; }
+ ;
DropTrigStmt: DROP TRIGGER name ON relation_name
- {
- DropTrigStmt *n = makeNode(DropTrigStmt);
- n->trigname = $3;
- n->relname = $5;
- $$ = (Node *) n;
- }
- ;
+ {
+ DropTrigStmt *n = makeNode(DropTrigStmt);
+ n->trigname = $3;
+ n->relname = $5;
+ $$ = (Node *) n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY :
- * define (type,operator,aggregate)
+ * QUERY :
+ * define (type,operator,aggregate)
*
*****************************************************************************/
DefineStmt: CREATE def_type def_rest
- {
- $3->defType = $2;
- $$ = (Node *)$3;
- }
- ;
+ {
+ $3->defType = $2;
+ $$ = (Node *)$3;
+ }
+ ;
def_rest: def_name definition
- {
- $$ = makeNode(DefineStmt);
- $$->defname = $1;
- $$->definition = $2;
- }
- ;
-
-def_type: OPERATOR { $$ = OPERATOR; }
- | Type { $$ = P_TYPE; }
- | AGGREGATE { $$ = AGGREGATE; }
- ;
+ {
+ $$ = makeNode(DefineStmt);
+ $$->defname = $1;
+ $$->definition = $2;
+ }
+ ;
+
+def_type: OPERATOR { $$ = OPERATOR; }
+ | Type { $$ = P_TYPE; }
+ | AGGREGATE { $$ = AGGREGATE; }
+ ;
def_name: Id | MathOp | Op
- ;
+ ;
-definition: '(' def_list ')' { $$ = $2; }
- ;
+definition: '(' def_list ')' { $$ = $2; }
+ ;
def_list: def_elem
- { $$ = lcons($1, NIL); }
- | def_list ',' def_elem
- { $$ = lappend($1, $3); }
- ;
+ { $$ = lcons($1, NIL); }
+ | def_list ',' def_elem
+ { $$ = lappend($1, $3); }
+ ;
def_elem: def_name '=' def_arg
- {
- $$ = makeNode(DefElem);
- $$->defname = $1;
- $$->arg = (Node *)$3;
- }
- | def_name
- {
- $$ = makeNode(DefElem);
- $$->defname = $1;
- $$->arg = (Node *)NULL;
- }
- | DEFAULT '=' def_arg
- {
- $$ = makeNode(DefElem);
- $$->defname = (char*) palloc (8);
- strcpy ($$->defname, "default");
- $$->arg = (Node *)$3;
- }
- ;
-
-def_arg: Id { $$ = (Node *)makeString($1); }
- | all_Op { $$ = (Node *)makeString($1); }
- | NumConst { $$ = (Node *)$1; /* already a Value */ }
- | Sconst { $$ = (Node *)makeString($1); }
- | SETOF Id {
- TypeName *n = makeNode(TypeName);
- n->name = $2;
- n->setof = TRUE;
- n->arrayBounds = NULL;
- $$ = (Node *)n;
- }
- ;
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)$3;
+ }
+ | def_name
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)NULL;
+ }
+ | DEFAULT '=' def_arg
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = (char*) palloc (8);
+ strcpy ($$->defname, "default");
+ $$->arg = (Node *)$3;
+ }
+ ;
+
+def_arg: Id { $$ = (Node *)makeString($1); }
+ | all_Op { $$ = (Node *)makeString($1); }
+ | NumConst { $$ = (Node *)$1; /* already a Value */ }
+ | Sconst { $$ = (Node *)makeString($1); }
+ | SETOF Id {
+ TypeName *n = makeNode(TypeName);
+ n->name = $2;
+ n->setof = TRUE;
+ n->arrayBounds = NULL;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * destroy <relname1> [, <relname2> .. <relnameN> ]
+ * QUERY:
+ * destroy <relname1> [, <relname2> .. <relnameN> ]
*
*****************************************************************************/
DestroyStmt: DROP TABLE relation_name_list
- {
- DestroyStmt *n = makeNode(DestroyStmt);
- n->relNames = $3;
- n->sequence = false;
- $$ = (Node *)n;
- }
- | DROP SEQUENCE relation_name_list
- {
- DestroyStmt *n = makeNode(DestroyStmt);
- n->relNames = $3;
- n->sequence = true;
- $$ = (Node *)n;
- }
- ;
+ {
+ DestroyStmt *n = makeNode(DestroyStmt);
+ n->relNames = $3;
+ n->sequence = false;
+ $$ = (Node *)n;
+ }
+ | DROP SEQUENCE relation_name_list
+ {
+ DestroyStmt *n = makeNode(DestroyStmt);
+ n->relNames = $3;
+ n->sequence = true;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * fetch [forward | backward] [number | all ] [ in <portalname> ]
+ * QUERY:
+ *
fetch [forward | backward] [number | all ] [ in <portalname> ]
*
*****************************************************************************/
-FetchStmt: FETCH opt_direction fetch_how_many opt_portal_name
- {
- FetchStmt *n = makeNode(FetchStmt);
- n->direction = $2;
- n->howMany = $3;
- n->portalname = $4;
- $$ = (Node *)n;
- }
- ;
-
-opt_direction: FORWARD { $$ = FORWARD; }
- | BACKWARD { $$ = BACKWARD; }
- | /*EMPTY*/ { $$ = FORWARD; /* default */ }
- ;
+FetchStmt: FETCH opt_direction fetch_how_many opt_portal_name
+ {
+ FetchStmt *n = makeNode(FetchStmt);
+ n->direction = $2;
+ n->howMany = $3;
+ n->portalname = $4;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_direction: FORWARD { $$ = FORWARD; }
+ | BACKWARD { $$ = BACKWARD; }
+ | /*EMPTY*/ { $$ = FORWARD; /* default */ }
+ ;
fetch_how_many: Iconst
- { $$ = $1;
- if ($1 <= 0) elog(WARN,"Please specify nonnegative count for fetch"); }
- | ALL { $$ = 0; /* 0 means fetch all tuples*/}
- | /*EMPTY*/ { $$ = 1; /*default*/ }
- ;
+ { $$ = $1;
+ if ($1 <= 0) elog(WARN,"Please specify nonnegative count for fetch"); }
+ | ALL { $$ = 0; /* 0 means fetch all tuples*/}
+ | /*EMPTY*/ { $$ = 1; /*default*/ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
+ * QUERY:
+ * GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
*
*****************************************************************************/
GrantStmt: GRANT privileges ON relation_name_list TO grantee opt_with_grant
- {
- $$ = (Node*)makeAclStmt($2,$4,$6,'+');
- free($2);
- free($6);
- }
- ;
+ {
+ $$ = (Node*)makeAclStmt($2,$4,$6,'+');
+ free($2);
+ free($6);
+ }
+ ;
privileges: ALL PRIVILEGES
- {
- $$ = aclmakepriv("rwaR",0);
- }
- | ALL
- {
- $$ = aclmakepriv("rwaR",0);
- }
- | operation_commalist {
- $$ = $1;
- }
- ;
-
-operation_commalist: operation {
- $$ = aclmakepriv("",$1);
- }
- | operation_commalist ',' operation
- {
- $$ = aclmakepriv($1,$3);
- free($1);
- }
- ;
-
-operation: SELECT {
- $$ = ACL_MODE_RD_CHR;
- }
- | INSERT {
- $$ = ACL_MODE_AP_CHR;
- }
- | UPDATE {
- $$ = ACL_MODE_WR_CHR;
- }
- | DELETE {
- $$ = ACL_MODE_WR_CHR;
- }
- | RULE {
- $$ = ACL_MODE_RU_CHR;
- }
- ;
-
-grantee: PUBLIC {
- $$ = aclmakeuser("A","");
- }
- | GROUP Id {
- $$ = aclmakeuser("G",$2);
- }
- | Id {
- $$ = aclmakeuser("U",$1);
- }
- ;
+ {
+ $$ = aclmakepriv("rwaR",0);
+ }
+ | ALL
+ {
+ $$ = aclmakepriv("rwaR",0);
+ }
+ | operation_commalist
+ {
+ $$ = $1;
+ }
+ ;
+
+operation_commalist: operation
+ {
+ $$ = aclmakepriv("",$1);
+ }
+ | operation_commalist ',' operation
+ {
+ $$ = aclmakepriv($1,$3);
+ free($1);
+ }
+ ;
+
+operation: SELECT
+ {
+ $$ = ACL_MODE_RD_CHR;
+ }
+ | INSERT
+ {
+ $$ = ACL_MODE_AP_CHR;
+ }
+ | UPDATE
+ {
+ $$ = ACL_MODE_WR_CHR;
+ }
+ | DELETE
+ {
+ $$ = ACL_MODE_WR_CHR;
+ }
+ | RULE
+ {
+ $$ = ACL_MODE_RU_CHR;
+ }
+ ;
+
+grantee: PUBLIC
+ {
+ $$ = aclmakeuser("A","");
+ }
+ | GROUP Id
+ {
+ $$ = aclmakeuser("G",$2);
+ }
+ | Id
+ {
+ $$ = aclmakeuser("U",$1);
+ }
+ ;
opt_with_grant : /* empty */
- | WITH GRANT OPTION
- {
- yyerror("WITH GRANT OPTION is not supported. Only relation owners can set privileges");
- }
- ;
+ | WITH GRANT OPTION
+ {
+ yyerror("WITH GRANT OPTION is not supported. Only relation owners can set privileges");
+ }
+ ;
+
/*****************************************************************************
*
- * QUERY:
- * REVOKE [privileges] ON [relation_name] FROM [user]
+ * QUERY:
+ * REVOKE [privileges] ON [relation_name] FROM [user]
*
*****************************************************************************/
RevokeStmt: REVOKE privileges ON relation_name_list FROM grantee
- {
- $$ = (Node*)makeAclStmt($2,$4,$6,'-');
- free($2);
- free($6);
- }
- ;
+ {
+ $$ = (Node*)makeAclStmt($2,$4,$6,'-');
+ free($2);
+ free($6);
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * move [<dirn>] [<whereto>] [<portalname>]
+ * QUERY:
+ *
move [<dirn>] [<whereto>] [<portalname>]
*
*****************************************************************************/
MoveStmt: MOVE opt_direction opt_move_where opt_portal_name
- {
- MoveStmt *n = makeNode(MoveStmt);
- n->direction = $2;
- n->to = FALSE;
- n->where = $3;
- n->portalname = $4;
- $$ = (Node *)n;
- }
- | MOVE opt_direction TO Iconst opt_portal_name
- {
- MoveStmt *n = makeNode(MoveStmt);
- n->direction = $2;
- n->to = TRUE;
- n->where = $4;
- n->portalname = $5;
- $$ = (Node *)n;
- }
- ;
-
-opt_move_where: Iconst { $$ = $1; }
- | /*EMPTY*/ { $$ = 1; /* default */ }
- ;
-
-opt_portal_name: IN name { $$ = $2;}
- | /*EMPTY*/ { $$ = NULL; }
- ;
+ {
+ MoveStmt *n = makeNode(MoveStmt);
+ n->direction = $2;
+ n->to = FALSE;
+ n->where = $3;
+ n->portalname = $4;
+ $$ = (Node *)n;
+ }
+ | MOVE opt_direction TO Iconst opt_portal_name
+ {
+ MoveStmt *n = makeNode(MoveStmt);
+ n->direction = $2;
+ n->to = TRUE;
+ n->where = $4;
+ n->portalname = $5;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_move_where: Iconst { $$ = $1; }
+ | /*EMPTY*/ { $$ = 1; /* default */ }
+ ;
+
+opt_portal_name: IN name { $$ = $2;}
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
/*****************************************************************************
*
- * QUERY:
- * define [archive] index <indexname> on <relname>
- * using <access> "(" (<col> with <op>)+ ")" [with
- * <target_list>]
+ * QUERY:
+ * define [archive] index <indexname> on <relname>
+ *
using <access> "(" (<col> with <op>)+ ")" [with
+ * <target_list>]
*
- * [where <qual>] is not supported anymore
+ * [where <qual>] is not supported anymore
*****************************************************************************/
-IndexStmt: CREATE index_opt_unique INDEX index_name ON relation_name
- access_method_clause '(' index_params ')' opt_with
- {
- /* should check that access_method is valid,
- etc ... but doesn't */
- IndexStmt *n = makeNode(IndexStmt);
- n->unique = $2;
- n->idxname = $4;
- n->relname = $6;
- n->accessMethod = $7;
- n->indexParams = $9;
- n->withClause = $11;
- n->whereClause = NULL;
- $$ = (Node *)n;
- }
- ;
-
-access_method_clause: USING access_method { $$ = $2; }
- | /* empty -- 'btree' is default access method */
- { $$ = "btree"; }
- ;
-
-index_opt_unique: UNIQUE { $$ = TRUE; }
- | /*empty*/ { $$ = FALSE; }
- ;
+IndexStmt: CREATE index_opt_unique INDEX index_name ON relation_name
+ access_method_clause '(' index_params ')' opt_with
+ {
+ /* should check that access_method is valid,
+ etc ... but doesn't */
+ IndexStmt *n = makeNode(IndexStmt);
+ n->unique = $2;
+ n->idxname = $4;
+ n->relname = $6;
+ n->accessMethod = $7;
+ n->indexParams = $9;
+ n->withClause = $11;
+ n->whereClause = NULL;
+ $$ = (Node *)n;
+ }
+ ;
+
+access_method_clause: USING access_method { $$ = $2; }
+ | /* empty -- 'btree' is default access method */
+ { $$ = "btree"; }
+ ;
+
+index_opt_unique: UNIQUE { $$ = TRUE; }
+ | /*empty*/ { $$ = FALSE; }
+ ;
/*****************************************************************************
*
- * QUERY:
- * extend index <indexname> [where <qual>]
+ * QUERY:
+ * extend index <indexname> [where <qual>]
*
*****************************************************************************/
ExtendStmt: EXTEND INDEX index_name where_clause
- {
- ExtendStmt *n = makeNode(ExtendStmt);
- n->idxname = $3;
- n->whereClause = $4;
- $$ = (Node *)n;
- }
- ;
+ {
+ ExtendStmt *n = makeNode(ExtendStmt);
+ n->idxname = $3;
+ n->whereClause = $4;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * execute recipe <recipeName>
+ * QUERY:
+ * execute recipe <recipeName>
*
*****************************************************************************/
RecipeStmt: EXECUTE RECIPE recipe_name
- {
- RecipeStmt *n;
- if (!IsTransactionBlock())
- elog(WARN, "EXECUTE RECIPE may only be used in begin/end transaction blocks.");
-
- n = makeNode(RecipeStmt);
- n->recipeName = $3;
- $$ = (Node *)n;
- }
- ;
+ {
+ RecipeStmt *n;
+ if (!IsTransactionBlock())
+ elog(WARN, "EXECUTE RECIPE may only be used in begin/end transaction blocks.");
+
+ n = makeNode(RecipeStmt);
+ n->recipeName = $3;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * define function <fname>
- * (language = <lang>, returntype = <typename>
- * [, arch_pct = <percentage | pre-defined>]
- * [, disk_pct = <percentage | pre-defined>]
- * [, byte_pct = <percentage | pre-defined>]
- * [, perbyte_cpu = <int | pre-defined>]
- * [, percall_cpu = <int | pre-defined>]
- * [, iscachable])
- * [arg is (<type-1> { , <type-n>})]
- * as <filename or code in language as appropriate>
+ * QUERY:
+ * define function <fname>
+ * (language = <lang>, returntype = <typename>
+ *
[, arch_pct = <percentage | pre-defined>]
+ *
[, disk_pct = <percentage | pre-defined>]
+ *
[, byte_pct = <percentage | pre-defined>]
+ * [, perbyte_cpu = <int | pre-defined>]
+ * [, percall_cpu = <int | pre-defined>]
+ * [, iscachable])
+ * [arg is (<type-1> { , <type-n>})]
+ * as <filename or code in language as appropriate>
*
*****************************************************************************/
-ProcedureStmt: CREATE FUNCTION def_name def_args
- RETURNS def_arg opt_with AS Sconst LANGUAGE Sconst
- {
- ProcedureStmt *n = makeNode(ProcedureStmt);
- n->funcname = $3;
- n->defArgs = $4;
- n->returnType = (Node *)$6;
- n->withClause = $7;
- n->as = $9;
- n->language = $11;
- $$ = (Node *)n;
- };
-
-opt_with: WITH definition { $$ = $2; }
- | /* EMPTY */ { $$ = NIL; }
- ;
-
-def_args: '(' def_name_list ')' { $$ = $2; }
- | '(' ')' { $$ = NIL; }
- ;
+ProcedureStmt: CREATE FUNCTION def_name def_args
+ RETURNS def_arg opt_with AS Sconst LANGUAGE Sconst
+ {
+ ProcedureStmt *n = makeNode(ProcedureStmt);
+ n->funcname = $3;
+ n->defArgs = $4;
+ n->returnType = (Node *)$6;
+ n->withClause = $7;
+ n->as = $9;
+ n->language = $11;
+ $$ = (Node *)n;
+ };
+
+opt_with: WITH definition { $$ = $2; }
+ | /* EMPTY */ { $$ = NIL; }
+ ;
+
+def_args: '(' def_name_list ')' { $$ = $2; }
+ | '(' ')' { $$ = NIL; }
+ ;
def_name_list: name_list;
/*****************************************************************************
*
- * QUERY:
- * purge <relname> [before <date>] [after <date>]
- * or
- * purge <relname> [after <date>] [before <date>]
+ * QUERY:
+ * purge <relname> [before <date>] [after <date>]
+ * or
+ * purge <relname> [after <date>] [before <date>]
*
*****************************************************************************/
-PurgeStmt: PURGE relation_name purge_quals
- {
- $3->relname = $2;
- $$ = (Node *)$3;
- }
- ;
+PurgeStmt: PURGE relation_name purge_quals
+ {
+ $3->relname = $2;
+ $$ = (Node *)$3;
+ }
+ ;
purge_quals: before_clause
- {
- $$ = makeNode(PurgeStmt);
- $$->beforeDate = $1;
- $$->afterDate = NULL;
- }
- | after_clause
- {
- $$ = makeNode(PurgeStmt);
- $$->beforeDate = NULL;
- $$->afterDate = $1;
- }
- | before_clause after_clause
- {
- $$ = makeNode(PurgeStmt);
- $$->beforeDate = $1;
- $$->afterDate = $2;
- }
- | after_clause before_clause
- {
- $$ = makeNode(PurgeStmt);
- $$->beforeDate = $2;
- $$->afterDate = $1;
- }
- | /*EMPTY*/
- {
- $$ = makeNode(PurgeStmt);
- $$->beforeDate = NULL;
- $$->afterDate = NULL;
- }
- ;
-
-before_clause: BEFORE date { $$ = $2; }
-after_clause: AFTER date { $$ = $2; }
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $1;
+ $$->afterDate = NULL;
+ }
+ | after_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = NULL;
+ $$->afterDate = $1;
+ }
+ | before_clause after_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $1;
+ $$->afterDate = $2;
+ }
+ | after_clause before_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $2;
+ $$->afterDate = $1;
+ }
+ | /*EMPTY*/
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = NULL;
+ $$->afterDate = NULL;
+ }
+ ;
+
+before_clause: BEFORE date { $$ = $2; }
+after_clause: AFTER date { $$ = $2; }
/*****************************************************************************
*
- * QUERY:
+ * QUERY:
*
- * remove function <funcname>
- * (REMOVE FUNCTION "funcname" (arg1, arg2, ...))
- * remove aggregate <aggname>
- * (REMOVE AGGREGATE "aggname" "aggtype")
- * remove operator <opname>
- * (REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
- * remove type <typename>
- * (REMOVE TYPE "typename")
- * remove rule <rulename>
- * (REMOVE RULE "rulename")
+ * remove function <funcname>
+ * (REMOVE FUNCTION "funcname" (arg1, arg2, ...))
+ *
remove aggregate <aggname>
+ * (REMOVE AGGREGATE "aggname" "aggtype")
+ * remove operator <opname>
+ * (REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
+ * remove type <typename>
+ * (REMOVE TYPE "typename")
+ * remove rule <rulename>
+ * (REMOVE RULE "rulename")
*
*****************************************************************************/
RemoveStmt: DROP remove_type name
- {
- RemoveStmt *n = makeNode(RemoveStmt);
- n->removeType = $2;
- n->name = $3;
- $$ = (Node *)n;
- }
- ;
-
-remove_type: Type { $$ = P_TYPE; }
- | INDEX { $$ = INDEX; }
- | RULE { $$ = RULE; }
- | VIEW { $$ = VIEW; }
- ;
+ {
+ RemoveStmt *n = makeNode(RemoveStmt);
+ n->removeType = $2;
+ n->name = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+remove_type: Type { $$ = P_TYPE; }
+ | INDEX { $$ = INDEX; }
+ | RULE { $$ = RULE; }
+ | VIEW { $$ = VIEW; }
+ ;
RemoveAggrStmt: DROP AGGREGATE name aggr_argtype
- {
- RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
- n->aggname = $3;
- n->aggtype = $4;
- $$ = (Node *)n;
- }
- ;
-
-aggr_argtype: name { $$ = $1; }
- | '*' { $$ = NULL; }
- ;
+ {
+ RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
+ n->aggname = $3;
+ n->aggtype = $4;
+ $$ = (Node *)n;
+ }
+ ;
+
+aggr_argtype: name { $$ = $1; }
+ | '*' { $$ = NULL; }
+ ;
RemoveFuncStmt: DROP FUNCTION name '(' func_argtypes ')'
- {
- RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
- n->funcname = $3;
- n->args = $5;
- $$ = (Node *)n;
- }
- ;
-
-func_argtypes: name_list { $$ = $1; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+ {
+ RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
+ n->funcname = $3;
+ n->args = $5;
+ $$ = (Node *)n;
+ }
+ ;
+
+func_argtypes: name_list { $$ = $1; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
RemoveOperStmt: DROP OPERATOR all_Op '(' oper_argtypes ')'
- {
- RemoveOperStmt *n = makeNode(RemoveOperStmt);
- n->opname = $3;
- n->args = $5;
- $$ = (Node *)n;
- }
- ;
+ {
+ RemoveOperStmt *n = makeNode(RemoveOperStmt);
+ n->opname = $3;
+ n->args = $5;
+ $$ = (Node *)n;
+ }
+ ;
all_Op: Op | MathOp;
-MathOp: '+' { $$ = "+"; }
- | '-' { $$ = "-"; }
- | '*' { $$ = "*"; }
- | '/' { $$ = "/"; }
- | '<' { $$ = "<"; }
- | '>' { $$ = ">"; }
- | '=' { $$ = "="; }
- ;
-
-oper_argtypes: name
- {
- elog(WARN, "parser: argument type missing (use NONE for unary operators)");
- }
- | name ',' name
- { $$ = makeList(makeString($1), makeString($3), -1); }
- | NONE ',' name /* left unary */
- { $$ = makeList(NULL, makeString($3), -1); }
- | name ',' NONE /* right unary */
- { $$ = makeList(makeString($1), NULL, -1); }
- ;
+MathOp: '+' { $$ = "+"; }
+ | '-' { $$ = "-"; }
+ | '*' { $$ = "*"; }
+ | '/' { $$ = "/"; }
+ | '<' { $$ = "<"; }
+ | '>' { $$ = ">"; }
+ | '=' { $$ = "="; }
+ ;
+
+oper_argtypes: name
+ {
+ elog(WARN, "parser: argument type missing (use NONE for unary operators)");
+ }
+ | name ',' name
+ { $$ = makeList(makeString($1), makeString($3), -1); }
+ | NONE ',' name /* left unary */
+ { $$ = makeList(NULL, makeString($3), -1); }
+ | name ',' NONE /* right unary */
+ { $$ = makeList(makeString($1), NULL, -1); }
+ ;
/*****************************************************************************
*
- * QUERY:
- * rename <attrname1> in <relname> [*] to <attrname2>
- * rename <relname1> to <relname2>
+ * QUERY:
+ *
rename <attrname1> in <relname> [*] to <attrname2>
+ * rename <relname1> to <relname2>
*
*****************************************************************************/
RenameStmt: ALTER TABLE relation_name opt_inh_star
- RENAME opt_column opt_name TO name
- {
- RenameStmt *n = makeNode(RenameStmt);
- n->relname = $3;
- n->inh = $4;
- n->column = $7;
- n->newname = $9;
- $$ = (Node *)n;
- }
- ;
-
-opt_name: name { $$ = $1; }
- | /*EMPTY*/ { $$ = NULL; }
- ;
-
-opt_column: COLUMN { $$ = COLUMN; }
- | /*EMPTY*/ { $$ = 0; }
- ;
+ RENAME opt_column opt_name TO name
+ {
+ RenameStmt *n = makeNode(RenameStmt);
+ n->relname = $3;
+ n->inh = $4;
+ n->column = $7;
+ n->newname = $9;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_name: name { $$ = $1; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+opt_column: COLUMN { $$ = COLUMN; }
+ | /*EMPTY*/ { $$ = 0; }
+ ;
/*****************************************************************************
*
- * QUERY: Define Rewrite Rule , Define Tuple Rule
- * Define Rule <old rules >
+ * QUERY: Define Rewrite Rule , Define Tuple Rule
+ *
Define Rule <old rules >
*
- * only rewrite rule is supported -- ay 9/94
+ * only rewrite rule is supported -- ay 9/94
*
*****************************************************************************/
RuleStmt: CREATE RULE name AS
- { QueryIsRule=TRUE; }
- ON event TO event_object where_clause
- DO opt_instead OptStmtList
- {
- RuleStmt *n = makeNode(RuleStmt);
- n->rulename = $3;
- n->event = $7;
- n->object = $9;
- n->whereClause = $10;
- n->instead = $12;
- n->actions = $13;
- $$ = (Node *)n;
- }
- ;
-
-OptStmtList: NOTHING { $$ = NIL; }
- | OptimizableStmt { $$ = lcons($1, NIL); }
- | '[' OptStmtBlock ']' { $$ = $2; }
- ;
+ { QueryIsRule=TRUE; }
+ ON event TO event_object where_clause
+ DO opt_instead OptStmtList
+ {
+ RuleStmt *n = makeNode(RuleStmt);
+ n->rulename = $3;
+ n->event = $7;
+ n->object = $9;
+ n->whereClause = $10;
+ n->instead = $12;
+ n->actions = $13;
+ $$ = (Node *)n;
+ }
+ ;
+
+OptStmtList: NOTHING { $$ = NIL; }
+ | OptimizableStmt { $$ = lcons($1, NIL); }
+ | '[' OptStmtBlock ']' { $$ = $2; }
+ ;
OptStmtBlock: OptStmtMulti
- { $$ = $1; }
- | OptimizableStmt
- { $$ = lcons($1, NIL); }
- ;
+ { $$ = $1; }
+ | OptimizableStmt
+ { $$ = lcons($1, NIL); }
+ ;
OptStmtMulti: OptStmtMulti OptimizableStmt ';'
- { $$ = lappend($1, $2); }
- | OptStmtMulti OptimizableStmt
- { $$ = lappend($1, $2); }
- | OptimizableStmt ';'
- { $$ = lcons($1, NIL); }
- ;
+ { $$ = lappend($1, $2); }
+ | OptStmtMulti OptimizableStmt
+ { $$ = lappend($1, $2); }
+ | OptimizableStmt ';'
+ { $$ = lcons($1, NIL); }
+ ;
event_object: relation_name '.' attr_name
- {
- $$ = makeNode(Attr);
- $$->relname = $1;
- $$->paramNo = NULL;
- $$->attrs = lcons(makeString($3), NIL);
- $$->indirection = NIL;
- }
- | relation_name
- {
- $$ = makeNode(Attr);
- $$->relname = $1;
- $$->paramNo = NULL;
- $$->attrs = NIL;
- $$->indirection = NIL;
- }
- ;
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = lcons(makeString($3), NIL);
+ $$->indirection = NIL;
+ }
+ | relation_name
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = NIL;
+ $$->indirection = NIL;
+ }
+ ;
/* change me to select, update, etc. some day */
-event: SELECT { $$ = CMD_SELECT; }
- | UPDATE { $$ = CMD_UPDATE; }
- | DELETE { $$ = CMD_DELETE; }
- | INSERT { $$ = CMD_INSERT; }
- ;
+event: SELECT { $$ = CMD_SELECT; }
+ | UPDATE { $$ = CMD_UPDATE; }
+ | DELETE { $$ = CMD_DELETE; }
+ | INSERT { $$ = CMD_INSERT; }
+ ;
-opt_instead: INSTEAD { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
- ;
+opt_instead: INSTEAD { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
/*****************************************************************************
*
- * QUERY:
- * NOTIFY <relation_name> can appear both in rule bodies and
- * as a query-level command
+ * QUERY:
+ * NOTIFY <relation_name> can appear both in rule bodies and
+ * as a query-level command
*
*****************************************************************************/
NotifyStmt: NOTIFY relation_name
- {
- NotifyStmt *n = makeNode(NotifyStmt);
- n->relname = $2;
- $$ = (Node *)n;
- }
- ;
+ {
+ NotifyStmt *n = makeNode(NotifyStmt);
+ n->relname = $2;
+ $$ = (Node *)n;
+ }
+ ;
ListenStmt: LISTEN relation_name
- {
- ListenStmt *n = makeNode(ListenStmt);
- n->relname = $2;
- $$ = (Node *)n;
- }
+ {
+ ListenStmt *n = makeNode(ListenStmt);
+ n->relname = $2;
+ $$ = (Node *)n;
+ }
;
/*****************************************************************************
*
- * Transactions:
+ * Transactions:
*
- * abort transaction
- * (ABORT)
- * begin transaction
- * (BEGIN)
- * end transaction
- * (END)
+ * abort transaction
+ * (ABORT)
+ * begin transaction
+ * (BEGIN)
+ * end transaction
+ * (END)
*
*****************************************************************************/
TransactionStmt: ABORT_TRANS TRANSACTION
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = ABORT_TRANS;
- $$ = (Node *)n;
- }
- | BEGIN_TRANS TRANSACTION
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = BEGIN_TRANS;
- $$ = (Node *)n;
- }
- | BEGIN_TRANS WORK
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = BEGIN_TRANS;
- $$ = (Node *)n;
- }
- | COMMIT WORK
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = END_TRANS;
- $$ = (Node *)n;
- }
- | END_TRANS TRANSACTION
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = END_TRANS;
- $$ = (Node *)n;
- }
- | ROLLBACK WORK
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = ABORT_TRANS;
- $$ = (Node *)n;
- }
-
- | ABORT_TRANS
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = ABORT_TRANS;
- $$ = (Node *)n;
- }
- | BEGIN_TRANS
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = BEGIN_TRANS;
- $$ = (Node *)n;
- }
- | COMMIT
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = END_TRANS;
- $$ = (Node *)n;
- }
-
- | END_TRANS
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = END_TRANS;
- $$ = (Node *)n;
- }
- | ROLLBACK
- {
- TransactionStmt *n = makeNode(TransactionStmt);
- n->command = ABORT_TRANS;
- $$ = (Node *)n;
- }
- ;
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS TRANSACTION
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | COMMIT WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | END_TRANS TRANSACTION
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | ROLLBACK WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+
+ | ABORT_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | COMMIT
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+
+ | END_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | ROLLBACK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * define view <viewname> '('target-list ')' [where <quals> ]
+ * QUERY:
+ * define view <viewname> '('target-list ')' [where <quals> ]
*
*****************************************************************************/
ViewStmt: CREATE VIEW name AS RetrieveStmt
- {
- ViewStmt *n = makeNode(ViewStmt);
- n->viewname = $3;
- n->query = (Query *)$5;
- $$ = (Node *)n;
- }
- ;
+ {
+ ViewStmt *n = makeNode(ViewStmt);
+ n->viewname = $3;
+ n->query = (Query *)$5;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * load "filename"
+ * QUERY:
+ * load "filename"
*
*****************************************************************************/
LoadStmt: LOAD file_name
- {
- LoadStmt *n = makeNode(LoadStmt);
- n->filename = $2;
- $$ = (Node *)n;
- }
- ;
+ {
+ LoadStmt *n = makeNode(LoadStmt);
+ n->filename = $2;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * createdb dbname
+ * QUERY:
+ * createdb dbname
*
*****************************************************************************/
CreatedbStmt: CREATE DATABASE database_name
- {
- CreatedbStmt *n = makeNode(CreatedbStmt);
- n->dbname = $3;
- $$ = (Node *)n;
- }
- ;
+ {
+ CreatedbStmt *n = makeNode(CreatedbStmt);
+ n->dbname = $3;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * destroydb dbname
+ * QUERY:
+ * destroydb dbname
*
*****************************************************************************/
-DestroydbStmt: DROP DATABASE database_name
- {
- DestroydbStmt *n = makeNode(DestroydbStmt);
- n->dbname = $3;
- $$ = (Node *)n;
- }
- ;
+DestroydbStmt: DROP DATABASE database_name
+ {
+ DestroydbStmt *n = makeNode(DestroydbStmt);
+ n->dbname = $3;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * cluster <index_name> on <relation_name>
+ * QUERY:
+ * cluster <index_name> on <relation_name>
*
*****************************************************************************/
ClusterStmt: CLUSTER index_name ON relation_name
- {
- ClusterStmt *n = makeNode(ClusterStmt);
- n->relname = $4;
- n->indexname = $2;
- $$ = (Node*)n;
- }
- ;
+ {
+ ClusterStmt *n = makeNode(ClusterStmt);
+ n->relname = $4;
+ n->indexname = $2;
+ $$ = (Node*)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * vacuum
+ * QUERY:
+ * vacuum
*
*****************************************************************************/
VacuumStmt: VACUUM opt_verbose opt_analyze
- {
- VacuumStmt *n = makeNode(VacuumStmt);
- n->verbose = $2;
- n->analyze = $3;
- n->vacrel = NULL;
- n->va_spec = NIL;
- $$ = (Node *)n;
- }
- | VACUUM opt_verbose relation_name opt_analyze opt_va_list
- {
- VacuumStmt *n = makeNode(VacuumStmt);
- n->verbose = $2;
- n->analyze = $4;
- n->vacrel = $3;
- n->va_spec = $5;
- if ( $5 != NIL && !$4 )
- elog (WARN, "parser: syntax error at or near \"(\"");
- $$ = (Node *)n;
- }
- ;
-
-opt_verbose: VERBOSE { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
- ;
-
-opt_analyze: ANALYZE { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
- ;
+ {
+ VacuumStmt *n = makeNode(VacuumStmt);
+ n->verbose = $2;
+ n->analyze = $3;
+ n->vacrel = NULL;
+ n->va_spec = NIL;
+ $$ = (Node *)n;
+ }
+ | VACUUM opt_verbose relation_name opt_analyze opt_va_list
+ {
+ VacuumStmt *n = makeNode(VacuumStmt);
+ n->verbose = $2;
+ n->analyze = $4;
+ n->vacrel = $3;
+ n->va_spec = $5;
+ if ( $5 != NIL && !$4 )
+ elog (WARN, "parser: syntax error at or near \"(\"");
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_verbose: VERBOSE { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
+
+opt_analyze: ANALYZE { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
opt_va_list: '(' va_list ')'
- { $$ = $2; }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ { $$ = $2; }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
va_list: name
- { $$=lcons($1,NIL); }
- | va_list ',' name
- { $$=lappend($1,$3); }
- ;
+ { $$=lcons($1,NIL); }
+ | va_list ',' name
+ { $$=lappend($1,$3); }
+ ;
/*****************************************************************************
*
- * QUERY:
- * EXPLAIN query
+ * QUERY:
+ * EXPLAIN query
*
*****************************************************************************/
ExplainStmt: EXPLAIN opt_verbose OptimizableStmt
- {
- ExplainStmt *n = makeNode(ExplainStmt);
- n->verbose = $2;
- n->query = (Query*)$3;
- $$ = (Node *)n;
- }
- ;
+ {
+ ExplainStmt *n = makeNode(ExplainStmt);
+ n->verbose = $2;
+ n->query = (Query*)$3;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
- * *
- * Optimizable Stmts: *
- * *
- * one of the five queries processed by the planner *
- * *
- * [ultimately] produces query-trees as specified *
- * in the query-spec document in ~postgres/ref *
- * *
+ * *
+ * Optimizable Stmts: *
+ * *
+ * one of the five queries processed by the planner *
+ * *
+ * [ultimately] produces query-trees as specified *
+ * in the query-spec document in ~postgres/ref *
+ * *
*****************************************************************************/
OptimizableStmt: RetrieveStmt
- | CursorStmt
- | ReplaceStmt
- | AppendStmt
- | NotifyStmt
- | DeleteStmt /* by default all are $$=$1 */
- ;
+ | CursorStmt
+ | ReplaceStmt
+ | AppendStmt
+ | NotifyStmt
+ | DeleteStmt /* by default all are $$=$1 */
+ ;
/*****************************************************************************
*
- * QUERY:
- * INSERT STATEMENTS
+ * QUERY:
+ * INSERT STATEMENTS
*
*****************************************************************************/
AppendStmt: INSERT INTO relation_name opt_column_list insert_rest
- {
- $5->relname = $3;
- $5->cols = $4;
- $$ = (Node *)$5;
- }
- ;
+ {
+ $5->relname = $3;
+ $5->cols = $4;
+ $$ = (Node *)$5;
+ }
+ ;
insert_rest: VALUES '(' res_target_list2 ')'
- {
- $$ = makeNode(AppendStmt);
- $$->targetList = $3;
- $$->fromClause = NIL;
- $$->whereClause = NULL;
- }
- | SELECT res_target_list2 from_clause where_clause
- {
- $$ = makeNode(AppendStmt);
- $$->targetList = $2;
- $$->fromClause = $3;
- $$->whereClause = $4;
- }
- ;
-
-opt_column_list: '(' columnList ')' { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+ {
+ $$ = makeNode(AppendStmt);
+ $$->targetList = $3;
+ $$->fromClause = NIL;
+ $$->whereClause = NULL;
+ }
+ | SELECT res_target_list2 from_clause where_clause
+ {
+ $$ = makeNode(AppendStmt);
+ $$->targetList = $2;
+ $$->fromClause = $3;
+ $$->whereClause = $4;
+ }
+ ;
+
+opt_column_list: '(' columnList ')' { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
columnList:
- columnList ',' columnElem
- { $$ = lappend($1, $3); }
- | columnElem
- { $$ = lcons($1, NIL); }
- ;
+ columnList ',' columnElem
+ { $$ = lappend($1, $3); }
+ | columnElem
+ { $$ = lcons($1, NIL); }
+ ;
columnElem: Id opt_indirection
- {
- Ident *id = makeNode(Ident);
- id->name = $1;
- id->indirection = $2;
- $$ = (Node *)id;
- }
- ;
+ {
+ Ident *id = makeNode(Ident);
+ id->name = $1;
+ id->indirection = $2;
+ $$ = (Node *)id;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * DELETE STATEMENTS
+ * QUERY:
+ * DELETE STATEMENTS
*
*****************************************************************************/
DeleteStmt: DELETE FROM relation_name
- where_clause
- {
- DeleteStmt *n = makeNode(DeleteStmt);
- n->relname = $3;
- n->whereClause = $4;
- $$ = (Node *)n;
- }
- ;
+ where_clause
+ {
+ DeleteStmt *n = makeNode(DeleteStmt);
+ n->relname = $3;
+ n->whereClause = $4;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * ReplaceStmt (UPDATE)
+ * QUERY:
+ * ReplaceStmt (UPDATE)
*
*****************************************************************************/
ReplaceStmt: UPDATE relation_name
- SET res_target_list
- from_clause
- where_clause
- {
- ReplaceStmt *n = makeNode(ReplaceStmt);
- n->relname = $2;
- n->targetList = $4;
- n->fromClause = $5;
- n->whereClause = $6;
- $$ = (Node *)n;
- }
- ;
+ SET res_target_list
+ from_clause
+ where_clause
+ {
+ ReplaceStmt *n = makeNode(ReplaceStmt);
+ n->relname = $2;
+ n->targetList = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * CURSOR STATEMENTS
+ * QUERY:
+ * CURSOR STATEMENTS
*
*****************************************************************************/
CursorStmt: DECLARE name opt_binary CURSOR FOR
- SELECT opt_unique res_target_list2
- from_clause where_clause group_clause sort_clause
- {
- CursorStmt *n = makeNode(CursorStmt);
-
- /* from PORTAL name */
- /*
- * 15 august 1991 -- since 3.0 postgres does locking
- * right, we discovered that portals were violating
- * locking protocol. portal locks cannot span xacts.
- * as a short-term fix, we installed the check here.
- * -- mao
- */
- if (!IsTransactionBlock())
- elog(WARN, "Named portals may only be used in begin/end transaction blocks.");
-
- n->portalname = $2;
- n->binary = $3;
- n->unique = $7;
- n->targetList = $8;
- n->fromClause = $9;
- n->whereClause = $10;
- n->groupClause = $11;
- n->sortClause = $12;
- $$ = (Node *)n;
- }
- ;
+ SELECT opt_unique res_target_list2
+ from_clause where_clause group_clause sort_clause
+ {
+ CursorStmt *n = makeNode(CursorStmt);
+
+ /* from PORTAL name */
+ /*
+ * 15 august 1991 -- since 3.0 postgres does locking
+ * right, we discovered that portals were violating
+ * locking protocol. portal locks cannot span xacts.
+ * as a short-term fix, we installed the check here.
+ * -- mao
+ */
+ if (!IsTransactionBlock())
+ elog(WARN, "Named portals may only be used in begin/end transaction blocks.");
+
+ n->portalname = $2;
+ n->binary = $3;
+ n->unique = $7;
+ n->targetList = $8;
+ n->fromClause = $9;
+ n->whereClause = $10;
+ n->groupClause = $11;
+ n->sortClause = $12;
+ $$ = (Node *)n;
+ }
+ ;
/*****************************************************************************
*
- * QUERY:
- * SELECT STATEMENTS
+ * QUERY:
+ * SELECT STATEMENTS
*
*****************************************************************************/
/******************************************************************************
RetrieveStmt: SELECT opt_unique res_target_list2
- result from_clause where_clause
- group_clause having_clause
- sort_clause
- {
- RetrieveStmt *n = makeNode(RetrieveStmt);
- n->unique = $2;
- n->targetList = $3;
- n->into = $4;
- n->fromClause = $5;
- n->whereClause = $6;
- n->groupClause = $7;
- n->havingClause = $8;
- n->sortClause = $9;
- $$ = (Node *)n;
- }
- ;
+ result from_clause where_clause
+ group_clause having_clause
+ sort_clause
+ {
+ RetrieveStmt *n = makeNode(RetrieveStmt);
+ n->unique = $2;
+ n->targetList = $3;
+ n->into = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ n->groupClause = $7;
+ n->havingClause = $8;
+ n->sortClause = $9;
+ $$ = (Node *)n;
+ }
+ ;
RetrieveStmt: Select UNION select_list sort_clause
- | Select sort_clause
+ | Select sort_clause
Select: SELECT opt_unique res_target_list2
- result from_clause where_clause
- group_clause having_clause
- {
- Select *n = makeNode(Select);
- n->unique = $2;
- n->targetList = $3;
- n->into = $4;
- n->fromClause = $5;
- n->whereClause = $6;
- n->groupClause = $7;
- n->havingClause = $8;
- $$ = (Node *)n;
- }
- ;
+ result from_clause where_clause
+ group_clause having_clause
+ {
+ Select *n = makeNode(Select);
+ n->unique = $2;
+ n->targetList = $3;
+ n->into = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ n->groupClause = $7;
+ n->havingClause = $8;
+ $$ = (Node *)n;
+ }
+ ;
******************************************************************************/
RetrieveStmt: SELECT opt_unique res_target_list2
- result from_clause where_clause
- group_clause having_clause
- union_clause sort_clause
- {
- RetrieveStmt *n = makeNode(RetrieveStmt);
- n->unique = $2;
- n->targetList = $3;
- n->into = $4;
- n->fromClause = $5;
- n->whereClause = $6;
- n->groupClause = $7;
- n->havingClause = $8;
- n->selectClause = $9;
- n->sortClause = $10;
- $$ = (Node *)n;
- }
- ;
-
-union_clause: UNION select_list { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+ result from_clause where_clause
+ group_clause having_clause
+ union_clause sort_clause
+ {
+ RetrieveStmt *n = makeNode(RetrieveStmt);
+ n->unique = $2;
+ n->targetList = $3;
+ n->into = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ n->groupClause = $7;
+ n->havingClause = $8;
+ n->selectClause = $9;
+ n->sortClause = $10;
+ $$ = (Node *)n;
+ }
+ ;
+
+union_clause: UNION select_list { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
select_list: select_list UNION SubSelect
- { $$ = lappend($1, $3); }
- | SubSelect
- { $$ = lcons($1, NIL); }
- ;
-
-SubSelect: SELECT opt_unique res_target_list2
- result from_clause where_clause
- group_clause having_clause
- {
- SubSelect *n = makeNode(SubSelect);
- n->unique = $2;
- n->targetList = $3;
- n->fromClause = $5;
- n->whereClause = $6;
- n->groupClause = $7;
- n->havingClause = $8;
- $$ = (Node *)n;
- }
- ;
+ { $$ = lappend($1, $3); }
+ | SubSelect
+ { $$ = lcons($1, NIL); }
+ ;
+
+SubSelect: SELECT opt_unique res_target_list2
+ result from_clause where_clause
+ group_clause having_clause
+ {
+ SubSelect *n = makeNode(SubSelect);
+ n->unique = $2;
+ n->targetList = $3;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ n->groupClause = $7;
+ n->havingClause = $8;
+ $$ = (Node *)n;
+ }
+ ;
result: INTO TABLE relation_name
- { $$= $3; /* should check for archive level */ }
- | /*EMPTY*/
- { $$ = NULL; }
- ;
+ { $$= $3; /* should check for archive level */ }
+ | /*EMPTY*/
+ { $$ = NULL; }
+ ;
-opt_unique: DISTINCT { $$ = "*"; }
- | DISTINCT ON Id { $$ = $3; }
- | /*EMPTY*/ { $$ = NULL;}
- ;
+opt_unique: DISTINCT { $$ = "*"; }
+ | DISTINCT ON Id { $$ = $3; }
+ | /*EMPTY*/ { $$ = NULL;}
+ ;
-sort_clause: ORDER BY sortby_list { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+sort_clause: ORDER BY sortby_list { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
sortby_list: sortby
- { $$ = lcons($1, NIL); }
- | sortby_list ',' sortby
- { $$ = lappend($1, $3); }
- ;
+ { $$ = lcons($1, NIL); }
+ | sortby_list ',' sortby
+ { $$ = lappend($1, $3); }
+ ;
sortby: Id OptUseOp
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = NULL;
- $$->name = $1;
- $$->useOp = $2;
- }
- | Id '.' Id OptUseOp
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = $1;
- $$->name = $3;
- $$->useOp = $4;
- }
- | Iconst OptUseOp
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = $1;
- $$->range = NULL;
- $$->name = NULL;
- $$->useOp = $2;
- }
- ;
-
-OptUseOp: USING Op { $$ = $2; }
- | USING '<' { $$ = "<"; }
- | USING '>' { $$ = ">"; }
- | ASC { $$ = "<"; }
- | DESC { $$ = ">"; }
- | /*EMPTY*/ { $$ = "<"; /*default*/ }
- ;
-
-index_params: index_list { $$ = $1; }
- | func_index { $$ = lcons($1,NIL); }
- ;
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = NULL;
+ $$->name = $1;
+ $$->useOp = $2;
+ }
+ | Id '.' Id OptUseOp
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = $1;
+ $$->name = $3;
+ $$->useOp = $4;
+ }
+ | Iconst OptUseOp
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = $1;
+ $$->range = NULL;
+ $$->name = NULL;
+ $$->useOp = $2;
+ }
+ ;
+
+OptUseOp: USING Op { $$ = $2; }
+ | USING '<' { $$ = "<"; }
+ | USING '>' { $$ = ">"; }
+ | ASC { $$ = "<"; }
+ | DESC { $$ = ">"; }
+ | /*EMPTY*/ { $$ = "<"; /*default*/ }
+ ;
+
+index_params: index_list { $$ = $1; }
+ | func_index { $$ = lcons($1,NIL); }
+ ;
index_list:
- index_list ',' index_elem
- { $$ = lappend($1, $3); }
- | index_elem
- { $$ = lcons($1, NIL); }
- ;
+ index_list ',' index_elem
+ { $$ = lappend($1, $3); }
+ | index_elem
+ { $$ = lcons($1, NIL); }
+ ;
func_index: name '(' name_list ')' opt_type opt_class
- {
- $$ = makeNode(IndexElem);
- $$->name = $1;
- $$->args = $3;
- $$->class = $6;
- $$->tname = $5;
- }
- ;
+ {
+ $$ = makeNode(IndexElem);
+ $$->name = $1;
+ $$->args = $3;
+ $$->class = $6;
+ $$->tname = $5;
+ }
+ ;
index_elem: attr_name opt_type opt_class
- {
- $$ = makeNode(IndexElem);
- $$->name = $1;
- $$->args = NIL;
- $$->class = $3;
- $$->tname = $2;
- }
- ;
-
-opt_type: ':' Typename { $$ = $2;}
- | /*EMPTY*/ { $$ = NULL;}
- ;
-
-opt_class: class
- | WITH class { $$ = $2; }
- | /*EMPTY*/ { $$ = NULL; }
- ;
+ {
+ $$ = makeNode(IndexElem);
+ $$->name = $1;
+ $$->args = NIL;
+ $$->class = $3;
+ $$->tname = $2;
+ }
+ ;
+
+opt_type: ':' Typename { $$ = $2;}
+ | /*EMPTY*/ { $$ = NULL;}
+ ;
+
+opt_class: class
+ | WITH class { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
/*
- * jimmy bell-style recursive queries aren't supported in the
- * current system.
+ * jimmy bell-style recursive queries aren't supported in the
+ * current system.
*
- * ...however, recursive addattr and rename supported. make special
- * cases for these.
+ * ...however, recursive addattr and rename supported. make special
+ * cases for these.
*
- * XXX i believe '*' should be the default behavior, but...
+ * XXX i believe '*' should be the default behavior, but...
*/
-opt_inh_star: '*' { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
- ;
+opt_inh_star: '*' { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
+ ;
-relation_name_list: name_list ;
+relation_name_list: name_list ;
name_list: name
- { $$=lcons(makeString($1),NIL); }
- | name_list ',' name
- { $$=lappend($1,makeString($3)); }
- ;
+ { $$=lcons(makeString($1),NIL); }
+ | name_list ',' name
+ { $$=lappend($1,makeString($3)); }
+ ;
-group_clause: GROUP BY groupby_list { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
+group_clause: GROUP BY groupby_list { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
-groupby_list: groupby { $$ = lcons($1, NIL); }
- | groupby_list ',' groupby { $$ = lappend($1, $3); }
- ;
+groupby_list: groupby { $$ = lcons($1, NIL); }
+ | groupby_list ',' groupby { $$ = lappend($1, $3); }
+ ;
groupby: Id
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = NULL;
- $$->name = $1;
- $$->useOp = NULL;
- }
- | Id '.' Id
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = $1;
- $$->name = $3;
- $$->useOp = NULL;
- }
- | Iconst
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = $1;
- $$->range = NULL;
- $$->name = NULL;
- $$->useOp = NULL;
- }
- ;
-
-having_clause: HAVING a_expr { $$ = $2; }
- | /*EMPTY*/ { $$ = NULL; }
- ;
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = NULL;
+ $$->name = $1;
+ $$->useOp = NULL;
+ }
+ | Id '.' Id
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = $1;
+ $$->name = $3;
+ $$->useOp = NULL;
+ }
+ | Iconst
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = $1;
+ $$->range = NULL;
+ $$->name = NULL;
+ $$->useOp = NULL;
+ }
+ ;
+
+having_clause: HAVING a_expr { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
/*****************************************************************************
*
- * clauses common to all Optimizable Stmts:
- * from_clause -
- * where_clause -
+ * clauses common to all Optimizable Stmts:
+ * from_clause -
+ * where_clause -
*
*****************************************************************************/
from_clause: FROM '(' relation_expr join_clause relation_expr join_spec ')'
- {
- $$ = NIL;
- elog(WARN,"JOIN not yet implemented",NULL);
- }
- | FROM from_list { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
- ;
-
-from_list: from_list ',' from_val
- { $$ = lappend($1, $3); }
- | from_val CROSS JOIN from_val
- { elog(WARN,"CROSS JOIN not yet implemented",NULL); }
- | from_val
- { $$ = lcons($1, NIL); }
- ;
+ {
+ $$ = NIL;
+ elog(WARN,"JOIN not yet implemented",NULL);
+ }
+ | FROM from_list { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+from_list: from_list ',' from_val
+ { $$ = lappend($1, $3); }
+ | from_val CROSS JOIN from_val
+ { elog(WARN,"CROSS JOIN not yet implemented",NULL); }
+ | from_val
+ { $$ = lcons($1, NIL); }
+ ;
from_val: relation_expr AS var_name
- {
- $$ = makeNode(RangeVar);
- $$->relExpr = $1;
- $$->name = $3;
- }
- | relation_expr var_name
- {
- $$ = makeNode(RangeVar);
- $$->relExpr = $1;
- $$->name = $2;
- }
- | relation_expr
- {
- $$ = makeNode(RangeVar);
- $$->relExpr = $1;
- $$->name = NULL;
- }
- ;
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = $3;
+ }
+ | relation_expr var_name
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = $2;
+ }
+ | relation_expr
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = NULL;
+ }
+ ;
join_clause: join_qual join_type JOIN
- {
- $$ = NULL;
- }
- ;
-
-join_qual: NATURAL { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
- ;
-
-join_type: FULL join_outer
- { elog(WARN,"FULL OUTER JOIN not yet implemented",NULL); }
- | LEFT join_outer
- { elog(WARN,"LEFT OUTER JOIN not yet implemented",NULL); }
- | RIGHT join_outer
- { elog(WARN,"RIGHT OUTER JOIN not yet implemented",NULL); }
- | join_outer
- { elog(WARN,"OUTER JOIN not yet implemented",NULL); }
- | INNERJOIN
- { elog(WARN,"INNER JOIN not yet implemented",NULL); }
- | UNION
- { elog(WARN,"UNION JOIN not yet implemented",NULL); }
- | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
- ;
-
-join_outer: OUTERJOIN { $$ = NULL; }
- | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
- ;
-
-join_spec: ON '(' a_expr ')' { $$ = NULL; }
- | USING '(' join_list ')' { $$ = NULL; }
- | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
- ;
-
-join_list: join_using { $$ = lcons($1, NIL); }
- | join_list ',' join_using { $$ = lappend($1, $3); }
- ;
+ {
+ $$ = NULL;
+ }
+ ;
+
+join_qual: NATURAL { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
+ ;
+
+join_type: FULL join_outer
+ { elog(WARN,"FULL OUTER JOIN not yet implemented",NULL); }
+ | LEFT join_outer
+ { elog(WARN,"LEFT OUTER JOIN not yet implemented",NULL); }
+ | RIGHT join_outer
+ { elog(WARN,"RIGHT OUTER JOIN not yet implemented",NULL); }
+ | join_outer
+ { elog(WARN,"OUTER JOIN not yet implemented",NULL); }
+ | INNERJOIN
+ { elog(WARN,"INNER JOIN not yet implemented",NULL); }
+ | UNION
+ { elog(WARN,"UNION JOIN not yet implemented",NULL); }
+ | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ ;
+
+join_outer: OUTERJOIN { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ ;
+
+join_spec: ON '(' a_expr ')' { $$ = NULL; }
+ | USING '(' join_list ')' { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ ;
+
+join_list: join_using { $$ = lcons($1, NIL); }
+ | join_list ',' join_using { $$ = lappend($1, $3); }
+ ;
join_using: Id
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = NULL;
- $$->name = $1;
- $$->useOp = NULL;
- }
- | Id '.' Id
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = 0;
- $$->range = $1;
- $$->name = $3;
- $$->useOp = NULL;
- }
- | Iconst
- {
- $$ = makeNode(SortGroupBy);
- $$->resno = $1;
- $$->range = NULL;
- $$->name = NULL;
- $$->useOp = NULL;
- }
- ;
-
-where_clause: WHERE a_expr { $$ = $2; }
- | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
- ;
-
-relation_expr: relation_name
- {
- /* normal relations */
- $$ = makeNode(RelExpr);
- $$->relname = $1;
- $$->inh = FALSE;
- $$->timeRange = NULL;
- }
- | relation_name '*' %prec '='
- {
- /* inheiritance query */
- $$ = makeNode(RelExpr);
- $$->relname = $1;
- $$->inh = TRUE;
- $$->timeRange = NULL;
- }
- | relation_name time_range
- {
- /* time-qualified query */
- $$ = makeNode(RelExpr);
- $$->relname = $1;
- $$->inh = FALSE;
- $$->timeRange = $2;
- }
- ;
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = NULL;
+ $$->name = $1;
+ $$->useOp = NULL;
+ }
+ | Id '.' Id
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = 0;
+ $$->range = $1;
+ $$->name = $3;
+ $$->useOp = NULL;
+ }
+ | Iconst
+ {
+ $$ = makeNode(SortGroupBy);
+ $$->resno = $1;
+ $$->range = NULL;
+ $$->name = NULL;
+ $$->useOp = NULL;
+ }
+ ;
+
+where_clause: WHERE a_expr { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ ;
+
+relation_expr: relation_name
+ {
+ /* normal relations */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = FALSE;
+ $$->timeRange = NULL;
+ }
+ | relation_name '*' %prec '='
+ {
+ /* inheiritance query */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = TRUE;
+ $$->timeRange = NULL;
+ }
+ | relation_name time_range
+ {
+ /* time-qualified query */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = FALSE;
+ $$->timeRange = $2;
+ }
+ ;
time_range: '[' opt_range_start ',' opt_range_end ']'
- {
- $$ = makeNode(TimeRange);
- $$->startDate = $2;
- $$->endDate = $4;
- }
- | '[' date ']'
- {
- $$ = makeNode(TimeRange);
- $$->startDate = $2;
- $$->endDate = NULL;
- }
- ;
+ {
+ $$ = makeNode(TimeRange);
+ $$->startDate = $2;
+ $$->endDate = $4;
+ }
+ | '[' date ']'
+ {
+ $$ = makeNode(TimeRange);
+ $$->startDate = $2;
+ $$->endDate = NULL;
+ }
+ ;
opt_range_start: date
- | /*EMPTY*/ { $$ = "epoch"; }
- ;
+ | /*EMPTY*/ { $$ = "epoch"; }
+ ;
-opt_range_end: date
- | /*EMPTY*/ { $$ = "now"; }
- ;
+opt_range_end: date
+ | /*EMPTY*/ { $$ = "now"; }
+ ;
opt_array_bounds: '[' ']' nest_array_bounds
- { $$ = lcons(makeInteger(-1), $3); }
- | '[' Iconst ']' nest_array_bounds
- { $$ = lcons(makeInteger($2), $4); }
- | /* EMPTY */
- { $$ = NIL; }
- ;
-
-nest_array_bounds: '[' ']' nest_array_bounds
- { $$ = lcons(makeInteger(-1), $3); }
- | '[' Iconst ']' nest_array_bounds
- { $$ = lcons(makeInteger($2), $4); }
- | /*EMPTY*/
- { $$ = NIL; }
- ;
+ { $$ = lcons(makeInteger(-1), $3); }
+ | '[' Iconst ']' nest_array_bounds
+ { $$ = lcons(makeInteger($2), $4); }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
+
+nest_array_bounds: '[' ']' nest_array_bounds
+ { $$ = lcons(makeInteger(-1), $3); }
+ | '[' Iconst ']' nest_array_bounds
+ { $$ = lcons(makeInteger($2), $4); }
+ | /*EMPTY*/
+ { $$ = NIL; }
+ ;
typname: txname
- {
- char *tname = xlateSqlType($1);
- $$ = makeNode(TypeName);
- $$->name = tname;
-
- /* Is this the name of a complex type? If so, implement
- * it as a set.
- */
- if (!strcmp(saved_relname, tname)) {
- /* This attr is the same type as the relation
- * being defined. The classic example: create
- * emp(name=text,mgr=emp)
- */
- $$->setof = TRUE;
- }else if (get_typrelid((Type)type(tname))
- != InvalidOid) {
- /* (Eventually add in here that the set can only
- * contain one element.)
- */
- $$->setof = TRUE;
- } else {
- $$->setof = FALSE;
- }
- }
- | SETOF txname
- {
- char *tname = xlateSqlType($2);
- $$ = makeNode(TypeName);
- $$->name = tname;
- $$->setof = TRUE;
- }
- ;
-
-txname: Id { $$ = $1; }
- | TIME { $$ = "time"; }
- | INTERVAL interval_opts { $$ = "interval"; }
- ;
-
-interval_opts: YEARINTERVAL { $$ = lcons("year", NIL); }
- | MONTHINTERVAL { $$ = NIL; }
- | DAYINTERVAL { $$ = NIL; }
- | HOURINTERVAL { $$ = NIL; }
- | MINUTEINTERVAL { $$ = NIL; }
- | SECONDINTERVAL { $$ = NIL; }
- | YEARINTERVAL TO MONTHINTERVAL { $$ = NIL; }
- | DAYINTERVAL TO HOURINTERVAL { $$ = NIL; }
- | DAYINTERVAL TO MINUTEINTERVAL { $$ = NIL; }
- | DAYINTERVAL TO SECONDINTERVAL { $$ = NIL; }
- | HOURINTERVAL TO MINUTEINTERVAL { $$ = NIL; }
- | HOURINTERVAL TO SECONDINTERVAL { $$ = NIL; }
- | /* EMPTY */ { $$ = NIL; }
- ;
+ {
+ char *tname = xlateSqlType($1);
+ $$ = makeNode(TypeName);
+ $$->name = tname;
+
+ /* Is this the name of a complex type? If so, implement
+ * it as a set.
+ */
+ if (!strcmp(saved_relname, tname))
+ /* This attr is the same type as the relation
+ * being defined. The classic example: create
+ * emp(name=text,mgr=emp)
+ */
+ $$->setof = TRUE;
+ else if (get_typrelid((Type)type(tname)) != InvalidOid)
+ /* (Eventually add in here that the set can only
+ * contain one element.)
+ */
+ $$->setof = TRUE;
+ else
+ $$->setof = FALSE;
+ }
+ | SETOF txname
+ {
+ char *tname = xlateSqlType($2);
+ $$ = makeNode(TypeName);
+ $$->name = tname;
+ $$->setof = TRUE;
+ }
+ ;
+
+txname: Id { $$ = $1; }
+ | TIME { $$ = "time"; }
+ | INTERVAL interval_opts { $$ = "interval"; }
+ ;
+
+interval_opts: YEARINTERVAL { $$ = lcons("year", NIL); }
+ | MONTHINTERVAL { $$ = NIL; }
+ | DAYINTERVAL { $$ = NIL; }
+ | HOURINTERVAL { $$ = NIL; }
+ | MINUTEINTERVAL { $$ = NIL; }
+ | SECONDINTERVAL { $$ = NIL; }
+ | YEARINTERVAL TO MONTHINTERVAL { $$ = NIL; }
+ | DAYINTERVAL TO HOURINTERVAL { $$ = NIL; }
+ | DAYINTERVAL TO MINUTEINTERVAL { $$ = NIL; }
+ | DAYINTERVAL TO SECONDINTERVAL { $$ = NIL; }
+ | HOURINTERVAL TO MINUTEINTERVAL { $$ = NIL; }
+ | HOURINTERVAL TO SECONDINTERVAL { $$ = NIL; }
+ | /* EMPTY */ { $$ = NIL; }
+ ;
Typename: typname opt_array_bounds
- {
- $$ = $1;
- $$->arrayBounds = $2;
- }
- | txname '(' Iconst ')'
- {
- /*
- * This block gets hit when the parser is passed a query
- * which contains only spaces (e.g. from psql type " \g").
- * Let's check explicitly for a zero-length argument
- * here, and do nothing if so. This seems to fix the problem.
- * - thomas 1997-07-13
- */
- if (strlen($1) > 0) {
-
- /*
- * The following implements char() and varchar().
- * We do it here instead of the 'typname:' production
- * because we don't want to allow arrays of varchar().
- * I haven't thought about whether that will work or not.
- * - ay 6/95
- */
- $$ = makeNode(TypeName);
- if (!strcasecmp($1, "char")) {
- $$->name = "bpchar"; /* strdup("bpchar"); */
- } else if (!strcasecmp($1, "varchar")) {
- $$->name = "varchar"; /* strdup("varchar"); */
- } else {
- yyerror("parse error");
- }
- if ($3 < 1) {
- elog(WARN, "length for '%s' type must be at least 1",
- $1);
- } else if ($3 > 4096) {
- /* we can store a char() of length up to the size
- * of a page (8KB) - page headers and friends but
- * just to be safe here... - ay 6/95
- * XXX note this hardcoded limit - thomas 1997-07-13
- */
- elog(WARN, "length for '%s' type cannot exceed 4096",
- $1);
- }
- /* we actually implement this sort of like a varlen, so
- * the first 4 bytes is the length. (the difference
- * between this and "text" is that we blank-pad and
- * truncate where necessary
- */
- $$->typlen = 4 + $3;
-
- }
- }
- ;
+ {
+ $$ = $1;
+ $$->arrayBounds = $2;
+ }
+ | txname '(' Iconst ')'
+ {
+ /*
+ * This block gets hit when the parser is passed a query
+ * which contains only spaces (e.g. from psql type " \g").
+ * Let's check explicitly for a zero-length argument
+ * here, and do nothing if so. This seems to fix the problem.
+ * - thomas 1997-07-13
+ */
+ if (strlen($1) > 0)
+ {
+
+ /*
+ * The following implements char() and varchar().
+ * We do it here instead of the 'typname:' production
+ * because we don't want to allow arrays of varchar().
+ * I haven't thought about whether that will work or not.
+ * - ay 6/95
+ */
+ $$ = makeNode(TypeName);
+ if (!strcasecmp($1, "char"))
+ $$->name = "bpchar"; /* strdup("bpchar"); */
+ else if (!strcasecmp($1, "varchar"))
+ $$->name = "varchar"; /* strdup("varchar"); */
+ else
+ yyerror("parse error");
+ if ($3 < 1)
+ elog(WARN, "length for '%s' type must be at least 1",$1);
+ else if ($3 > 4096)
+ /* we can store a char() of length up to the size
+ * of a page (8KB) - page headers and friends but
+ * just to be safe here... - ay 6/95
+ * XXX note this hardcoded limit - thomas 1997-07-13
+ */
+ elog(WARN, "length for '%s' type cannot exceed 4096",$1);
+
+ /* we actually implement this sort of like a varlen, so
+ * the first 4 bytes is the length. (the difference
+ * between this and "text" is that we blank-pad and
+ * truncate where necessary
+ */
+ $$->typlen = 4 + $3;
+
+ }
+ }
+ ;
/*****************************************************************************
*
- * expression grammar, still needs some cleanup
+ * expression grammar, still needs some cleanup
*
*****************************************************************************/
a_expr_or_null: a_expr
- { $$ = $1;}
- | Pnull
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_Null;
- $$ = (Node *)n;
- }
+ { $$ = $1;}
+ | Pnull
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Null;
+ $$ = (Node *)n;
+ }
a_expr: attr opt_indirection
- {
- $1->indirection = $2;
- $$ = (Node *)$1;
- }
- | AexprConst
- { $$ = $1; }
- | '-' a_expr %prec UMINUS
- { $$ = makeA_Expr(OP, "-", NULL, $2); }
- | a_expr '+' a_expr
- { $$ = makeA_Expr(OP, "+", $1, $3); }
- | a_expr '-' a_expr
- { $$ = makeA_Expr(OP, "-", $1, $3); }
- | a_expr '/' a_expr
- { $$ = makeA_Expr(OP, "/", $1, $3); }
- | a_expr '*' a_expr
- { $$ = makeA_Expr(OP, "*", $1, $3); }
- | a_expr '<' a_expr
- { $$ = makeA_Expr(OP, "<", $1, $3); }
- | a_expr '>' a_expr
- { $$ = makeA_Expr(OP, ">", $1, $3); }
- | a_expr '=' a_expr
- { $$ = makeA_Expr(OP, "=", $1, $3); }
- | ':' a_expr
- { $$ = makeA_Expr(OP, ":", NULL, $2); }
- | ';' a_expr
- { $$ = makeA_Expr(OP, ";", NULL, $2); }
- | '|' a_expr
- { $$ = makeA_Expr(OP, "|", NULL, $2); }
- | AexprConst TYPECAST Typename
- {
- /* AexprConst can be either A_Const or ParamNo */
- if (nodeTag($1) == T_A_Const) {
- ((A_Const *)$1)->typename = $3;
- }else {
- ((ParamNo *)$1)->typename = $3;
- }
- $$ = (Node *)$1;
- }
- | CAST AexprConst AS Typename
- {
- /* AexprConst can be either A_Const or ParamNo */
- if (nodeTag($2) == T_A_Const) {
- ((A_Const *)$2)->typename = $4;
- }else {
- ((ParamNo *)$2)->typename = $4;
- }
- $$ = (Node *)$2;
- }
- | '(' a_expr_or_null ')'
- { $$ = $2; }
- | a_expr Op a_expr
- { $$ = makeA_Expr(OP, $2, $1, $3); }
- | a_expr LIKE a_expr
- { $$ = makeA_Expr(OP, "~~", $1, $3); }
- | a_expr NOT LIKE a_expr
- { $$ = makeA_Expr(OP, "!~~", $1, $4); }
- | Op a_expr
- { $$ = makeA_Expr(OP, $1, NULL, $2); }
- | a_expr Op
- { $$ = makeA_Expr(OP, $2, $1, NULL); }
- | Id
- { /* could be a column name or a relation_name */
- Ident *n = makeNode(Ident);
- n->name = $1;
- n->indirection = NULL;
- $$ = (Node *)n;
- }
- | name '(' '*' ')'
- {
- FuncCall *n = makeNode(FuncCall);
- Ident *star = makeNode(Ident);
-
- /* cheap hack for aggregate (eg. count) */
- star->name = "oid";
- n->funcname = $1;
- n->args = lcons(star, NIL);
- $$ = (Node *)n;
- }
- | name '(' ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = $1;
- n->args = NIL;
- $$ = (Node *)n;
- }
- /* We probably need to define an "exists" node,
- * since the optimizer could choose to find only one match.
- * Perhaps the first implementation could just check for
- * count(*) > 0? - thomas 1997-07-19
- */
- | EXISTS '(' SubSelect ')'
- {
- elog(WARN,"EXISTS not yet supported",NULL);
- $$ = $3;
- }
- | EXTRACT '(' extract_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "date_part";
- n->args = $3;
- $$ = (Node *)n;
- }
- | POSITION '(' position_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "strpos";
- n->args = $3;
- $$ = (Node *)n;
- }
- | SUBSTRING '(' substr_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "substr";
- n->args = $3;
- $$ = (Node *)n;
- }
- /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
- | TRIM '(' BOTH trim_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "btrim";
- n->args = $4;
- $$ = (Node *)n;
- }
- | TRIM '(' LEADING trim_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "ltrim";
- n->args = $4;
- $$ = (Node *)n;
- }
- | TRIM '(' TRAILING trim_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "rtrim";
- n->args = $4;
- $$ = (Node *)n;
- }
- | TRIM '(' trim_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = "btrim";
- n->args = $3;
- $$ = (Node *)n;
- }
- | name '(' expr_list ')'
- {
- FuncCall *n = makeNode(FuncCall);
- n->funcname = $1;
- n->args = $3;
- $$ = (Node *)n;
- }
- | a_expr ISNULL
- { $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
- | a_expr IS PNULL
- { $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
- | a_expr NOTNULL
- { $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
- | a_expr IS NOT PNULL
- { $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
- | a_expr BETWEEN AexprConst AND AexprConst
- { $$ = makeA_Expr(AND, NULL,
- makeA_Expr(OP, ">=", $1, $3),
- makeA_Expr(OP, "<=", $1, $5));
- }
- | a_expr NOT BETWEEN AexprConst AND AexprConst
- { $$ = makeA_Expr(OR, NULL,
- makeA_Expr(OP, "<", $1, $4),
- makeA_Expr(OP, ">", $1, $6));
- }
- | a_expr IN { saved_In_Expr = $1; } '(' in_expr_nodes ')'
- { $$ = $5; }
- | a_expr NOT IN { saved_In_Expr = $1; } '(' not_in_expr_nodes ')'
- { $$ = $6; }
- | a_expr AND a_expr
- { $$ = makeA_Expr(AND, NULL, $1, $3); }
- | a_expr OR a_expr
- { $$ = makeA_Expr(OR, NULL, $1, $3); }
- | NOT a_expr
- { $$ = makeA_Expr(NOT, NULL, NULL, $2); }
- ;
+ {
+ $1->indirection = $2;
+ $$ = (Node *)$1;
+ }
+ | AexprConst
+ { $$ = $1; }
+ | '-' a_expr %prec UMINUS
+ { $$ = makeA_Expr(OP, "-", NULL, $2); }
+ | a_expr '+' a_expr
+ { $$ = makeA_Expr(OP, "+", $1, $3); }
+ | a_expr '-' a_expr
+ { $$ = makeA_Expr(OP, "-", $1, $3); }
+ | a_expr '/' a_expr
+ { $$ = makeA_Expr(OP, "/", $1, $3); }
+ | a_expr '*' a_expr
+ { $$ = makeA_Expr(OP, "*", $1, $3); }
+ | a_expr '<' a_expr
+ { $$ = makeA_Expr(OP, "<", $1, $3); }
+ | a_expr '>' a_expr
+ { $$ = makeA_Expr(OP, ">", $1, $3); }
+ | a_expr '=' a_expr
+ { $$ = makeA_Expr(OP, "=", $1, $3); }
+ | ':' a_expr
+ { $$ = makeA_Expr(OP, ":", NULL, $2); }
+ | ';' a_expr
+ { $$ = makeA_Expr(OP, ";", NULL, $2); }
+ | '|' a_expr
+ { $$ = makeA_Expr(OP, "|", NULL, $2); }
+ | AexprConst TYPECAST Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($1) == T_A_Const)
+ ((A_Const *)$1)->typename = $3;
+ else
+ ((ParamNo *)$1)->typename = $3;
+ $$ = (Node *)$1;
+ }
+ | CAST AexprConst AS Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($2) == T_A_Const)
+ ((A_Const *)$2)->typename = $4;
+ else
+ ((ParamNo *)$2)->typename = $4;
+ $$ = (Node *)$2;
+ }
+ | '(' a_expr_or_null ')'
+ { $$ = $2; }
+ | a_expr Op a_expr
+ { $$ = makeA_Expr(OP, $2, $1, $3); }
+ | a_expr LIKE a_expr
+ { $$ = makeA_Expr(OP, "~~", $1, $3); }
+ | a_expr NOT LIKE a_expr
+ { $$ = makeA_Expr(OP, "!~~", $1, $4); }
+ | Op a_expr
+ { $$ = makeA_Expr(OP, $1, NULL, $2); }
+ | a_expr Op
+ { $$ = makeA_Expr(OP, $2, $1, NULL); }
+ | Id
+ {
+ /* could be a column name or a relation_name */
+ Ident *n = makeNode(Ident);
+ n->name = $1;
+ n->indirection = NULL;
+ $$ = (Node *)n;
+ }
+ | name '(' '*' ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ Ident *star = makeNode(Ident);
+
+ /* cheap hack for aggregate (eg. count) */
+ star->name = "oid";
+ n->funcname = $1;
+ n->args = lcons(star, NIL);
+ $$ = (Node *)n;
+ }
+ | name '(' ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = NIL;
+ $$ = (Node *)n;
+ }
+ /* We probably need to define an "exists" node,
+ * since the optimizer could choose to find only one match.
+ * Perhaps the first implementation could just check for
+ * count(*) > 0? - thomas 1997-07-19
+ */
+ | EXISTS '(' SubSelect ')'
+ {
+ elog(WARN,"EXISTS not yet supported",NULL);
+ $$ = $3;
+ }
+ | EXTRACT '(' extract_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "date_part";
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ | POSITION '(' position_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "strpos";
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ | SUBSTRING '(' substr_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "substr";
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ /* various trim expressions are defined in SQL92 - thomas 1997-07-19 */
+ | TRIM '(' BOTH trim_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "btrim";
+ n->args = $4;
+ $$ = (Node *)n;
+ }
+ | TRIM '(' LEADING trim_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "ltrim";
+ n->args = $4;
+ $$ = (Node *)n;
+ }
+ | TRIM '(' TRAILING trim_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "rtrim";
+ n->args = $4;
+ $$ = (Node *)n;
+ }
+ | TRIM '(' trim_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = "btrim";
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ | name '(' expr_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ | a_expr ISNULL
+ { $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
+ | a_expr IS PNULL
+ { $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
+ | a_expr NOTNULL
+ { $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
+ | a_expr IS NOT PNULL
+ { $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
+ | a_expr BETWEEN AexprConst AND AexprConst
+ {
+ $$ = makeA_Expr(AND, NULL,
+ makeA_Expr(OP, ">=", $1, $3),
+ makeA_Expr(OP, "<=", $1, $5));
+ }
+ | a_expr NOT BETWEEN AexprConst AND AexprConst
+ {
+ $$ = makeA_Expr(OR, NULL,
+ makeA_Expr(OP, "<", $1, $4),
+ makeA_Expr(OP, ">", $1, $6));
+ }
+ | a_expr IN { saved_In_Expr = $1; } '(' in_expr_nodes ')'
+ { $$ = $5; }
+ | a_expr NOT IN { saved_In_Expr = $1; } '(' not_in_expr_nodes ')'
+ { $$ = $6; }
+ | a_expr AND a_expr
+ { $$ = makeA_Expr(AND, NULL, $1, $3); }
+ | a_expr OR a_expr
+ { $$ = makeA_Expr(OR, NULL, $1, $3); }
+ | NOT a_expr
+ { $$ = makeA_Expr(NOT, NULL, NULL, $2); }
+ ;
opt_indirection: '[' a_expr ']' opt_indirection
- {
- A_Indices *ai = makeNode(A_Indices);
- ai->lidx = NULL;
- ai->uidx = $2;
- $$ = lcons(ai, $4);
- }
- | '[' a_expr ':' a_expr ']' opt_indirection
- {
- A_Indices *ai = makeNode(A_Indices);
- ai->lidx = $2;
- ai->uidx = $4;
- $$ = lcons(ai, $6);
- }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ {
+ A_Indices *ai = makeNode(A_Indices);
+ ai->lidx = NULL;
+ ai->uidx = $2;
+ $$ = lcons(ai, $4);
+ }
+ | '[' a_expr ':' a_expr ']' opt_indirection
+ {
+ A_Indices *ai = makeNode(A_Indices);
+ ai->lidx = $2;
+ ai->uidx = $4;
+ $$ = lcons(ai, $6);
+ }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
expr_list: a_expr_or_null
- { $$ = lcons($1, NIL); }
- | expr_list ',' a_expr_or_null
- { $$ = lappend($1, $3); }
- | expr_list USING a_expr
- { $$ = lappend($1, $3); }
- ;
+ { $$ = lcons($1, NIL); }
+ | expr_list ',' a_expr_or_null
+ { $$ = lappend($1, $3); }
+ | expr_list USING a_expr
+ { $$ = lappend($1, $3); }
+ ;
extract_list: datetime FROM a_expr
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_String;
- n->val.val.str = $1;
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_String;
+ n->val.val.str = $1;
printf( "string is %s\n", $1);
- $$ = lappend(lcons((Node *)n,NIL), $3);
- }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ $$ = lappend(lcons((Node *)n,NIL), $3);
+ }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
position_list: a_expr IN expr_list
- {
- $$ = lappend($3, $1);
- }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ { $$ = lappend($3, $1); }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
substr_list: expr_list substr_from substr_for
- {
- $$ = $1;
- if ($2 != NULL) $$ = lappend($$, $2);
- if ($3 != NULL) $$ = lappend($$, $3);
- }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ {
+ $$ = $1;
+ if ($2 != NULL) $$ = lappend($$, $2);
+ if ($3 != NULL) $$ = lappend($$, $3);
+ }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
substr_from: FROM expr_list
- { $$ = $2; }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ { $$ = $2; }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
substr_for: FOR expr_list
- { $$ = $2; }
- | /* EMPTY */
- { $$ = NIL; }
- ;
+ { $$ = $2; }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
trim_list: a_expr FROM expr_list
- { $$ = lappend($3, $1); }
- | FROM expr_list
- { $$ = $2; }
- | expr_list
- { $$ = $1; }
- ;
+ { $$ = lappend($3, $1); }
+ | FROM expr_list
+ { $$ = $2; }
+ | expr_list
+ { $$ = $1; }
+ ;
in_expr_nodes: AexprConst
- { $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
- | in_expr_nodes ',' AexprConst
- { $$ = makeA_Expr(OR, NULL, $1,
- makeA_Expr(OP, "=", saved_In_Expr, $3));
- }
- ;
+ { $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
+ | in_expr_nodes ',' AexprConst
+ { $$ = makeA_Expr(OR, NULL, $1,
+ makeA_Expr(OP, "=", saved_In_Expr, $3));
+ }
+ ;
not_in_expr_nodes: AexprConst
- { $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
- | not_in_expr_nodes ',' AexprConst
- { $$ = makeA_Expr(AND, NULL, $1,
- makeA_Expr(OP, "<>", saved_In_Expr, $3));
- }
- ;
+ { $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
+ | not_in_expr_nodes ',' AexprConst
+ { $$ = makeA_Expr(AND, NULL, $1,
+ makeA_Expr(OP, "<>", saved_In_Expr, $3));
+ }
+ ;
attr: relation_name '.' attrs
- {
- $$ = makeNode(Attr);
- $$->relname = $1;
- $$->paramNo = NULL;
- $$->attrs = $3;
- $$->indirection = NULL;
- }
- | ParamNo '.' attrs
- {
- $$ = makeNode(Attr);
- $$->relname = NULL;
- $$->paramNo = $1;
- $$->attrs = $3;
- $$->indirection = NULL;
- }
- ;
-
-attrs: attr_name
- { $$ = lcons(makeString($1), NIL); }
- | attrs '.' attr_name
- { $$ = lappend($1, makeString($3)); }
- | attrs '.' '*'
- { $$ = lappend($1, makeString("*")); }
- ;
-
-datetime: YEARINTERVAL { $$ = "year"; }
- | MONTHINTERVAL { $$ = "month"; }
- | DAYINTERVAL { $$ = "day"; }
- | HOURINTERVAL { $$ = "hour"; }
- | MINUTEINTERVAL { $$ = "minute"; }
- | SECONDINTERVAL { $$ = "second"; }
- ;
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = $3;
+ $$->indirection = NULL;
+ }
+ | ParamNo '.' attrs
+ {
+ $$ = makeNode(Attr);
+ $$->relname = NULL;
+ $$->paramNo = $1;
+ $$->attrs = $3;
+ $$->indirection = NULL;
+ }
+ ;
+
+attrs: attr_name
+ { $$ = lcons(makeString($1), NIL); }
+ | attrs '.' attr_name
+ { $$ = lappend($1, makeString($3)); }
+ | attrs '.' '*'
+ { $$ = lappend($1, makeString("*")); }
+ ;
+
+datetime: YEARINTERVAL { $$ = "year"; }
+ | MONTHINTERVAL { $$ = "month"; }
+ | DAYINTERVAL { $$ = "day"; }
+ | HOURINTERVAL { $$ = "hour"; }
+ | MINUTEINTERVAL { $$ = "minute"; }
+ | SECONDINTERVAL { $$ = "second"; }
+ ;
/*****************************************************************************
*
- * target lists
+ * target lists
*
*****************************************************************************/
res_target_list: res_target_list ',' res_target_el
- { $$ = lappend($1,$3); }
- | res_target_el
- { $$ = lcons($1, NIL); }
- | '*'
- {
- ResTarget *rt = makeNode(ResTarget);
- Attr *att = makeNode(Attr);
- att->relname = "*";
- att->paramNo = NULL;
- att->attrs = NULL;
- att->indirection = NIL;
- rt->name = NULL;
- rt->indirection = NULL;
- rt->val = (Node *)att;
- $$ = lcons(rt, NIL);
- }
- ;
+ { $$ = lappend($1,$3); }
+ | res_target_el
+ { $$ = lcons($1, NIL); }
+ | '*'
+ {
+ ResTarget *rt = makeNode(ResTarget);
+ Attr *att = makeNode(Attr);
+ att->relname = "*";
+ att->paramNo = NULL;
+ att->attrs = NULL;
+ att->indirection = NIL;
+ rt->name = NULL;
+ rt->indirection = NULL;
+ rt->val = (Node *)att;
+ $$ = lcons(rt, NIL);
+ }
+ ;
res_target_el: Id opt_indirection '=' a_expr_or_null
- {
- $$ = makeNode(ResTarget);
- $$->name = $1;
- $$->indirection = $2;
- $$->val = (Node *)$4;
- }
- | attr opt_indirection
- {
- $$ = makeNode(ResTarget);
- $$->name = NULL;
- $$->indirection = $2;
- $$->val = (Node *)$1;
- }
- | relation_name '.' '*'
- {
- Attr *att = makeNode(Attr);
- att->relname = $1;
- att->paramNo = NULL;
- att->attrs = lcons(makeString("*"), NIL);
- att->indirection = NIL;
- $$ = makeNode(ResTarget);
- $$->name = NULL;
- $$->indirection = NULL;
- $$->val = (Node *)att;
- }
- ;
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = $1;
+ $$->indirection = $2;
+ $$->val = (Node *)$4;
+ }
+ | attr opt_indirection
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = $2;
+ $$->val = (Node *)$1;
+ }
+ | relation_name '.' '*'
+ {
+ Attr *att = makeNode(Attr);
+ att->relname = $1;
+ att->paramNo = NULL;
+ att->attrs = lcons(makeString("*"), NIL);
+ att->indirection = NIL;
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)att;
+ }
+ ;
/*
** target list for select.
** and update (uses a subset)
*/
res_target_list2: res_target_list2 ',' res_target_el2
- { $$ = lappend($1, $3); }
- | res_target_el2
- { $$ = lcons($1, NIL); }
- ;
+ { $$ = lappend($1, $3); }
+ | res_target_el2
+ { $$ = lcons($1, NIL); }
+ ;
/* AS is not optional because shift/red conflict with unary ops */
res_target_el2: a_expr AS ColId
- {
- $$ = makeNode(ResTarget);
- $$->name = $3;
- $$->indirection = NULL;
- $$->val = (Node *)$1;
- }
- | a_expr_or_null
- {
- $$ = makeNode(ResTarget);
- $$->name = NULL;
- $$->indirection = NULL;
- $$->val = (Node *)$1;
- }
- | relation_name '.' '*'
- {
- Attr *att = makeNode(Attr);
- att->relname = $1;
- att->paramNo = NULL;
- att->attrs = lcons(makeString("*"), NIL);
- att->indirection = NIL;
- $$ = makeNode(ResTarget);
- $$->name = NULL;
- $$->indirection = NULL;
- $$->val = (Node *)att;
- }
- | '*'
- {
- Attr *att = makeNode(Attr);
- att->relname = "*";
- att->paramNo = NULL;
- att->attrs = NULL;
- att->indirection = NIL;
- $$ = makeNode(ResTarget);
- $$->name = NULL;
- $$->indirection = NULL;
- $$->val = (Node *)att;
- }
- ;
-
-opt_id: Id { $$ = $1; }
- | /* EMPTY */ { $$ = NULL; }
- ;
-
-relation_name: SpecialRuleRelation
- {
- $$ = $1;
- strNcpy(saved_relname, $1, NAMEDATALEN-1);
- }
- | ColId
- {
- /* disallow refs to magic system tables */
- if (strcmp(LogRelationName, $1) == 0
- || strcmp(VariableRelationName, $1) == 0
- || strcmp(TimeRelationName, $1) == 0
- || strcmp(MagicRelationName, $1) == 0) {
- elog(WARN, "%s cannot be accessed by users", $1);
- } else {
- $$ = $1;
- }
- strNcpy(saved_relname, $1, NAMEDATALEN-1);
- }
- ;
-
-database_name: Id { $$ = $1; };
-access_method: Id { $$ = $1; };
-attr_name: ColId { $$ = $1; };
-class: Id { $$ = $1; };
-index_name: Id { $$ = $1; };
-var_name: Id { $$ = $1; };
-name: Id { $$ = $1; };
-
-date: Sconst { $$ = $1; };
-file_name: Sconst { $$ = $1; };
-recipe_name: Id { $$ = $1; };
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = $3;
+ $$->indirection = NULL;
+ $$->val = (Node *)$1;
+ }
+ | a_expr_or_null
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)$1;
+ }
+ | relation_name '.' '*'
+ {
+ Attr *att = makeNode(Attr);
+ att->relname = $1;
+ att->paramNo = NULL;
+ att->attrs = lcons(makeString("*"), NIL);
+ att->indirection = NIL;
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)att;
+ }
+ | '*'
+ {
+ Attr *att = makeNode(Attr);
+ att->relname = "*";
+ att->paramNo = NULL;
+ att->attrs = NULL;
+ att->indirection = NIL;
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)att;
+ }
+ ;
+
+opt_id: Id { $$ = $1; }
+ | /* EMPTY */ { $$ = NULL; }
+ ;
+
+relation_name: SpecialRuleRelation
+ {
+ $$ = $1;
+ strNcpy(saved_relname, $1, NAMEDATALEN-1);
+ }
+ | ColId
+ {
+ /* disallow refs to magic system tables */
+ if (strcmp(LogRelationName, $1) == 0
+ || strcmp(VariableRelationName, $1) == 0
+ || strcmp(TimeRelationName, $1) == 0
+ || strcmp(MagicRelationName, $1) == 0)
+ elog(WARN, "%s cannot be accessed by users", $1);
+ else
+ $$ = $1;
+ strNcpy(saved_relname, $1, NAMEDATALEN-1);
+ }
+ ;
+
+database_name: Id { $$ = $1; };
+access_method: Id { $$ = $1; };
+attr_name: ColId { $$ = $1; };
+class: Id { $$ = $1; };
+index_name: Id { $$ = $1; };
+var_name: Id { $$ = $1; };
+name: Id { $$ = $1; };
+
+date: Sconst { $$ = $1; };
+file_name: Sconst { $$ = $1; };
+recipe_name: Id { $$ = $1; };
AexprConst: Iconst
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_Integer;
- n->val.val.ival = $1;
- $$ = (Node *)n;
- }
- | FCONST
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_Float;
- n->val.val.dval = $1;
- $$ = (Node *)n;
- }
- | Sconst
- {
- A_Const *n = makeNode(A_Const);
- n->val.type = T_String;
- n->val.val.str = $1;
- $$ = (Node *)n;
- }
- | ParamNo
- { $$ = (Node *)$1; }
- ;
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Integer;
+ n->val.val.ival = $1;
+ $$ = (Node *)n;
+ }
+ | FCONST
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Float;
+ n->val.val.dval = $1;
+ $$ = (Node *)n;
+ }
+ | Sconst
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_String;
+ n->val.val.str = $1;
+ $$ = (Node *)n;
+ }
+ | ParamNo
+ { $$ = (Node *)$1; }
+ ;
ParamNo: PARAM
- {
- $$ = makeNode(ParamNo);
- $$->number = $1;
- }
- ;
+ {
+ $$ = makeNode(ParamNo);
+ $$->number = $1;
+ }
+ ;
-NumConst: Iconst { $$ = makeInteger($1); }
- | FCONST { $$ = makeFloat($1); }
- ;
+NumConst: Iconst { $$ = makeInteger($1); }
+ | FCONST { $$ = makeFloat($1); }
+ ;
-Iconst: ICONST { $$ = $1; };
-Sconst: SCONST { $$ = $1; };
+Iconst: ICONST { $$ = $1; };
+Sconst: SCONST { $$ = $1; };
-Id: IDENT { $$ = $1; };
+Id: IDENT { $$ = $1; };
-ColId: Id { $$ = $1; }
- | datetime { $$ = $1; }
- ;
+ColId: Id { $$ = $1; }
+ | datetime { $$ = $1; }
+ ;
SpecialRuleRelation: CURRENT
- {
- if (QueryIsRule)
- $$ = "*CURRENT*";
- else
- elog(WARN,"CURRENT used in non-rule query");
- }
- | NEW
- {
- if (QueryIsRule)
- $$ = "*NEW*";
- else
- elog(WARN,"NEW used in non-rule query");
- }
- ;
+ {
+ if (QueryIsRule)
+ $$ = "*CURRENT*";
+ else
+ elog(WARN,"CURRENT used in non-rule query");
+ }
+ | NEW
+ {
+ if (QueryIsRule)
+ $$ = "*NEW*";
+ else
+ elog(WARN,"NEW used in non-rule query");
+ }
+ ;
Type: P_TYPE;
Pnull: PNULL;
static Node *makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
{
- A_Expr *a = makeNode(A_Expr);
- a->oper = oper;
- a->opname = opname;
- a->lexpr = lexpr;
- a->rexpr = rexpr;
- return (Node *)a;
+ A_Expr *a = makeNode(A_Expr);
+ a->oper = oper;
+ a->opname = opname;
+ a->lexpr = lexpr;
+ a->rexpr = rexpr;
+ return (Node *)a;
}
static char *
xlateSqlType(char *name)
{
- if (!strcasecmp(name,"int") ||
- !strcasecmp(name,"integer"))
- return "int4"; /* strdup("int4") -- strdup leaks memory here */
- else if (!strcasecmp(name, "smallint"))
- return "int2";
- else if (!strcasecmp(name, "float") ||
- !strcasecmp(name, "real"))
- return "float8";
- else if (!strcasecmp(name, "interval"))
- return "timespan";
- else
- return name;
+ if (!strcasecmp(name,"int") ||
+ !strcasecmp(name,"integer"))
+ return "int4"; /* strdup("int4") -- strdup leaks memory here */
+ else if (!strcasecmp(name, "smallint"))
+ return "int2";
+ else if (!strcasecmp(name, "float") ||
+ !strcasecmp(name, "real"))
+ return "float8";
+ else if (!strcasecmp(name, "interval"))
+ return "timespan";
+ else
+ return name;
}
void parser_init(Oid *typev, int nargs)
{
- QueryIsRule = false;
- saved_relname[0]= '\0';
- saved_In_Expr = NULL;
+ QueryIsRule = false;
+ saved_relname[0]= '\0';
+ saved_In_Expr = NULL;
- param_type_init(typev, nargs);
+ param_type_init(typev, nargs);
}
-
projects / postgresql / commitdiff