*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.62 1997/11/02 15:25:26 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.63 1997/11/07 07:02:07 thomas Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
ReplaceStmt, AppendStmt, NotifyStmt, DeleteStmt, ClusterStmt,
ExplainStmt, VariableSetStmt, VariableShowStmt, VariableResetStmt
+%type opt_database, location
+
%type SubSelect
%type join_expr, join_outer, join_spec
%type TriggerActionTime, TriggerForSpec, PLangTrusted
MATCH, MINUTE_P, MONTH_P,
NATIONAL, NATURAL, NCHAR, NO, NOT, NOTIFY, NOTNULL, NULL_P, NUMERIC,
ON, OPTION, OR, ORDER, OUTER_P,
- PARTIAL, PRECISION, POSITION, PRIMARY, PRIVILEGES, PROCEDURE, PUBLIC,
+ PARTIAL, POSITION, PRECISION, PRIMARY, PRIVILEGES, PROCEDURE, PUBLIC,
REFERENCES, REVOKE, RIGHT, ROLLBACK,
SECOND_P, SELECT, SET, SUBSTRING,
TABLE, TIME, TIMESTAMP, TO, TRAILING, TRANSACTION, TRIM,
DATABASE, DELIMITERS, DO, EXPLAIN, EXTEND,
FORWARD, FUNCTION, HANDLER, HEAVY,
INDEX, INHERITS, INSTEAD, ISNULL,
- LANCOMPILER, LIGHT, LISTEN, LOAD, MERGE, MOVE,
+ LANCOMPILER, LIGHT, LISTEN, LOAD, LOCATION, MERGE, MOVE,
NEW, NONE, NOTHING, OIDS, OPERATOR, PROCEDURAL, PURGE,
RECIPE, RENAME, REPLACE, RESET, RETRIEVE, RETURNS, RULE,
SEQUENCE, SETOF, SHOW, STDIN, STDOUT, STORE, TRUSTED,
%left UNION
%%
-stmtblock: stmtmulti
+stmtblock: stmtmulti
{ parsetree = $1; }
- | stmt
+ | stmt
{ parsetree = lcons($1,NIL); }
;
-stmtmulti: stmtmulti stmt ';'
+stmtmulti: stmtmulti stmt ';'
{ $$ = lappend($1, $2); }
- | stmtmulti stmt
+ | stmtmulti stmt
{ $$ = lappend($1, $2); }
- | stmt ';'
+ | stmt ';'
{ $$ = lcons($1,NIL); }
;
n->value = $4;
$$ = (Node *) n;
}
- | SET ColId '=' var_value
+ | SET ColId '=' var_value
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = $2;
n->value = $4;
$$ = (Node *) n;
}
- | SET TIME ZONE zone_value
+ | SET TIME ZONE zone_value
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "timezone";
;
var_value: Sconst { $$ = $1; }
+ | DEFAULT { $$ = NULL; }
;
zone_value: Sconst { $$ = $1; }
+ | DEFAULT { $$ = NULL; }
| LOCAL { $$ = "default"; }
;
{
$$ = FlattenStringList($2);
}
- | /*EMPTY*/ { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; }
;
default_expr: AexprConst
copy_dirn: TO
{ $$ = TO; }
- | FROM
+ | FROM
{ $$ = FROM; }
;
| STDOUT { $$ = NULL; }
;
-opt_binary: BINARY { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_binary: BINARY { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
opt_with_copy: WITH OIDS { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
+ | /* EMPTY */ { $$ = FALSE; }
;
/*
* the default copy delimiter is tab but the user can configure it
*/
-copy_delimiter: USING DELIMITERS Sconst { $$ = $3;}
+copy_delimiter: USING DELIMITERS Sconst { $$ = $3;}
| /* EMPTY */ { $$ = "\t"; }
;
{ $$ = -1; }
;
-OptArchiveLocation: ARCH_STORE '=' Sconst
+OptArchiveLocation: ARCH_STORE '=' Sconst
{ $$ = smgrin($3); }
| /*EMPTY*/
{ $$ = -1; }
;
OptInherit: INHERITS '(' relation_name_list ')' { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
+ | /*EMPTY*/ { $$ = NIL; }
;
OptConstraint: ConstraintList { $$ = $1; }
*
*****************************************************************************/
-CreatePLangStmt: CREATE PLangTrusted PROCEDURAL LANGUAGE Sconst
+CreatePLangStmt: CREATE PLangTrusted PROCEDURAL LANGUAGE Sconst
HANDLER def_name LANCOMPILER Sconst
{
CreatePLangStmt *n = makeNode(CreatePLangStmt);
PLangTrusted: TRUSTED { $$ = TRUE; }
| { $$ = FALSE; }
-DropPLangStmt: DROP PROCEDURAL LANGUAGE Sconst
+DropPLangStmt: DROP PROCEDURAL LANGUAGE Sconst
{
DropPLangStmt *n = makeNode(DropPLangStmt);
n->plname = $4;
*
*****************************************************************************/
-CreateTrigStmt: CREATE TRIGGER name TriggerActionTime TriggerEvents ON
+CreateTrigStmt: CREATE TRIGGER name TriggerActionTime TriggerEvents ON
relation_name TriggerForSpec EXECUTE PROCEDURE
name '(' TriggerFuncArgs ')'
{
| UPDATE { $$ = 'u'; }
;
-TriggerForSpec: FOR name name
+TriggerForSpec: FOR name name
{
if ( strcmp ($2, "each") != 0 )
elog(WARN,"parser: syntax error near %s",$2);
}
;
-TriggerFuncArgs: TriggerFuncArg
+TriggerFuncArgs: TriggerFuncArg
{ $$ = lcons($1, NIL); }
- | TriggerFuncArgs ',' TriggerFuncArg
+ | TriggerFuncArgs ',' TriggerFuncArg
{ $$ = lappend($1, $3); }
- | /* EMPTY */ { $$ = NIL; }
+ | /*EMPTY*/
+ { $$ = NIL; }
;
-TriggerFuncArg: ICONST
+TriggerFuncArg: ICONST
{
char *s = (char *) palloc (256);
sprintf (s, "%d", $1);
;
def_type: OPERATOR { $$ = OPERATOR; }
- | Type
+ | Type
{
#ifdef PARSEDEBUG
printf("def_type: decoding TYPE_P\n");
#endif
$$ = TYPE_P;
}
- | AGGREGATE { $$ = AGGREGATE; }
+ | AGGREGATE { $$ = AGGREGATE; }
;
def_name: PROCEDURE { $$ = "procedure"; }
- | ColId { $$ = $1; }
- | MathOp { $$ = $1; }
- | Op { $$ = $1; }
+ | JOIN { $$ = "join"; }
+ | ColId { $$ = $1; }
+ | MathOp { $$ = $1; }
+ | Op { $$ = $1; }
;
definition: '(' def_list ')' { $$ = $2; }
;
def_list: def_elem { $$ = lcons($1, NIL); }
- | def_list ',' def_elem { $$ = lappend($1, $3); }
+ | def_list ',' def_elem { $$ = lappend($1, $3); }
;
def_elem: def_name '=' def_arg
$$->defname = $1;
$$->arg = (Node *)$3;
}
- | def_name
+ | def_name
{
#ifdef PARSEDEBUG
printf("def_elem: decoding %s\n", $1);
$$->defname = $1;
$$->arg = (Node *)NULL;
}
- | DEFAULT '=' def_arg
+ | DEFAULT '=' def_arg
{
#ifdef PARSEDEBUG
printf("def_elem: decoding DEFAULT =\n");
fetch_how_many: Iconst
{ $$ = $1;
if ($1 <= 0) elog(WARN,"Please specify nonnegative count for fetch",NULL); }
- | ALL { $$ = 0; /* 0 means fetch all tuples*/}
- | /*EMPTY*/ { $$ = 1; /*default*/ }
+ | ALL { $$ = 0; /* 0 means fetch all tuples*/}
+ | /*EMPTY*/ { $$ = 1; /*default*/ }
;
-opt_portal_name: IN name { $$ = $2;}
+opt_portal_name: IN name { $$ = $2;}
| /*EMPTY*/ { $$ = NULL; }
;
*
*****************************************************************************/
-RevokeStmt: REVOKE privileges ON relation_name_list FROM grantee
+RevokeStmt: REVOKE privileges ON relation_name_list FROM grantee
{
$$ = (Node*)makeAclStmt($2,$4,$6,'-');
free($2);
| index_elem { $$ = lcons($1, NIL); }
;
-func_index: name '(' name_list ')' opt_type opt_class
+func_index: name '(' name_list ')' opt_type opt_class
{
$$ = makeNode(IndexElem);
$$->name = $1;
* for Typename of "TIMESTAMP WITH TIME ZONE"
* So, remove "WITH class" from the syntax. OK??
* - thomas 1997-10-12
- * | WITH class { $$ = $2; }
+ * | WITH class { $$ = $2; }
*/
opt_class: class { $$ = $1; }
- | USING class { $$ = $2; }
+ | USING class { $$ = $2; }
| /*EMPTY*/ { $$ = NULL; }
;
};
opt_with: WITH definition { $$ = $2; }
- | /* EMPTY */ { $$ = NIL; }
+ | /* EMPTY */ { $$ = NIL; }
;
def_args: '(' def_name_list ')' { $$ = $2; }
- | '(' ')' { $$ = NIL; }
+ | '(' ')' { $$ = NIL; }
;
def_name_list: name_list;
$$->beforeDate = $1;
$$->afterDate = NULL;
}
- | after_clause
+ | after_clause
{
$$ = makeNode(PurgeStmt);
$$->beforeDate = NULL;
$$->afterDate = $1;
}
- | before_clause after_clause
+ | before_clause after_clause
{
$$ = makeNode(PurgeStmt);
$$->beforeDate = $1;
$$->afterDate = $2;
}
- | after_clause before_clause
+ | after_clause before_clause
{
$$ = makeNode(PurgeStmt);
$$->beforeDate = $2;
$$->afterDate = $1;
}
- | /*EMPTY*/
+ | /*EMPTY*/
{
$$ = makeNode(PurgeStmt);
$$->beforeDate = NULL;
;
remove_type: Type { $$ = TYPE_P; }
- | INDEX { $$ = INDEX; }
- | RULE { $$ = RULE; }
- | VIEW { $$ = VIEW; }
+ | INDEX { $$ = INDEX; }
+ | RULE { $$ = RULE; }
+ | VIEW { $$ = VIEW; }
;
RemoveAggrStmt: DROP AGGREGATE name aggr_argtype
;
aggr_argtype: name { $$ = $1; }
- | '*' { $$ = NULL; }
+ | '*' { $$ = NULL; }
;
RemoveFuncStmt: DROP FUNCTION name '(' func_argtypes ')'
;
func_argtypes: name_list { $$ = $1; }
- | /*EMPTY*/ { $$ = NIL; }
+ | /*EMPTY*/ { $$ = NIL; }
;
RemoveOperStmt: DROP OPERATOR all_Op '(' oper_argtypes ')'
}
;
-all_Op: Op | MathOp;
+all_Op: Op | MathOp;
MathOp: '+' { $$ = "+"; }
- | '-' { $$ = "-"; }
- | '*' { $$ = "*"; }
- | '/' { $$ = "/"; }
- | '<' { $$ = "<"; }
- | '>' { $$ = ">"; }
- | '=' { $$ = "="; }
+ | '-' { $$ = "-"; }
+ | '*' { $$ = "*"; }
+ | '/' { $$ = "/"; }
+ | '<' { $$ = "<"; }
+ | '>' { $$ = ">"; }
+ | '=' { $$ = "="; }
;
oper_argtypes: name
;
opt_name: name { $$ = $1; }
- | /*EMPTY*/ { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; }
;
opt_column: COLUMN { $$ = COLUMN; }
OptStmtBlock: OptStmtMulti
{ $$ = $1; }
- | OptimizableStmt
+ | OptimizableStmt
{ $$ = lcons($1, NIL); }
;
OptStmtMulti: OptStmtMulti OptimizableStmt ';'
{ $$ = lappend($1, $2); }
- | OptStmtMulti OptimizableStmt
+ | OptStmtMulti OptimizableStmt
{ $$ = lappend($1, $2); }
- | OptimizableStmt ';'
+ | OptimizableStmt ';'
{ $$ = lcons($1, NIL); }
;
-event_object: relation_name '.' attr_name
+event_object: relation_name '.' attr_name
{
$$ = makeNode(Attr);
$$->relname = $1;
*
*****************************************************************************/
-NotifyStmt: NOTIFY relation_name
+NotifyStmt: NOTIFY relation_name
{
NotifyStmt *n = makeNode(NotifyStmt);
n->relname = $2;
}
;
-ListenStmt: LISTEN relation_name
+ListenStmt: LISTEN relation_name
{
ListenStmt *n = makeNode(ListenStmt);
n->relname = $2;
*
*****************************************************************************/
-LoadStmt: LOAD file_name
+LoadStmt: LOAD file_name
{
LoadStmt *n = makeNode(LoadStmt);
n->filename = $2;
*
*****************************************************************************/
-CreatedbStmt: CREATE DATABASE database_name
+CreatedbStmt: CREATE DATABASE database_name opt_database
{
CreatedbStmt *n = makeNode(CreatedbStmt);
n->dbname = $3;
+ n->dbpath = $4;
$$ = (Node *)n;
}
;
+opt_database: WITH LOCATION '=' location { $$ = $4; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+location: Sconst { $$ = $1; }
+ | DEFAULT { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
/*****************************************************************************
*
| /* EMPTY */ { $$ = FALSE; }
;
-opt_va_list: '(' va_list ')'
+opt_va_list: '(' va_list ')'
{ $$ = $2; }
| /* EMPTY */
{ $$ = NIL; }
;
-va_list: name
+va_list: name
{ $$=lcons($1,NIL); }
| va_list ',' name
{ $$=lappend($1,$3); }
}
;
-insert_rest: VALUES '(' res_target_list2 ')'
+insert_rest: VALUES '(' res_target_list2 ')'
{
$$ = makeNode(AppendStmt);
$$->targetList = $3;
}
;
-opt_column_list: '(' columnList ')' { $$ = $2; }
+opt_column_list: '(' columnList ')' { $$ = $2; }
| /*EMPTY*/ { $$ = NIL; }
;
{ $$ = lcons($1, NIL); }
;
-columnElem: ColId opt_indirection
+columnElem: ColId opt_indirection
{
Ident *id = makeNode(Ident);
id->name = $1;
;
sort_clause: ORDER BY sortby_list { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
+ | /*EMPTY*/ { $$ = NIL; }
;
sortby_list: sortby { $$ = lcons($1, NIL); }
from_list: from_list ',' from_val
{ $$ = lappend($1, $3); }
- | from_val CROSS JOIN from_val
+ | from_val CROSS JOIN from_val
{ elog(WARN,"CROSS JOIN not yet implemented",NULL); }
- | from_val
+ | from_val
{ $$ = lcons($1, NIL); }
;
| /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
;
-join_list: join_using { $$ = lcons($1, NIL); }
+join_list: join_using { $$ = lcons($1, NIL); }
| join_list ',' join_using { $$ = lappend($1, $3); }
;
;
opt_range_start: date
- | /*EMPTY*/ { $$ = "epoch"; }
+ | /*EMPTY*/ { $$ = "epoch"; }
;
opt_range_end: date
- | /*EMPTY*/ { $$ = "now"; }
+ | /*EMPTY*/ { $$ = "now"; }
;
opt_array_bounds: '[' ']' nest_array_bounds
*
*****************************************************************************/
-a_expr_or_null: a_expr
+a_expr_or_null: a_expr
{ $$ = $1;}
| Pnull
{
$$ = (Node *)n;
}
- | CURRENT_USER
+ | CURRENT_USER
{
FuncCall *n = makeNode(FuncCall);
n->funcname = "getpgusername";
{ $$ = NIL; }
;
-expr_list: a_expr_or_null
+expr_list: a_expr_or_null
{ $$ = lcons($1, NIL); }
- | expr_list ',' a_expr_or_null
+ | expr_list ',' a_expr_or_null
{ $$ = lappend($1, $3); }
- | expr_list USING a_expr
+ | expr_list USING a_expr
{ $$ = lappend($1, $3); }
;
-extract_list: datetime FROM a_expr
+extract_list: datetime FROM a_expr
{
A_Const *n = makeNode(A_Const);
n->val.type = T_String;
{ $$ = NIL; }
;
-position_list: position_expr IN position_expr
+position_list: position_expr IN position_expr
{ $$ = makeList($3, $1, -1); }
| /* EMPTY */
{ $$ = NIL; }
}
;
-substr_list: expr_list substr_from substr_for
+substr_list: expr_list substr_from substr_for
{
$$ = nconc(nconc($1,$2),$3);
}
{ $$ = NIL; }
;
-substr_from: FROM expr_list
+substr_from: FROM expr_list
{ $$ = $2; }
| /* EMPTY */
{
}
;
-substr_for: FOR expr_list
+substr_for: FOR expr_list
{ $$ = $2; }
| /* EMPTY */
{ $$ = NIL; }
;
-trim_list: a_expr FROM expr_list
+trim_list: a_expr FROM expr_list
{ $$ = lappend($3, $1); }
- | FROM expr_list
+ | FROM expr_list
{ $$ = $2; }
- | expr_list
+ | expr_list
{ $$ = $1; }
;
{ $$ = $1; }
;
-in_expr_nodes: AexprConst
+in_expr_nodes: AexprConst
{ $$ = makeA_Expr(OP, "=", saved_In_Expr, $1); }
- | in_expr_nodes ',' AexprConst
+ | in_expr_nodes ',' AexprConst
{ $$ = makeA_Expr(OR, NULL, $1,
makeA_Expr(OP, "=", saved_In_Expr, $3));
}
{ $$ = $1; }
;
-not_in_expr_nodes: AexprConst
+not_in_expr_nodes: AexprConst
{ $$ = makeA_Expr(OP, "<>", saved_In_Expr, $1); }
- | not_in_expr_nodes ',' AexprConst
+ | not_in_expr_nodes ',' AexprConst
{ $$ = makeA_Expr(AND, NULL, $1,
makeA_Expr(OP, "<>", saved_In_Expr, $3));
}
}
;
-res_target_el: ColId opt_indirection '=' a_expr_or_null
+res_target_el: ColId opt_indirection '=' a_expr_or_null
{
$$ = makeNode(ResTarget);
$$->name = $1;
** should get rid of the other but is still needed by the defunct retrieve into
** and update (uses a subset)
*/
-res_target_list2: res_target_list2 ',' res_target_el2
+res_target_list2: res_target_list2 ',' res_target_el2
{ $$ = 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_or_null AS ColLabel
+res_target_el2: a_expr_or_null AS ColLabel
{
$$ = makeNode(ResTarget);
$$->name = $3;
;
NumConst: Iconst { $$ = makeInteger($1); }
- | FCONST { $$ = makeFloat($1); }
+ | FCONST { $$ = makeFloat($1); }
;
Iconst: ICONST { $$ = $1; };
/* Column identifier
* Include date/time keywords as SQL92 extension.
* Include TYPE as a SQL92 unreserved keyword. - thomas 1997-10-05
+ * Add other keywords. Note that as the syntax expands,
+ * some of these keywords will have to be removed from this
+ * list due to shift/reduce conflicts in yacc. If so, move
+ * down to the ColLabel entity. - thomas 1997-11-06
*/
ColId: Id { $$ = $1; }
| datetime { $$ = $1; }
+ | ACTION { $$ = "action"; }
+ | DATABASE { $$ = "database"; }
+ | DELIMITERS { $$ = "delimiters"; }
+ | FUNCTION { $$ = "function"; }
+ | INDEX { $$ = "index"; }
+ | KEY { $$ = "key"; }
+ | LANGUAGE { $$ = "language"; }
+ | LIGHT { $$ = "light"; }
+ | LOCATION { $$ = "location"; }
+ | MATCH { $$ = "match"; }
+ | OPERATOR { $$ = "operator"; }
+ | OPTION { $$ = "option"; }
+ | PRIVILEGES { $$ = "privileges"; }
+ | RECIPE { $$ = "recipe"; }
| TIME { $$ = "time"; }
+ | TRIGGER { $$ = "trigger"; }
| TYPE_P { $$ = "type"; }
+ | VERSION { $$ = "version"; }
+ | ZONE { $$ = "zone"; }
;
/* Column label
* compatibility. Cannot allow this for column names since the
* syntax would not distinguish between the constant value and
* a column name. - thomas 1997-10-24
+ * Add other keywords to this list. Note that they appear here
+ * rather than in ColId if there was a shift/reduce conflict
+ * when used as a full identifier. - thomas 1997-11-06
*/
ColLabel: ColId { $$ = $1; }
+ | ARCHIVE { $$ = "archive"; }
+ | CLUSTER { $$ = "cluster"; }
+ | CONSTRAINT { $$ = "constraint"; }
+ | CROSS { $$ = "cross"; }
+ | FOREIGN { $$ = "foreign"; }
+ | GROUP { $$ = "group"; }
+ | LOAD { $$ = "load"; }
+ | ORDER { $$ = "order"; }
+ | POSITION { $$ = "position"; }
+ | PRECISION { $$ = "precision"; }
+ | STORE { $$ = "store"; }
+ | TABLE { $$ = "table"; }
+ | TRANSACTION { $$ = "transaction"; }
| TRUE_P { $$ = "true"; }
| FALSE_P { $$ = "false"; }
;
static char *
xlateSqlType(char *name)
{
- if (!strcasecmp(name,"int") ||
- !strcasecmp(name,"integer"))
+ if (!strcasecmp(name,"int")
+ || !strcasecmp(name,"integer"))
return "int4";
else if (!strcasecmp(name, "smallint"))
return "int2";
projects / postgresql.git / commitdiff