-%{
+ %{
/*#define YYDEBUG 1*/
/*-------------------------------------------------------------------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.325 2002/06/17 07:00:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.326 2002/06/17 20:27:43 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
%type <node> select_no_parens, select_with_parens, select_clause,
simple_select
-%type <node> alter_column_default
-%type <ival> add_drop, drop_behavior, opt_drop_behavior
+%type <node> alter_column_default
+%type <ival> add_drop, drop_behavior, opt_drop_behavior
%type <list> createdb_opt_list, createdb_opt_item
-%type <boolean> opt_equal
+%type <boolean> opt_equal
%type <ival> opt_lock, lock_type
-%type <boolean> opt_force, opt_or_replace
+%type <boolean> opt_force, opt_or_replace
%type <list> user_list
%type <str> OptSchemaName
%type <list> OptSchemaEltList
-%type <boolean> TriggerActionTime, TriggerForSpec, opt_trusted, opt_procedural
+%type <boolean> TriggerActionTime, TriggerForSpec, opt_trusted, opt_procedural
%type <str> opt_lancompiler
%type <str> TriggerEvents
%type <value> TriggerFuncArg
%type <str> relation_name, copy_file_name, copy_delimiter, copy_null,
- database_name, access_method_clause, access_method, attr_name,
- index_name, name, function_name, file_name
+ database_name, access_method_clause, access_method, attr_name,
+ index_name, name, function_name, file_name
%type <list> func_name, handler_name, qual_Op, qual_all_Op, OptUseOp,
- opt_class, opt_validator
+ opt_class, opt_validator
%type <range> qualified_name, OptConstrFromTable
-%type <str> opt_id,
- all_Op, MathOp, opt_name, SpecialRuleRelation
+%type <str> opt_id, all_Op, MathOp, opt_name, SpecialRuleRelation
%type <str> opt_level, opt_encoding
%type <node> grantee
%type <privtarget> privilege_target
%type <node> function_with_argtypes
%type <list> function_with_argtypes_list
-%type <chr> TriggerOneEvent
+%type <chr> TriggerOneEvent
%type <list> stmtblock, stmtmulti,
- OptTableElementList, OptInherit, definition,
- opt_distinct, opt_definition, func_args,
- func_args_list, func_as, createfunc_opt_list
- oper_argtypes, RuleActionList, RuleActionMulti,
- opt_column_list, columnList, opt_name_list,
- sort_clause, sortby_list, index_params, index_list,
- name_list, from_clause, from_list, opt_array_bounds,
- qualified_name_list, any_name, any_name_list,
- any_operator, expr_list, dotted_name, attrs,
- target_list, update_target_list, insert_column_list,
- insert_target_list, def_list, opt_indirection,
- group_clause, TriggerFuncArgs, select_limit,
- opt_select_limit
+ OptTableElementList, OptInherit, definition,
+ opt_distinct, opt_definition, func_args,
+ func_args_list, func_as, createfunc_opt_list
+ oper_argtypes, RuleActionList, RuleActionMulti,
+ opt_column_list, columnList, opt_name_list,
+ sort_clause, sortby_list, index_params, index_list,
+ name_list, from_clause, from_list, opt_array_bounds,
+ qualified_name_list, any_name, any_name_list,
+ any_operator, expr_list, dotted_name, attrs,
+ target_list, update_target_list, insert_column_list,
+ insert_target_list, def_list, opt_indirection,
+ group_clause, TriggerFuncArgs, select_limit,
+ opt_select_limit
%type <range> into_clause, OptTempTableName
-%type <defelt> createfunc_opt_item
+%type <defelt> createfunc_opt_item
%type <typnam> func_arg, func_return, func_type, aggr_argtype
-%type <boolean> opt_arg, TriggerForOpt, TriggerForType, OptTemp, OptWithOids
+%type <boolean> opt_arg, TriggerForOpt, TriggerForType, OptTemp, OptWithOids
%type <list> for_update_clause, opt_for_update_clause, update_list
-%type <boolean> opt_all
-%type <boolean> opt_table
-%type <boolean> opt_chain, opt_trans
+%type <boolean> opt_all
+%type <boolean> opt_table
+%type <boolean> opt_chain, opt_trans
%type <node> join_outer, join_qual
%type <jtype> join_type
%type <ival> opt_interval
%type <node> overlay_placing, substr_from, substr_for
-%type <boolean> opt_binary, opt_using, opt_instead, opt_cursor, opt_with
-%type <boolean> opt_with_copy, index_opt_unique, opt_verbose, opt_full
-%type <boolean> opt_freeze, analyze_keyword
+%type <boolean> opt_binary, opt_using, opt_instead, opt_cursor, opt_with
+%type <boolean> opt_with_copy, index_opt_unique, opt_verbose, opt_full
+%type <boolean> opt_freeze, analyze_keyword
%type <ival> copy_dirn, direction, reindex_type, drop_type,
opt_column, event, comment_type
%type <istmt> insert_rest
-%type <vsetstmt> set_rest
+%type <vsetstmt> set_rest
%type <node> OptTableElement, ConstraintElem
%type <node> columnDef
%type <str> extract_arg
%type <str> opt_charset, opt_collate
%type <ival> opt_numeric, opt_decimal
-%type <boolean> opt_varying, opt_timezone
+%type <boolean> opt_varying, opt_timezone
%type <ival> Iconst
%type <str> Sconst, comment_text
%type <str> ColId, ColLabel, type_name
%type <node> var_value, zone_value
-%type <keyword> unreserved_keyword, func_name_keyword
-%type <keyword> col_name_keyword, reserved_keyword
+%type <keyword> unreserved_keyword, func_name_keyword
+%type <keyword> col_name_keyword, reserved_keyword
%type <node> TableConstraint
%type <list> ColQualList
ConstraintTimeSpec
%type <list> constraints_set_list
-%type <boolean> constraints_set_mode
+%type <boolean> constraints_set_mode
%type <boolean> opt_as
* psql already handles such cases, but other interfaces don't.
* bjm 1999/10/05
*/
-stmtblock: stmtmulti
- { parsetree = $1; }
+stmtblock: stmtmulti { parsetree = $1; }
;
/* the thrashing around here is to discard "empty" statements... */
-stmtmulti: stmtmulti ';' stmt
+stmtmulti: stmtmulti ';' stmt
{ if ($3 != (Node *)NULL)
$$ = lappend($1, $3);
else
$$ = $1;
}
- | stmt
- { if ($1 != (Node *)NULL)
- $$ = makeList1($1);
- else
- $$ = NIL;
- }
+ | stmt
+ { if ($1 != (Node *)NULL)
+ $$ = makeList1($1);
+ else
+ $$ = NIL;
+ }
;
-stmt : AlterDatabaseSetStmt
- | AlterGroupStmt
- | AlterSchemaStmt
- | AlterTableStmt
- | AlterUserStmt
- | AlterUserSetStmt
- | ClosePortalStmt
- | CopyStmt
- | CreateStmt
- | CreateAsStmt
- | CreateDomainStmt
- | CreateFunctionStmt
- | CreateSchemaStmt
- | CreateGroupStmt
- | CreateSeqStmt
- | CreatePLangStmt
- | CreateAssertStmt
- | CreateTrigStmt
- | CreateUserStmt
- | ClusterStmt
- | DefineStmt
- | DropStmt
- | DropSchemaStmt
- | TruncateStmt
- | CommentStmt
- | DropGroupStmt
- | DropPLangStmt
- | DropAssertStmt
- | DropTrigStmt
- | DropRuleStmt
- | DropUserStmt
- | ExplainStmt
- | FetchStmt
- | GrantStmt
- | IndexStmt
- | ListenStmt
- | UnlistenStmt
- | LockStmt
- | NotifyStmt
- | ReindexStmt
- | RemoveAggrStmt
- | RemoveOperStmt
- | RemoveFuncStmt
- | RenameStmt
- | RevokeStmt
- | OptimizableStmt
- | RuleStmt
- | TransactionStmt
- | ViewStmt
- | LoadStmt
- | CreatedbStmt
- | DropdbStmt
- | VacuumStmt
- | AnalyzeStmt
- | VariableSetStmt
- | VariableShowStmt
- | VariableResetStmt
- | ConstraintsSetStmt
- | CheckPointStmt
- | /*EMPTY*/
- { $$ = (Node *)NULL; }
+stmt :
+ AlterDatabaseSetStmt
+ | AlterGroupStmt
+ | AlterSchemaStmt
+ | AlterTableStmt
+ | AlterUserStmt
+ | AlterUserSetStmt
+ | ClosePortalStmt
+ | CopyStmt
+ | CreateStmt
+ | CreateAsStmt
+ | CreateDomainStmt
+ | CreateFunctionStmt
+ | CreateSchemaStmt
+ | CreateGroupStmt
+ | CreateSeqStmt
+ | CreatePLangStmt
+ | CreateAssertStmt
+ | CreateTrigStmt
+ | CreateUserStmt
+ | ClusterStmt
+ | DefineStmt
+ | DropStmt
+ | DropSchemaStmt
+ | TruncateStmt
+ | CommentStmt
+ | DropGroupStmt
+ | DropPLangStmt
+ | DropAssertStmt
+ | DropTrigStmt
+ | DropRuleStmt
+ | DropUserStmt
+ | ExplainStmt
+ | FetchStmt
+ | GrantStmt
+ | IndexStmt
+ | ListenStmt
+ | UnlistenStmt
+ | LockStmt
+ | NotifyStmt
+ | ReindexStmt
+ | RemoveAggrStmt
+ | RemoveOperStmt
+ | RemoveFuncStmt
+ | RenameStmt
+ | RevokeStmt
+ | OptimizableStmt
+ | RuleStmt
+ | TransactionStmt
+ | ViewStmt
+ | LoadStmt
+ | CreatedbStmt
+ | DropdbStmt
+ | VacuumStmt
+ | AnalyzeStmt
+ | VariableSetStmt
+ | VariableShowStmt
+ | VariableResetStmt
+ | ConstraintsSetStmt
+ | CheckPointStmt
+ | /*EMPTY*/
+ { $$ = (Node *)NULL; }
;
/*****************************************************************************
*
*****************************************************************************/
-CreateUserStmt: CREATE USER UserId opt_with OptUserList
+CreateUserStmt:
+ CREATE USER UserId opt_with OptUserList
{
CreateUserStmt *n = makeNode(CreateUserStmt);
n->user = $3;
;
-opt_with: WITH { $$ = TRUE; }
- | /*EMPTY*/ { $$ = TRUE; }
+opt_with: WITH { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = TRUE; }
;
/*****************************************************************************
*
*****************************************************************************/
-AlterUserStmt: ALTER USER UserId opt_with OptUserList
+AlterUserStmt:
+ ALTER USER UserId opt_with OptUserList
{
AlterUserStmt *n = makeNode(AlterUserStmt);
n->user = $3;
;
-AlterUserSetStmt: ALTER USER UserId SET set_rest
+AlterUserSetStmt:
+ ALTER USER UserId SET set_rest
{
AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
n->user = $3;
n->value = $5->args;
$$ = (Node *)n;
}
- | ALTER USER UserId VariableResetStmt
+ | ALTER USER UserId VariableResetStmt
{
AlterUserSetStmt *n = makeNode(AlterUserSetStmt);
n->user = $3;
n->value = NIL;
$$ = (Node *)n;
}
- ;
+ ;
/*****************************************************************************
*
*****************************************************************************/
-DropUserStmt: DROP USER user_list
+DropUserStmt:
+ DROP USER user_list
{
DropUserStmt *n = makeNode(DropUserStmt);
n->users = $3;
$$ = (Node *)n;
}
- ;
+ ;
/*
* Options for CREATE USER and ALTER USER
*/
-OptUserList: OptUserList OptUserElem { $$ = lappend($1, $2); }
- | /* EMPTY */ { $$ = NIL; }
+OptUserList:
+ OptUserList OptUserElem { $$ = lappend($1, $2); }
+ | /* EMPTY */ { $$ = NIL; }
;
-OptUserElem: PASSWORD Sconst
+OptUserElem:
+ PASSWORD Sconst
{
$$ = makeNode(DefElem);
$$->defname = "password";
}
;
-user_list: user_list ',' UserId
+user_list: user_list ',' UserId
{
$$ = lappend($1, makeString($3));
}
*
*****************************************************************************/
-CreateGroupStmt: CREATE GROUP_P UserId opt_with OptGroupList
+CreateGroupStmt:
+ CREATE GROUP_P UserId opt_with OptGroupList
{
CreateGroupStmt *n = makeNode(CreateGroupStmt);
n->name = $3;
/*
* Options for CREATE GROUP
*/
-OptGroupList: OptGroupList OptGroupElem { $$ = lappend($1, $2); }
- | /* EMPTY */ { $$ = NIL; }
+OptGroupList:
+ OptGroupList OptGroupElem { $$ = lappend($1, $2); }
+ | /* EMPTY */ { $$ = NIL; }
;
-OptGroupElem: USER user_list
+OptGroupElem:
+ USER user_list
{
$$ = makeNode(DefElem);
$$->defname = "userElts";
*
*****************************************************************************/
-AlterGroupStmt: ALTER GROUP_P UserId add_drop USER user_list
+AlterGroupStmt:
+ ALTER GROUP_P UserId add_drop USER user_list
{
AlterGroupStmt *n = makeNode(AlterGroupStmt);
n->name = $3;
n->listUsers = $6;
$$ = (Node *)n;
}
- ;
+ ;
-add_drop: ADD { $$ = +1; }
- | DROP { $$ = -1; }
+add_drop: ADD { $$ = +1; }
+ | DROP { $$ = -1; }
;
*
*****************************************************************************/
-DropGroupStmt: DROP GROUP_P UserId
+DropGroupStmt:
+ DROP GROUP_P UserId
{
DropGroupStmt *n = makeNode(DropGroupStmt);
n->name = $3;
$$ = (Node *)n;
}
- ;
+ ;
/*****************************************************************************
*
*****************************************************************************/
-CreateSchemaStmt: CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
+CreateSchemaStmt:
+ CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
/* One can omit the schema name or the authorization id... */
n->schemaElts = $6;
$$ = (Node *)n;
}
- | CREATE SCHEMA ColId OptSchemaEltList
+ | CREATE SCHEMA ColId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
/* ...but not both */
}
;
-AlterSchemaStmt: ALTER SCHEMA ColId
+AlterSchemaStmt:
+ ALTER SCHEMA ColId
{
elog(ERROR, "ALTER SCHEMA not yet supported");
}
;
-DropSchemaStmt: DROP SCHEMA ColId
+DropSchemaStmt:
+ DROP SCHEMA ColId
{
elog(ERROR, "DROP SCHEMA not yet supported");
}
;
-OptSchemaName: ColId { $$ = $1; }
- | /* EMPTY */ { $$ = NULL; }
+OptSchemaName:
+ ColId { $$ = $1; }
+ | /* EMPTY */ { $$ = NULL; }
;
-OptSchemaEltList: OptSchemaEltList schema_stmt { $$ = lappend($1, $2); }
- | /* EMPTY */ { $$ = NIL; }
+OptSchemaEltList:
+ OptSchemaEltList schema_stmt { $$ = lappend($1, $2); }
+ | /* EMPTY */ { $$ = NIL; }
;
/*
* schema_stmt are the ones that can show up inside a CREATE SCHEMA
* statement (in addition to by themselves).
*/
-schema_stmt: CreateStmt
- | GrantStmt
- | ViewStmt
+schema_stmt:
+ CreateStmt
+ | GrantStmt
+ | ViewStmt
;
* Set PG internal variable
* SET name TO 'var_value'
* Include SQL92 syntax (thomas 1997-10-22):
- * SET TIME ZONE 'var_value'
+ * SET TIME ZONE 'var_value'
*
*****************************************************************************/
-VariableSetStmt: SET set_rest
+VariableSetStmt:
+ SET set_rest
{
VariableSetStmt *n = $2;
n->is_local = false;
$$ = (Node *) n;
}
- | SET LOCAL set_rest
+ | SET LOCAL set_rest
{
VariableSetStmt *n = $3;
n->is_local = true;
$$ = (Node *) n;
}
- | SET SESSION set_rest
+ | SET SESSION set_rest
{
VariableSetStmt *n = $3;
n->is_local = false;
n->args = $3;
$$ = n;
}
- | ColId '=' var_list_or_default
+ | ColId '=' var_list_or_default
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = $1;
n->args = $3;
$$ = n;
}
- | TIME ZONE zone_value
+ | TIME ZONE zone_value
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "timezone";
n->args = makeList1($3);
$$ = n;
}
- | TRANSACTION ISOLATION LEVEL opt_level
+ | TRANSACTION ISOLATION LEVEL opt_level
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "TRANSACTION ISOLATION LEVEL";
n->args = makeList1(makeStringConst($4, NULL));
$$ = n;
}
- | SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL opt_level
+ | SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL opt_level
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "default_transaction_isolation";
n->args = makeList1(makeStringConst($7, NULL));
$$ = n;
}
- | NAMES opt_encoding
+ | NAMES opt_encoding
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "client_encoding";
n->args = makeList1(makeStringConst($2, NULL));
$$ = n;
}
- | SESSION AUTHORIZATION ColId_or_Sconst
+ | SESSION AUTHORIZATION ColId_or_Sconst
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "session_authorization";
n->args = makeList1(makeStringConst($3, NULL));
$$ = n;
}
- | SESSION AUTHORIZATION DEFAULT
+ | SESSION AUTHORIZATION DEFAULT
{
VariableSetStmt *n = makeNode(VariableSetStmt);
n->name = "session_authorization";
}
;
-var_list_or_default: var_list
- { $$ = $1; }
- | DEFAULT
- { $$ = NIL; }
+var_list_or_default:
+ var_list { $$ = $1; }
+ | DEFAULT { $$ = NIL; }
;
-var_list: var_value
- { $$ = makeList1($1); }
- | var_list ',' var_value
- { $$ = lappend($1, $3); }
+var_list:
+ var_value { $$ = makeList1($1); }
+ | var_list ',' var_value { $$ = lappend($1, $3); }
;
-var_value: opt_boolean
+var_value: opt_boolean
{ $$ = makeStringConst($1, NULL); }
- | ColId_or_Sconst
+ | ColId_or_Sconst
{ $$ = makeStringConst($1, NULL); }
- | NumericOnly
+ | NumericOnly
{ $$ = makeAConst($1); }
;
-opt_level: READ COMMITTED { $$ = "read committed"; }
- | SERIALIZABLE { $$ = "serializable"; }
+opt_level: READ COMMITTED { $$ = "read committed"; }
+ | SERIALIZABLE { $$ = "serializable"; }
;
-opt_boolean: TRUE_P { $$ = "true"; }
- | FALSE_P { $$ = "false"; }
- | ON { $$ = "on"; }
- | OFF { $$ = "off"; }
+opt_boolean:
+ TRUE_P { $$ = "true"; }
+ | FALSE_P { $$ = "false"; }
+ | ON { $$ = "on"; }
+ | OFF { $$ = "off"; }
;
/* Timezone values can be:
* ColId gives reduce/reduce errors against ConstInterval and LOCAL,
* so use IDENT and reject anything which is a reserved word.
*/
-zone_value: Sconst
- {
- $$ = makeStringConst($1, NULL);
- }
- | IDENT
- {
- $$ = makeStringConst($1, NULL);
- }
- | ConstInterval Sconst opt_interval
- {
- A_Const *n = (A_Const *) makeStringConst($2, $1);
- if ($3 != -1)
+zone_value:
+ Sconst
{
- if (($3 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
- elog(ERROR, "Time zone interval must be HOUR or HOUR TO MINUTE");
- n->typename->typmod = ((($3 & 0x7FFF) << 16) | 0xFFFF);
+ $$ = makeStringConst($1, NULL);
}
- $$ = (Node *)n;
- }
- | ConstInterval '(' Iconst ')' Sconst opt_interval
- {
- A_Const *n = (A_Const *) makeStringConst($5, $1);
- if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
- elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
- $3, 0, MAX_INTERVAL_PRECISION);
- if ($6 != -1)
- {
- if (($6 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
- elog(ERROR, "Time zone interval must be HOUR or HOUR TO MINUTE");
- n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
+ | IDENT
+ {
+ $$ = makeStringConst($1, NULL);
}
- else
+ | ConstInterval Sconst opt_interval
{
- n->typename->typmod = ((0x7FFF << 16) | $3);
+ A_Const *n = (A_Const *) makeStringConst($2, $1);
+ if ($3 != -1)
+ {
+ if (($3 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
+ elog(ERROR,
+ "Time zone interval must be HOUR or HOUR TO MINUTE");
+ n->typename->typmod = ((($3 & 0x7FFF) << 16) | 0xFFFF);
+ }
+ $$ = (Node *)n;
}
+ | ConstInterval '(' Iconst ')' Sconst opt_interval
+ {
+ A_Const *n = (A_Const *) makeStringConst($5, $1);
+ if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
+ elog(ERROR,
+ "INTERVAL(%d) precision must be between %d and %d",
+ $3, 0, MAX_INTERVAL_PRECISION);
+ if ($6 != -1)
+ {
+ if (($6 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
+ elog(ERROR,
+ "Time zone interval must be HOUR or HOUR TO MINUTE");
+ n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
+ }
+ else
+ {
+ n->typename->typmod = ((0x7FFF << 16) | $3);
+ }
- $$ = (Node *)n;
- }
- | NumericOnly { $$ = makeAConst($1); }
- | DEFAULT { $$ = NULL; }
- | LOCAL { $$ = NULL; }
+ $$ = (Node *)n;
+ }
+ | NumericOnly { $$ = makeAConst($1); }
+ | DEFAULT { $$ = NULL; }
+ | LOCAL { $$ = NULL; }
;
-opt_encoding: Sconst { $$ = $1; }
- | DEFAULT { $$ = NULL; }
- | /*EMPTY*/ { $$ = NULL; }
- ;
+opt_encoding:
+ Sconst { $$ = $1; }
+ | DEFAULT { $$ = NULL; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
-ColId_or_Sconst: ColId { $$ = $1; }
- | SCONST { $$ = $1; }
+ColId_or_Sconst:
+ ColId { $$ = $1; }
+ | SCONST { $$ = $1; }
;
-VariableShowStmt: SHOW ColId
+VariableShowStmt:
+ SHOW ColId
{
VariableShowStmt *n = makeNode(VariableShowStmt);
n->name = $2;
$$ = (Node *) n;
}
- | SHOW TIME ZONE
+ | SHOW TIME ZONE
{
VariableShowStmt *n = makeNode(VariableShowStmt);
n->name = "timezone";
$$ = (Node *) n;
}
- | SHOW TRANSACTION ISOLATION LEVEL
+ | SHOW TRANSACTION ISOLATION LEVEL
{
VariableShowStmt *n = makeNode(VariableShowStmt);
n->name = "TRANSACTION ISOLATION LEVEL";
$$ = (Node *) n;
}
- | SHOW SESSION AUTHORIZATION
+ | SHOW SESSION AUTHORIZATION
{
VariableShowStmt *n = makeNode(VariableShowStmt);
n->name = "session_authorization";
$$ = (Node *) n;
}
- | SHOW ALL
+ | SHOW ALL
{
VariableShowStmt *n = makeNode(VariableShowStmt);
n->name = "all";
}
;
-VariableResetStmt: RESET ColId
+VariableResetStmt:
+ RESET ColId
{
VariableResetStmt *n = makeNode(VariableResetStmt);
n->name = $2;
$$ = (Node *) n;
}
- | RESET TIME ZONE
+ | RESET TIME ZONE
{
VariableResetStmt *n = makeNode(VariableResetStmt);
n->name = "timezone";
$$ = (Node *) n;
}
- | RESET TRANSACTION ISOLATION LEVEL
+ | RESET TRANSACTION ISOLATION LEVEL
{
VariableResetStmt *n = makeNode(VariableResetStmt);
n->name = "TRANSACTION ISOLATION LEVEL";
$$ = (Node *) n;
}
- | RESET SESSION AUTHORIZATION
+ | RESET SESSION AUTHORIZATION
{
VariableResetStmt *n = makeNode(VariableResetStmt);
n->name = "session_authorization";
$$ = (Node *) n;
}
- | RESET ALL
+ | RESET ALL
{
VariableResetStmt *n = makeNode(VariableResetStmt);
n->name = "all";
;
-ConstraintsSetStmt: SET CONSTRAINTS constraints_set_list constraints_set_mode
+ConstraintsSetStmt:
+ SET CONSTRAINTS constraints_set_list constraints_set_mode
{
ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt);
n->constraints = $3;
}
;
-constraints_set_list: ALL { $$ = NIL; }
- | name_list { $$ = $1; }
+constraints_set_list:
+ ALL { $$ = NIL; }
+ | name_list { $$ = $1; }
;
-constraints_set_mode: DEFERRED { $$ = TRUE; }
- | IMMEDIATE { $$ = FALSE; }
+constraints_set_mode:
+ DEFERRED { $$ = TRUE; }
+ | IMMEDIATE { $$ = FALSE; }
;
/*
* Checkpoint statement
*/
-CheckPointStmt: CHECKPOINT
+CheckPointStmt:
+ CHECKPOINT
{
CheckPointStmt *n = makeNode(CheckPointStmt);
$$ = (Node *)n;
}
- ;
+ ;
+
/*****************************************************************************
*
*****************************************************************************/
AlterTableStmt:
-/* ALTER TABLE <relation> ADD [COLUMN] <coldef> */
- ALTER TABLE relation_expr ADD opt_column columnDef
+ /* ALTER TABLE <relation> ADD [COLUMN] <coldef> */
+ ALTER TABLE relation_expr ADD opt_column columnDef
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'A';
n->def = $6;
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
- | ALTER TABLE relation_expr ALTER opt_column ColId alter_column_default
+ /* ALTER TABLE <relation> ALTER [COLUMN] <colname> {SET DEFAULT <expr>|DROP DEFAULT} */
+ | ALTER TABLE relation_expr ALTER opt_column ColId alter_column_default
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'T';
n->def = $7;
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> ALTER [COLUMN] <colname> DROP NOT NULL */
- | ALTER TABLE relation_expr ALTER opt_column ColId DROP NOT NULL_P
- {
- AlterTableStmt *n = makeNode(AlterTableStmt);
- n->subtype = 'N';
- n->relation = $3;
- n->name = $6;
- $$ = (Node *)n;
- }
-/* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET NOT NULL */
- | ALTER TABLE relation_expr ALTER opt_column ColId SET NOT NULL_P
- {
- AlterTableStmt *n = makeNode(AlterTableStmt);
- n->subtype = 'O';
- n->relation = $3;
- n->name = $6;
- $$ = (Node *)n;
- }
-/* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STATISTICS <Iconst> */
- | ALTER TABLE relation_expr ALTER opt_column ColId SET STATISTICS Iconst
+ /* ALTER TABLE <relation> ALTER [COLUMN] <colname> DROP NOT NULL */
+ | ALTER TABLE relation_expr ALTER opt_column ColId DROP NOT NULL_P
+ {
+ AlterTableStmt *n = makeNode(AlterTableStmt);
+ n->subtype = 'N';
+ n->relation = $3;
+ n->name = $6;
+ $$ = (Node *)n;
+ }
+ /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET NOT NULL */
+ | ALTER TABLE relation_expr ALTER opt_column ColId SET NOT NULL_P
+ {
+ AlterTableStmt *n = makeNode(AlterTableStmt);
+ n->subtype = 'O';
+ n->relation = $3;
+ n->name = $6;
+ $$ = (Node *)n;
+ }
+ /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STATISTICS <Iconst> */
+ | ALTER TABLE relation_expr ALTER opt_column ColId SET STATISTICS Iconst
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'S';
n->def = (Node *) makeInteger($9);
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
- | ALTER TABLE relation_expr ALTER opt_column ColId SET STORAGE ColId
- {
+ /* ALTER TABLE <relation> ALTER [COLUMN] <colname> SET STORAGE <storagemode> */
+ | ALTER TABLE relation_expr ALTER opt_column ColId SET STORAGE ColId
+ {
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'M';
n->relation = $3;
n->def = (Node *) makeString($9);
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> DROP [COLUMN] <colname> {RESTRICT|CASCADE} */
- | ALTER TABLE relation_expr DROP opt_column ColId drop_behavior
+ /* ALTER TABLE <relation> DROP [COLUMN] <colname> {RESTRICT|CASCADE} */
+ | ALTER TABLE relation_expr DROP opt_column ColId drop_behavior
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'D';
n->behavior = $7;
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> ADD CONSTRAINT ... */
- | ALTER TABLE relation_expr ADD TableConstraint
+ /* ALTER TABLE <relation> ADD CONSTRAINT ... */
+ | ALTER TABLE relation_expr ADD TableConstraint
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'C';
n->def = $5;
$$ = (Node *)n;
}
-/* ALTER TABLE <relation> DROP CONSTRAINT <name> {RESTRICT|CASCADE} */
- | ALTER TABLE relation_expr DROP CONSTRAINT name drop_behavior
+ /* ALTER TABLE <relation> DROP CONSTRAINT <name> {RESTRICT|CASCADE} */
+ | ALTER TABLE relation_expr DROP CONSTRAINT name drop_behavior
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'X';
n->behavior = $7;
$$ = (Node *)n;
}
-/* ALTER TABLE <name> CREATE TOAST TABLE */
- | ALTER TABLE qualified_name CREATE TOAST TABLE
+ /* ALTER TABLE <name> CREATE TOAST TABLE */
+ | ALTER TABLE qualified_name CREATE TOAST TABLE
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'E';
n->relation = $3;
$$ = (Node *)n;
}
-/* ALTER TABLE <name> OWNER TO UserId */
- | ALTER TABLE qualified_name OWNER TO UserId
+ /* ALTER TABLE <name> OWNER TO UserId */
+ | ALTER TABLE qualified_name OWNER TO UserId
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->subtype = 'U';
;
alter_column_default:
- SET DEFAULT a_expr
- {
- /* Treat SET DEFAULT NULL the same as DROP DEFAULT */
- if (exprIsNullConstant($3))
- $$ = NULL;
- else
- $$ = $3;
- }
- | DROP DEFAULT { $$ = NULL; }
- ;
+ SET DEFAULT a_expr
+ {
+ /* Treat SET DEFAULT NULL the same as DROP DEFAULT */
+ if (exprIsNullConstant($3))
+ $$ = NULL;
+ else
+ $$ = $3;
+ }
+ | DROP DEFAULT { $$ = NULL; }
+ ;
-drop_behavior: CASCADE { $$ = CASCADE; }
- | RESTRICT { $$ = RESTRICT; }
- ;
+drop_behavior:
+ CASCADE { $$ = CASCADE; }
+ | RESTRICT { $$ = RESTRICT; }
+ ;
-opt_drop_behavior: CASCADE { $$ = CASCADE; }
- | RESTRICT { $$ = RESTRICT; }
- | /* EMPTY */ { $$ = RESTRICT; /* default */ }
+opt_drop_behavior:
+ CASCADE { $$ = CASCADE; }
+ | RESTRICT { $$ = RESTRICT; }
+ | /* EMPTY */ { $$ = RESTRICT; /* default */ }
;
*
*****************************************************************************/
-ClosePortalStmt: CLOSE opt_id
+ClosePortalStmt:
+ CLOSE opt_id
{
ClosePortalStmt *n = makeNode(ClosePortalStmt);
n->portalname = $2;
}
;
-opt_id: ColId { $$ = $1; }
- | /*EMPTY*/ { $$ = NULL; }
+opt_id: ColId { $$ = $1; }
+ | /*EMPTY*/ { $$ = NULL; }
;
*
*****************************************************************************/
-CopyStmt: COPY opt_binary qualified_name opt_with_copy copy_dirn copy_file_name copy_delimiter copy_null
+CopyStmt: COPY opt_binary qualified_name opt_with_copy copy_dirn copy_file_name copy_delimiter copy_null
{
CopyStmt *n = makeNode(CopyStmt);
n->binary = $2;
}
;
-copy_dirn: TO
- { $$ = TO; }
- | FROM
- { $$ = FROM; }
+copy_dirn: TO { $$ = TO; }
+ | FROM { $$ = FROM; }
;
/*
* used depends on the direction. (It really doesn't make sense to copy from
* 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: opt_using DELIMITERS Sconst { $$ = $3; }
- | /*EMPTY*/ { $$ = "\t"; }
+copy_delimiter:
+ opt_using DELIMITERS Sconst { $$ = $3; }
+ | /*EMPTY*/ { $$ = "\t"; }
;
-opt_using: USING { $$ = TRUE; }
- | /*EMPTY*/ { $$ = TRUE; }
+opt_using: USING { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = TRUE; }
;
-copy_null: WITH NULL_P AS Sconst { $$ = $4; }
- | /*EMPTY*/ { $$ = "\\N"; }
+copy_null: WITH NULL_P AS Sconst { $$ = $4; }
+ | /*EMPTY*/ { $$ = "\\N"; }
;
/*****************************************************************************
*
*****************************************************************************/
-CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptInherit OptWithOids
+CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' OptInherit OptWithOids
{
CreateStmt *n = makeNode(CreateStmt);
$4->istemp = $2;
* Redundancy here is needed to avoid shift/reduce conflicts,
* since TEMP is not a reserved word. See also OptTempTableName.
*/
-OptTemp: TEMPORARY { $$ = TRUE; }
+OptTemp: TEMPORARY { $$ = TRUE; }
| TEMP { $$ = TRUE; }
| LOCAL TEMPORARY { $$ = TRUE; }
| LOCAL TEMP { $$ = TRUE; }
| /*EMPTY*/ { $$ = FALSE; }
;
-OptTableElementList: OptTableElementList ',' OptTableElement
+OptTableElementList:
+ OptTableElementList ',' OptTableElement
{
if ($3 != NULL)
$$ = lappend($1, $3);
| /*EMPTY*/ { $$ = NIL; }
;
-OptTableElement: columnDef { $$ = $1; }
+OptTableElement:
+ columnDef { $$ = $1; }
| TableConstraint { $$ = $1; }
;
-columnDef: ColId Typename ColQualList opt_collate
+columnDef: ColId Typename ColQualList opt_collate
{
ColumnDef *n = makeNode(ColumnDef);
n->colname = $1;
}
;
-ColQualList: ColQualList ColConstraint { $$ = lappend($1, $2); }
- | /*EMPTY*/ { $$ = NIL; }
+ColQualList:
+ ColQualList ColConstraint { $$ = lappend($1, $2); }
+ | /*EMPTY*/ { $$ = NIL; }
;
ColConstraint:
- CONSTRAINT name ColConstraintElem
+ CONSTRAINT name ColConstraintElem
{
switch (nodeTag($3))
{
}
$$ = $3;
}
- | ColConstraintElem
- { $$ = $1; }
- | ConstraintAttr
- { $$ = $1; }
+ | ColConstraintElem { $$ = $1; }
+ | ConstraintAttr { $$ = $1; }
;
/* DEFAULT NULL is already the default for Postgres.
* or be part of a_expr NOT LIKE or similar constructs).
*/
ColConstraintElem:
- NOT NULL_P
+ NOT NULL_P
{
Constraint *n = makeNode(Constraint);
n->contype = CONSTR_NOTNULL;
* See also ConstraintAttributeSpec, which can be used in places where
* there is no parsing conflict.
*/
-ConstraintAttr: DEFERRABLE
+ConstraintAttr:
+ DEFERRABLE
{
Constraint *n = makeNode(Constraint);
n->contype = CONSTR_ATTR_DEFERRABLE;
/* ConstraintElem specifies constraint syntax which is not embedded into
- * a column definition. ColConstraintElem specifies the embedded form.
+ * a column definition. ColConstraintElem specifies the embedded form.
* - thomas 1997-12-03
*/
-TableConstraint: CONSTRAINT name ConstraintElem
+TableConstraint:
+ CONSTRAINT name ConstraintElem
{
switch (nodeTag($3))
{
}
$$ = $3;
}
- | ConstraintElem
- { $$ = $1; }
+ | ConstraintElem { $$ = $1; }
;
-ConstraintElem: CHECK '(' a_expr ')'
+ConstraintElem:
+ CHECK '(' a_expr ')'
{
Constraint *n = makeNode(Constraint);
n->contype = CONSTR_CHECK;
n->cooked_expr = NULL;
$$ = (Node *)n;
}
- | UNIQUE '(' columnList ')'
+ | UNIQUE '(' columnList ')'
{
Constraint *n = makeNode(Constraint);
n->contype = CONSTR_UNIQUE;
n->keys = $3;
$$ = (Node *)n;
}
- | PRIMARY KEY '(' columnList ')'
+ | PRIMARY KEY '(' columnList ')'
{
Constraint *n = makeNode(Constraint);
n->contype = CONSTR_PRIMARY;
n->keys = $4;
$$ = (Node *)n;
}
- | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name opt_column_list
+ | FOREIGN KEY '(' columnList ')' REFERENCES qualified_name opt_column_list
key_match key_actions ConstraintAttributeSpec
{
FkConstraint *n = makeNode(FkConstraint);
}
;
-opt_column_list: '(' columnList ')' { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
+opt_column_list:
+ '(' columnList ')' { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
;
-columnList: columnList ',' columnElem
- { $$ = lappend($1, $3); }
- | columnElem
- { $$ = makeList1($1); }
+columnList: columnList ',' columnElem { $$ = lappend($1, $3); }
+ | columnElem { $$ = makeList1($1); }
;
-columnElem: ColId
+columnElem: ColId
{
Ident *id = makeNode(Ident);
id->name = $1;
}
;
-key_match: MATCH FULL
- {
- $$ = "FULL";
- }
- | MATCH PARTIAL
- {
- elog(ERROR, "FOREIGN KEY/MATCH PARTIAL not yet implemented");
- $$ = "PARTIAL";
- }
- | /*EMPTY*/
- {
- $$ = "UNSPECIFIED";
- }
+key_match: MATCH FULL { $$ = "FULL"; }
+ | MATCH PARTIAL
+ {
+ elog(ERROR, "FOREIGN KEY/MATCH PARTIAL not yet implemented");
+ $$ = "PARTIAL";
+ }
+ | /*EMPTY*/
+ {
+ $$ = "UNSPECIFIED";
+ }
;
-key_actions: key_delete { $$ = $1; }
- | key_update { $$ = $1; }
- | key_delete key_update { $$ = $1 | $2; }
- | key_update key_delete { $$ = $1 | $2; }
- | /*EMPTY*/ { $$ = 0; }
+key_actions:
+ key_delete { $$ = $1; }
+ | key_update { $$ = $1; }
+ | key_delete key_update { $$ = $1 | $2; }
+ | key_update key_delete { $$ = $1 | $2; }
+ | /*EMPTY*/ { $$ = 0; }
;
-key_delete: ON DELETE_P key_reference { $$ = $3 << FKCONSTR_ON_DELETE_SHIFT; }
+key_delete: ON DELETE_P key_reference { $$ = $3 << FKCONSTR_ON_DELETE_SHIFT; }
;
-key_update: ON UPDATE key_reference { $$ = $3 << FKCONSTR_ON_UPDATE_SHIFT; }
+key_update: ON UPDATE key_reference { $$ = $3 << FKCONSTR_ON_UPDATE_SHIFT; }
;
-key_reference: NO ACTION { $$ = FKCONSTR_ON_KEY_NOACTION; }
- | RESTRICT { $$ = FKCONSTR_ON_KEY_RESTRICT; }
- | CASCADE { $$ = FKCONSTR_ON_KEY_CASCADE; }
- | SET NULL_P { $$ = FKCONSTR_ON_KEY_SETNULL; }
- | SET DEFAULT { $$ = FKCONSTR_ON_KEY_SETDEFAULT; }
+key_reference:
+ NO ACTION { $$ = FKCONSTR_ON_KEY_NOACTION; }
+ | RESTRICT { $$ = FKCONSTR_ON_KEY_RESTRICT; }
+ | CASCADE { $$ = FKCONSTR_ON_KEY_CASCADE; }
+ | SET NULL_P { $$ = FKCONSTR_ON_KEY_SETNULL; }
+ | SET DEFAULT { $$ = FKCONSTR_ON_KEY_SETDEFAULT; }
;
-OptInherit: INHERITS '(' qualified_name_list ')' { $$ = $3; }
- | /*EMPTY*/ { $$ = NIL; }
+OptInherit: INHERITS '(' qualified_name_list ')' { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
;
-OptWithOids: WITH OIDS { $$ = TRUE; }
- | WITHOUT OIDS { $$ = FALSE; }
- | /*EMPTY*/ { $$ = TRUE; }
+OptWithOids:
+ WITH OIDS { $$ = TRUE; }
+ | WITHOUT OIDS { $$ = FALSE; }
+ | /*EMPTY*/ { $$ = TRUE; }
;
* SELECT ... INTO.
*/
-CreateAsStmt: CREATE OptTemp TABLE qualified_name OptCreateAs AS SelectStmt
+CreateAsStmt:
+ CREATE OptTemp TABLE qualified_name OptCreateAs AS SelectStmt
{
/*
* When the SelectStmt is a set-operation tree, we must
* stuff the INTO information into the leftmost component
* Select, because that's where analyze.c will expect
- * to find it. Similarly, the output column names must
+ * to find it. Similarly, the output column names must
* be attached to that Select's target list.
*/
SelectStmt *n = findLeftmostSelect((SelectStmt *) $7);
}
;
-OptCreateAs: '(' CreateAsList ')' { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
+OptCreateAs:
+ '(' CreateAsList ')' { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
;
-CreateAsList: CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
- | CreateAsElement { $$ = makeList1($1); }
+CreateAsList:
+ CreateAsList ',' CreateAsElement { $$ = lappend($1, $3); }
+ | CreateAsElement { $$ = makeList1($1); }
;
-CreateAsElement: ColId
+CreateAsElement:
+ ColId
{
ColumnDef *n = makeNode(ColumnDef);
n->colname = $1;
*
*****************************************************************************/
-CreateSeqStmt: CREATE OptTemp SEQUENCE qualified_name OptSeqList
+CreateSeqStmt:
+ CREATE OptTemp SEQUENCE qualified_name OptSeqList
{
CreateSeqStmt *n = makeNode(CreateSeqStmt);
$4->istemp = $2;
}
;
-OptSeqList: OptSeqList OptSeqElem
- { $$ = lappend($1, $2); }
- | { $$ = NIL; }
+OptSeqList: OptSeqList OptSeqElem { $$ = lappend($1, $2); }
+ | { $$ = NIL; }
;
-OptSeqElem: CACHE NumericOnly
+OptSeqElem: CACHE NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "cache";
}
;
-NumericOnly: FloatOnly { $$ = $1; }
- | IntegerOnly { $$ = $1; }
+NumericOnly:
+ FloatOnly { $$ = $1; }
+ | IntegerOnly { $$ = $1; }
;
-FloatOnly: FCONST
- {
- $$ = makeFloat($1);
- }
+FloatOnly: FCONST { $$ = makeFloat($1); }
| '-' FCONST
{
$$ = makeFloat($2);
}
;
-IntegerOnly: Iconst
+IntegerOnly:
+ Iconst
{
$$ = makeInteger($1);
}
*
*****************************************************************************/
-CreatePLangStmt: CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
+CreatePLangStmt:
+ CREATE opt_trusted opt_procedural LANGUAGE ColId_or_Sconst
HANDLER handler_name opt_validator opt_lancompiler
{
CreatePLangStmt *n = makeNode(CreatePLangStmt);
}
;
-opt_trusted: TRUSTED { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_trusted:
+ TRUSTED { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
/* This ought to be just func_name, but that causes reduce/reduce conflicts
* (CREATE LANGUAGE is the only place where func_name isn't followed by '(').
* Work around by using name and dotted_name separately.
*/
-handler_name: name
- { $$ = makeList1(makeString($1)); }
- | dotted_name
- { $$ = $1; }
+handler_name:
+ name { $$ = makeList1(makeString($1)); }
+ | dotted_name { $$ = $1; }
;
-opt_lancompiler: LANCOMPILER Sconst { $$ = $2; }
- | /*EMPTY*/ { $$ = ""; }
+opt_lancompiler:
+ LANCOMPILER Sconst { $$ = $2; }
+ | /*EMPTY*/ { $$ = ""; }
;
-opt_validator: VALIDATOR handler_name { $$ = $2; }
+opt_validator:
+ VALIDATOR handler_name { $$ = $2; }
| /*EMPTY*/ { $$ = NULL; }
;
-DropPLangStmt: DROP opt_procedural LANGUAGE ColId_or_Sconst
- {
- DropPLangStmt *n = makeNode(DropPLangStmt);
- n->plname = $4;
- $$ = (Node *)n;
- }
+DropPLangStmt:
+ DROP opt_procedural LANGUAGE ColId_or_Sconst
+ {
+ DropPLangStmt *n = makeNode(DropPLangStmt);
+ n->plname = $4;
+ $$ = (Node *)n;
+ }
;
-opt_procedural: PROCEDURAL { $$ = TRUE; }
- | /*EMPTY*/ { $$ = TRUE; }
+opt_procedural:
+ PROCEDURAL { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = TRUE; }
;
/*****************************************************************************
*
*****************************************************************************/
-CreateTrigStmt: CREATE TRIGGER name TriggerActionTime TriggerEvents ON
- qualified_name TriggerForSpec EXECUTE PROCEDURE
- func_name '(' TriggerFuncArgs ')'
+CreateTrigStmt:
+ CREATE TRIGGER name TriggerActionTime TriggerEvents ON
+ qualified_name TriggerForSpec EXECUTE PROCEDURE
+ func_name '(' TriggerFuncArgs ')'
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
n->trigname = $3;
n->when = NULL; /* unused */
n->isconstraint = FALSE;
- n->deferrable = FALSE;
+ n->deferrable = FALSE;
n->initdeferred = FALSE;
n->constrrel = NULL;
$$ = (Node *)n;
}
- | CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
- qualified_name OptConstrFromTable
- ConstraintAttributeSpec
- FOR EACH ROW EXECUTE PROCEDURE
- func_name '(' TriggerFuncArgs ')'
+ | CREATE CONSTRAINT TRIGGER name AFTER TriggerEvents ON
+ qualified_name OptConstrFromTable
+ ConstraintAttributeSpec
+ FOR EACH ROW EXECUTE PROCEDURE
+ func_name '(' TriggerFuncArgs ')'
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
n->trigname = $4;
}
;
-TriggerActionTime: BEFORE { $$ = TRUE; }
- | AFTER { $$ = FALSE; }
+TriggerActionTime:
+ BEFORE { $$ = TRUE; }
+ | AFTER { $$ = FALSE; }
;
-TriggerEvents: TriggerOneEvent
+TriggerEvents:
+ TriggerOneEvent
{
char *e = palloc (4);
e[0] = $1; e[1] = 0; $$ = e;
}
;
-TriggerOneEvent: INSERT { $$ = 'i'; }
- | DELETE_P { $$ = 'd'; }
- | UPDATE { $$ = 'u'; }
+TriggerOneEvent:
+ INSERT { $$ = 'i'; }
+ | DELETE_P { $$ = 'd'; }
+ | UPDATE { $$ = 'u'; }
;
-TriggerForSpec: FOR TriggerForOpt TriggerForType
+TriggerForSpec:
+ FOR TriggerForOpt TriggerForType
{
$$ = $3;
}
;
-TriggerForOpt: EACH { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+TriggerForOpt:
+ EACH { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-TriggerForType: ROW { $$ = TRUE; }
- | STATEMENT { $$ = FALSE; }
+TriggerForType:
+ ROW { $$ = TRUE; }
+ | STATEMENT { $$ = FALSE; }
;
-TriggerFuncArgs: TriggerFuncArg
- { $$ = makeList1($1); }
+TriggerFuncArgs:
+ TriggerFuncArg { $$ = makeList1($1); }
| TriggerFuncArgs ',' TriggerFuncArg
- { $$ = lappend($1, $3); }
- | /*EMPTY*/
- { $$ = NIL; }
+ { $$ = lappend($1, $3); }
+ | /*EMPTY*/ { $$ = NIL; }
;
-TriggerFuncArg: ICONST
+TriggerFuncArg:
+ ICONST
{
char buf[64];
sprintf (buf, "%d", $1);
$$ = makeString(pstrdup(buf));
}
- | FCONST
- {
- $$ = makeString($1);
- }
- | Sconst
- {
- $$ = makeString($1);
- }
- | BITCONST
- {
- $$ = makeString($1);
- }
- | ColId
- {
- $$ = makeString($1);
- }
+ | FCONST { $$ = makeString($1); }
+ | Sconst { $$ = makeString($1); }
+ | BITCONST { $$ = makeString($1); }
+ | ColId { $$ = makeString($1); }
+ ;
+
+OptConstrFromTable:
+ FROM qualified_name { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
;
-OptConstrFromTable: /* Empty */
+ConstraintAttributeSpec:
+ ConstraintDeferrabilitySpec
+ { $$ = $1; }
+ | ConstraintDeferrabilitySpec ConstraintTimeSpec
{
- $$ = NULL;
+ if ($1 == 0 && $2 != 0)
+ elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
+ $$ = $1 | $2;
}
- | FROM qualified_name
+ | ConstraintTimeSpec
{
- $$ = $2;
+ if ($1 != 0)
+ $$ = 3;
+ else
+ $$ = 0;
}
+ | ConstraintTimeSpec ConstraintDeferrabilitySpec
+ {
+ if ($2 == 0 && $1 != 0)
+ elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
+ $$ = $1 | $2;
+ }
+ | /*EMPTY*/
+ { $$ = 0; }
;
-ConstraintAttributeSpec: ConstraintDeferrabilitySpec
- { $$ = $1; }
- | ConstraintDeferrabilitySpec ConstraintTimeSpec
- {
- if ($1 == 0 && $2 != 0)
- elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
- $$ = $1 | $2;
- }
- | ConstraintTimeSpec
- {
- if ($1 != 0)
- $$ = 3;
- else
- $$ = 0;
- }
- | ConstraintTimeSpec ConstraintDeferrabilitySpec
- {
- if ($2 == 0 && $1 != 0)
- elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
- $$ = $1 | $2;
- }
- | /* Empty */
- { $$ = 0; }
- ;
-
-ConstraintDeferrabilitySpec: NOT DEFERRABLE
- { $$ = 0; }
- | DEFERRABLE
- { $$ = 1; }
+ConstraintDeferrabilitySpec:
+ NOT DEFERRABLE { $$ = 0; }
+ | DEFERRABLE { $$ = 1; }
;
-ConstraintTimeSpec: INITIALLY IMMEDIATE
- { $$ = 0; }
- | INITIALLY DEFERRED
- { $$ = 2; }
+ConstraintTimeSpec:
+ INITIALLY IMMEDIATE { $$ = 0; }
+ | INITIALLY DEFERRED { $$ = 2; }
;
-DropTrigStmt: DROP TRIGGER name ON qualified_name
+DropTrigStmt:
+ DROP TRIGGER name ON qualified_name
{
DropPropertyStmt *n = makeNode(DropPropertyStmt);
n->relation = $5;
*
*****************************************************************************/
-CreateAssertStmt: CREATE ASSERTION name
- CHECK '(' a_expr ')' ConstraintAttributeSpec
+CreateAssertStmt:
+ CREATE ASSERTION name CHECK '(' a_expr ')' ConstraintAttributeSpec
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
n->trigname = $3;
}
;
-DropAssertStmt: DROP ASSERTION name
+DropAssertStmt:
+ DROP ASSERTION name
{
DropPropertyStmt *n = makeNode(DropPropertyStmt);
n->relation = NULL;
*
*****************************************************************************/
-DefineStmt: CREATE AGGREGATE func_name definition
+DefineStmt:
+ CREATE AGGREGATE func_name definition
{
DefineStmt *n = makeNode(DefineStmt);
n->defType = AGGREGATE;
n->definition = $4;
$$ = (Node *)n;
}
- | CREATE OPERATOR any_operator definition
+ | CREATE OPERATOR any_operator definition
{
DefineStmt *n = makeNode(DefineStmt);
n->defType = OPERATOR;
n->definition = $4;
$$ = (Node *)n;
}
- | CREATE TYPE_P any_name definition
+ | CREATE TYPE_P any_name definition
{
DefineStmt *n = makeNode(DefineStmt);
n->defType = TYPE_P;
n->definition = $4;
$$ = (Node *)n;
}
- | CREATE CHARACTER SET opt_as any_name GET definition opt_collate
+ | CREATE CHARACTER SET opt_as any_name GET definition opt_collate
{
DefineStmt *n = makeNode(DefineStmt);
n->defType = CHARACTER;
}
;
-definition: '(' def_list ')' { $$ = $2; }
+definition: '(' def_list ')' { $$ = $2; }
;
-def_list: def_elem { $$ = makeList1($1); }
- | def_list ',' def_elem { $$ = lappend($1, $3); }
+def_list: def_elem { $$ = makeList1($1); }
+ | def_list ',' def_elem { $$ = lappend($1, $3); }
;
def_elem: ColLabel '=' def_arg
$$->defname = $1;
$$->arg = (Node *)$3;
}
- | ColLabel
+ | ColLabel
{
$$ = makeNode(DefElem);
$$->defname = $1;
;
/* Note: any simple identifier will be returned as a type name! */
-def_arg: func_return { $$ = (Node *)$1; }
- | all_Op { $$ = (Node *)makeString($1); }
- | NumericOnly { $$ = (Node *)$1; }
- | Sconst { $$ = (Node *)makeString($1); }
+def_arg: func_return { $$ = (Node *)$1; }
+ | all_Op { $$ = (Node *)makeString($1); }
+ | NumericOnly { $$ = (Node *)$1; }
+ | Sconst { $$ = (Node *)makeString($1); }
;
*
*****************************************************************************/
-DropStmt: DROP drop_type any_name_list opt_drop_behavior
+DropStmt: DROP drop_type any_name_list opt_drop_behavior
{
DropStmt *n = makeNode(DropStmt);
n->removeType = $2;
}
;
-drop_type: TABLE { $$ = DROP_TABLE; }
- | SEQUENCE { $$ = DROP_SEQUENCE; }
- | VIEW { $$ = DROP_VIEW; }
- | INDEX { $$ = DROP_INDEX; }
- | TYPE_P { $$ = DROP_TYPE; }
- | DOMAIN_P { $$ = DROP_DOMAIN; }
+drop_type: TABLE { $$ = DROP_TABLE; }
+ | SEQUENCE { $$ = DROP_SEQUENCE; }
+ | VIEW { $$ = DROP_VIEW; }
+ | INDEX { $$ = DROP_INDEX; }
+ | TYPE_P { $$ = DROP_TYPE; }
+ | DOMAIN_P { $$ = DROP_DOMAIN; }
;
-any_name_list: any_name
- { $$ = makeList1($1); }
- | any_name_list ',' any_name
- { $$ = lappend($1, $3); }
+any_name_list:
+ any_name { $$ = makeList1($1); }
+ | any_name_list ',' any_name { $$ = lappend($1, $3); }
;
-any_name: ColId
- { $$ = makeList1(makeString($1)); }
- | dotted_name
- { $$ = $1; }
+any_name: ColId { $$ = makeList1(makeString($1)); }
+ | dotted_name { $$ = $1; }
;
/*****************************************************************************
*
*****************************************************************************/
-TruncateStmt: TRUNCATE opt_table qualified_name
+TruncateStmt:
+ TRUNCATE opt_table qualified_name
{
TruncateStmt *n = makeNode(TruncateStmt);
n->relation = $3;
$$ = (Node *)n;
}
- ;
+ ;
/*****************************************************************************
*
- * The COMMENT ON statement can take different forms based upon the type of
- * the object associated with the comment. The form of the statement is:
+ * The COMMENT ON statement can take different forms based upon the type of
+ * the object associated with the comment. The form of the statement is:
*
- * COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW ]
- *
<objname> | AGGREGATE <aggname> (<aggtype>) | FUNCTION
+ * COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW ]
+ * <objname> | AGGREGATE <aggname> (<aggtype>) | FUNCTION
* <funcname> (arg1, arg2, ...) | OPERATOR <op>
* (leftoperand_typ rightoperand_typ) | TRIGGER <triggername> ON
* <relname> | RULE <rulename> ON <relname> ] IS 'text'
*
*****************************************************************************/
-CommentStmt: COMMENT ON comment_type any_name IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = $3;
- n->objname = $4;
- n->objargs = NIL;
- n->comment = $6;
- $$ = (Node *) n;
- }
- | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')' IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = AGGREGATE;
- n->objname = $4;
- n->objargs = makeList1($6);
- n->comment = $9;
- $$ = (Node *) n;
- }
- | COMMENT ON FUNCTION func_name func_args IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = FUNCTION;
- n->objname = $4;
- n->objargs = $5;
- n->comment = $7;
- $$ = (Node *) n;
- }
- | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')' IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = OPERATOR;
- n->objname = $4;
- n->objargs = $6;
- n->comment = $9;
- $$ = (Node *) n;
- }
- | COMMENT ON TRIGGER name ON any_name IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = TRIGGER;
- n->objname = lappend($6, makeString($4));
- n->objargs = NIL;
- n->comment = $8;
- $$ = (Node *) n;
- }
- | COMMENT ON RULE name ON any_name IS comment_text
- {
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = RULE;
- n->objname = lappend($6, makeString($4));
- n->objargs = NIL;
- n->comment = $8;
- $$ = (Node *) n;
- }
- | COMMENT ON RULE name IS comment_text
- {
- /* Obsolete syntax supported for awhile for compatibility */
- CommentStmt *n = makeNode(CommentStmt);
- n->objtype = RULE;
- n->objname = makeList1(makeString($4));
- n->objargs = NIL;
- n->comment = $6;
- $$ = (Node *) n;
- }
+CommentStmt:
+ COMMENT ON comment_type any_name IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = $3;
+ n->objname = $4;
+ n->objargs = NIL;
+ n->comment = $6;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')' IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = AGGREGATE;
+ n->objname = $4;
+ n->objargs = makeList1($6);
+ n->comment = $9;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON FUNCTION func_name func_args IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = FUNCTION;
+ n->objname = $4;
+ n->objargs = $5;
+ n->comment = $7;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')' IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = OPERATOR;
+ n->objname = $4;
+ n->objargs = $6;
+ n->comment = $9;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON TRIGGER name ON any_name IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = TRIGGER;
+ n->objname = lappend($6, makeString($4));
+ n->objargs = NIL;
+ n->comment = $8;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON RULE name ON any_name IS comment_text
+ {
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = RULE;
+ n->objname = lappend($6, makeString($4));
+ n->objargs = NIL;
+ n->comment = $8;
+ $$ = (Node *) n;
+ }
+ | COMMENT ON RULE name IS comment_text
+ {
+ /* Obsolete syntax supported for awhile for compatibility */
+ CommentStmt *n = makeNode(CommentStmt);
+ n->objtype = RULE;
+ n->objname = makeList1(makeString($4));
+ n->objargs = NIL;
+ n->comment = $6;
+ $$ = (Node *) n;
+ }
;
-comment_type: COLUMN { $$ = COLUMN; }
- | DATABASE { $$ = DATABASE; }
- | SCHEMA { $$ = SCHEMA; }
- | INDEX { $$ = INDEX; }
- | SEQUENCE { $$ = SEQUENCE; }
- | TABLE { $$ = TABLE; }
- | DOMAIN_P { $$ = TYPE_P; }
- | TYPE_P { $$ = TYPE_P; }
- | VIEW { $$ = VIEW; }
+comment_type:
+ COLUMN { $$ = COLUMN; }
+ | DATABASE { $$ = DATABASE; }
+ | SCHEMA { $$ = SCHEMA; }
+ | INDEX { $$ = INDEX; }
+ | SEQUENCE { $$ = SEQUENCE; }
+ | TABLE { $$ = TABLE; }
+ | DOMAIN_P { $$ = TYPE_P; }
+ | TYPE_P { $$ = TYPE_P; }
+ | VIEW { $$ = VIEW; }
;
-comment_text: Sconst { $$ = $1; }
- | NULL_P { $$ = NULL; }
+comment_text:
+ Sconst { $$ = $1; }
+ | NULL_P { $$ = NULL; }
;
/*****************************************************************************
* QUERY:
* fetch/move [forward | backward] [ # | all ] [ in <portalname> ]
* fetch [ forward | backward | absolute | relative ]
- * [ # | all | next | prior ] [ [ in | from ] <portalname> ]
+ * [ # | all | next | prior ] [ [ in | from ] <portalname> ]
*
*****************************************************************************/
-FetchStmt: FETCH direction fetch_how_many from_in name
+FetchStmt: FETCH direction fetch_how_many from_in name
{
FetchStmt *n = makeNode(FetchStmt);
if ($2 == RELATIVE)
n->ismove = FALSE;
$$ = (Node *)n;
}
- | FETCH fetch_how_many from_in name
+ | FETCH fetch_how_many from_in name
{
FetchStmt *n = makeNode(FetchStmt);
if ($2 < 0)
n->ismove = FALSE;
$$ = (Node *)n;
}
- | FETCH direction from_in name
+ | FETCH direction from_in name
{
FetchStmt *n = makeNode(FetchStmt);
if ($2 == RELATIVE)
n->ismove = FALSE;
$$ = (Node *)n;
}
- | FETCH from_in name
+ | FETCH from_in name
{
FetchStmt *n = makeNode(FetchStmt);
n->direction = FORWARD;
n->ismove = FALSE;
$$ = (Node *)n;
}
- | FETCH name
+ | FETCH name
{
FetchStmt *n = makeNode(FetchStmt);
n->direction = FORWARD;
n->ismove = FALSE;
$$ = (Node *)n;
}
-
- | MOVE direction fetch_how_many from_in name
+ | MOVE direction fetch_how_many from_in name
{
FetchStmt *n = makeNode(FetchStmt);
if ($3 < 0)
n->ismove = TRUE;
$$ = (Node *)n;
}
- | MOVE fetch_how_many from_in name
+ | MOVE fetch_how_many from_in name
{
FetchStmt *n = makeNode(FetchStmt);
if ($2 < 0)
n->ismove = TRUE;
$$ = (Node *)n;
}
- | MOVE direction from_in name
+ | MOVE direction from_in name
{
FetchStmt *n = makeNode(FetchStmt);
n->direction = $2;
n->ismove = TRUE;
$$ = (Node *)n;
}
- | MOVE from_in name
+ | MOVE from_in name
{
FetchStmt *n = makeNode(FetchStmt);
n->direction = FORWARD;
n->ismove = TRUE;
$$ = (Node *)n;
}
- | MOVE name
+ | MOVE name
{
FetchStmt *n = makeNode(FetchStmt);
n->direction = FORWARD;
}
;
-direction: FORWARD { $$ = FORWARD; }
- | BACKWARD { $$ = BACKWARD; }
- | RELATIVE { $$ = RELATIVE; }
- | ABSOLUTE
- {
- elog(NOTICE,"FETCH / ABSOLUTE not supported, using RELATIVE");
- $$ = RELATIVE;
- }
+direction: FORWARD { $$ = FORWARD; }
+ | BACKWARD { $$ = BACKWARD; }
+ | RELATIVE { $$ = RELATIVE; }
+ | ABSOLUTE
+ {
+ elog(NOTICE,"FETCH / ABSOLUTE not supported, using RELATIVE");
+ $$ = RELATIVE;
+ }
;
-fetch_how_many: Iconst { $$ = $1; }
- | '-' Iconst { $$ = - $2; }
- | ALL { $$ = 0; /* 0 means fetch all tuples*/ }
- | NEXT { $$ = 1; }
- | PRIOR { $$ = -1; }
+fetch_how_many:
+ Iconst { $$ = $1; }
+ | '-' Iconst { $$ = - $2; }
+ | ALL { $$ = 0; /* 0 means fetch all tuples*/ }
+ | NEXT { $$ = 1; }
+ | PRIOR { $$ = -1; }
;
-from_in: IN_P { }
- | FROM { }
- ;
+from_in: IN_P { }
+ | FROM { }
+ ;
/*****************************************************************************
*
*****************************************************************************/
-GrantStmt: GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option
+GrantStmt: GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option
{
GrantStmt *n = makeNode(GrantStmt);
n->is_grant = true;
}
;
-RevokeStmt: REVOKE opt_revoke_grant_option privileges ON privilege_target FROM grantee_list
+RevokeStmt: REVOKE opt_revoke_grant_option privileges ON privilege_target FROM grantee_list
{
GrantStmt *n = makeNode(GrantStmt);
n->is_grant = false;
/* either ALL [PRIVILEGES] or a list of individual privileges */
-privileges: privilege_list { $$ = $1; }
- | ALL { $$ = makeListi1(ACL_ALL_RIGHTS); }
- | ALL PRIVILEGES { $$ = makeListi1(ACL_ALL_RIGHTS); }
+privileges: privilege_list { $$ = $1; }
+ | ALL { $$ = makeListi1(ACL_ALL_RIGHTS); }
+ | ALL PRIVILEGES { $$ = makeListi1(ACL_ALL_RIGHTS); }
;
-privilege_list: privilege { $$ = makeListi1($1); }
- | privilege_list ',' privilege { $$ = lappendi($1, $3); }
+privilege_list:
+ privilege { $$ = makeListi1($1); }
+ | privilege_list ',' privilege { $$ = lappendi($1, $3); }
;
/* Not all of these privilege types apply to all objects, but that
* gets sorted out later.
*/
-privilege: SELECT { $$ = ACL_SELECT; }
- | INSERT { $$ = ACL_INSERT; }
- | UPDATE { $$ = ACL_UPDATE; }
- | DELETE_P { $$ = ACL_DELETE; }
- | RULE { $$ = ACL_RULE; }
- | REFERENCES { $$ = ACL_REFERENCES; }
- | TRIGGER { $$ = ACL_TRIGGER; }
- | EXECUTE { $$ = ACL_EXECUTE; }
- | USAGE { $$ = ACL_USAGE; }
- | CREATE { $$ = ACL_CREATE; }
- | TEMPORARY { $$ = ACL_CREATE_TEMP; }
- | TEMP { $$ = ACL_CREATE_TEMP; }
+privilege: SELECT { $$ = ACL_SELECT; }
+ | INSERT { $$ = ACL_INSERT; }
+ | UPDATE { $$ = ACL_UPDATE; }
+ | DELETE_P { $$ = ACL_DELETE; }
+ | RULE { $$ = ACL_RULE; }
+ | REFERENCES { $$ = ACL_REFERENCES; }
+ | TRIGGER { $$ = ACL_TRIGGER; }
+ | EXECUTE { $$ = ACL_EXECUTE; }
+ | USAGE { $$ = ACL_USAGE; }
+ | CREATE { $$ = ACL_CREATE; }
+ | TEMPORARY { $$ = ACL_CREATE_TEMP; }
+ | TEMP { $$ = ACL_CREATE_TEMP; }
;
/* Don't bother trying to fold the first two rules into one using
opt_table. You're going to get conflicts. */
-privilege_target: qualified_name_list
+privilege_target:
+ qualified_name_list
{
PrivTarget *n = makeNode(PrivTarget);
n->objtype = ACL_OBJECT_RELATION;
;
-grantee_list: grantee { $$ = makeList1($1); }
- | grantee_list ',' grantee { $$ = lappend($1, $3); }
+grantee_list:
+ grantee { $$ = makeList1($1); }
+ | grantee_list ',' grantee { $$ = lappend($1, $3); }
;
-grantee: ColId
+grantee: ColId
{
PrivGrantee *n = makeNode(PrivGrantee);
/* This hack lets us avoid reserving PUBLIC as a keyword */
n->groupname = NULL;
$$ = (Node *)n;
}
- | GROUP_P ColId
+ | GROUP_P ColId
{
PrivGrantee *n = makeNode(PrivGrantee);
/* Treat GROUP PUBLIC as a synonym for PUBLIC */
;
-opt_grant_grant_option: WITH GRANT OPTION
+opt_grant_grant_option:
+ WITH GRANT OPTION
{
elog(ERROR, "grant options are not implemented");
}
- | /*EMPTY*/
+ | /*EMPTY*/
;
-opt_revoke_grant_option: GRANT OPTION FOR
+opt_revoke_grant_option:
+ GRANT OPTION FOR
{
elog(ERROR, "grant options are not implemented");
}
- | /*EMPTY*/
+ | /*EMPTY*/
;
-function_with_argtypes_list: function_with_argtypes
+function_with_argtypes_list:
+ function_with_argtypes
{ $$ = makeList1($1); }
- | function_with_argtypes_list ',' function_with_argtypes
+ | function_with_argtypes_list ',' function_with_argtypes
{ $$ = lappend($1, $3); }
;
-function_with_argtypes: func_name func_args
+function_with_argtypes:
+ func_name func_args
{
FuncWithArgs *n = makeNode(FuncWithArgs);
n->funcname = $1;
}
;
-index_opt_unique: UNIQUE { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+index_opt_unique:
+ UNIQUE { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-access_method_clause: USING access_method { $$ = $2; }
- /* If btree changes as our default, update pg_get_indexdef() */
- | /*EMPTY*/ { $$ = DEFAULT_INDEX_TYPE; }
+access_method_clause:
+ USING access_method { $$ = $2; }
+ /* If btree changes as our default, update pg_get_indexdef() */
+ | /*EMPTY*/ { $$ = DEFAULT_INDEX_TYPE; }
;
-index_params: index_list { $$ = $1; }
- | func_index { $$ = makeList1($1); }
+index_params:
+ index_list { $$ = $1; }
+ | func_index { $$ = makeList1($1); }
;
-index_list: index_list ',' index_elem { $$ = lappend($1, $3); }
- | index_elem { $$ = makeList1($1); }
+index_list: index_list ',' index_elem { $$ = lappend($1, $3); }
+ | index_elem { $$ = makeList1($1); }
;
-func_index: func_name '(' name_list ')' opt_class
+func_index: func_name '(' name_list ')' opt_class
{
$$ = makeNode(IndexElem);
$$->name = NULL;
}
;
-index_elem: attr_name opt_class
+index_elem: attr_name opt_class
{
$$ = makeNode(IndexElem);
$$->name = $1;
}
;
-opt_class: any_name
+opt_class: any_name
{
/*
* Release 7.0 removed network_ops, timespan_ops, and
else
$$ = $1;
}
- | USING any_name { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
+ | USING any_name { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
;
/*****************************************************************************
*
*****************************************************************************/
-CreateFunctionStmt: CREATE opt_or_replace FUNCTION func_name func_args
- RETURNS func_return createfunc_opt_list opt_definition
+CreateFunctionStmt:
+ CREATE opt_or_replace FUNCTION func_name func_args
+ RETURNS func_return createfunc_opt_list opt_definition
{
CreateFunctionStmt *n = makeNode(CreateFunctionStmt);
n->replace = $2;
n->options = $8;
n->withClause = $9;
$$ = (Node *)n;
- };
+ }
+ ;
-opt_or_replace: OR REPLACE { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_or_replace:
+ OR REPLACE { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-func_args: '(' func_args_list ')' { $$ = $2; }
- | '(' ')' { $$ = NIL; }
+func_args: '(' func_args_list ')' { $$ = $2; }
+ | '(' ')' { $$ = NIL; }
;
-func_args_list: func_arg
- { $$ = makeList1($1); }
- | func_args_list ',' func_arg
- { $$ = lappend($1, $3); }
+func_args_list:
+ func_arg { $$ = makeList1($1); }
+ | func_args_list ',' func_arg { $$ = lappend($1, $3); }
;
-func_arg: opt_arg func_type
+func_arg: opt_arg func_type
{
/* We can catch over-specified arguments here if we want to,
* but for now better to silently swallow typmod, etc.
*/
$$ = $2;
}
- | func_type
- {
- $$ = $1;
- }
+ | func_type { $$ = $1; }
;
-opt_arg: IN_P
- {
- $$ = FALSE;
- }
- | OUT_P
+opt_arg: IN_P { $$ = FALSE; }
+ | OUT_P
{
elog(ERROR, "CREATE FUNCTION / OUT parameters are not supported");
$$ = TRUE;
}
- | INOUT
+ | INOUT
{
elog(ERROR, "CREATE FUNCTION / INOUT parameters are not supported");
$$ = FALSE;
}
;
-func_return: func_type
+func_return:
+ func_type
{
/* We can catch over-specified arguments here if we want to,
* but for now better to silently swallow typmod, etc.
* We would like to make the second production here be ColId attrs etc,
* but that causes reduce/reduce conflicts. type_name is next best choice.
*/
-func_type: Typename
- {
- $$ = $1;
- }
- | type_name attrs '%' TYPE_P
+func_type: Typename { $$ = $1; }
+ | type_name attrs '%' TYPE_P
{
$$ = makeNode(TypeName);
$$->names = lcons(makeString($1), $2);
;
-createfunc_opt_list: createfunc_opt_item
- { $$ = makeList1($1); }
- | createfunc_opt_list createfunc_opt_item
- { $$ = lappend($1, $2); }
- ;
+createfunc_opt_list:
+ createfunc_opt_item { $$ = makeList1($1); }
+ | createfunc_opt_list createfunc_opt_item { $$ = lappend($1, $2); }
+ ;
-createfunc_opt_item: AS func_as
+createfunc_opt_item:
+ AS func_as
{
$$ = makeNode(DefElem);
$$->defname = "as";
$$->arg = (Node *)$2;
}
- | LANGUAGE ColId_or_Sconst
+ | LANGUAGE ColId_or_Sconst
{
$$ = makeNode(DefElem);
$$->defname = "language";
$$->arg = (Node *)makeString($2);
}
- | IMMUTABLE
+ | IMMUTABLE
{
$$ = makeNode(DefElem);
$$->defname = "volatility";
$$->arg = (Node *)makeString("immutable");
}
- | STABLE
+ | STABLE
{
$$ = makeNode(DefElem);
$$->defname = "volatility";
$$->arg = (Node *)makeString("stable");
}
- | VOLATILE
+ | VOLATILE
{
$$ = makeNode(DefElem);
$$->defname = "volatility";
$$->arg = (Node *)makeString("volatile");
}
- | CALLED ON NULL_P INPUT
+ | CALLED ON NULL_P INPUT
{
$$ = makeNode(DefElem);
$$->defname = "strict";
$$->arg = (Node *)makeInteger(FALSE);
}
- | RETURNS NULL_P ON NULL_P INPUT
+ | RETURNS NULL_P ON NULL_P INPUT
{
$$ = makeNode(DefElem);
$$->defname = "strict";
$$->arg = (Node *)makeInteger(TRUE);
}
- | STRICT
+ | STRICT
{
$$ = makeNode(DefElem);
$$->defname = "strict";
$$->arg = (Node *)makeInteger(TRUE);
}
- | EXTERNAL SECURITY DEFINER
+ | EXTERNAL SECURITY DEFINER
{
$$ = makeNode(DefElem);
$$->defname = "security";
$$->arg = (Node *)makeInteger(TRUE);
}
- | EXTERNAL SECURITY INVOKER
+ | EXTERNAL SECURITY INVOKER
{
$$ = makeNode(DefElem);
$$->defname = "security";
$$->arg = (Node *)makeInteger(FALSE);
}
- | SECURITY DEFINER
+ | SECURITY DEFINER
{
$$ = makeNode(DefElem);
$$->defname = "security";
$$->arg = (Node *)makeInteger(TRUE);
}
- | SECURITY INVOKER
+ | SECURITY INVOKER
{
$$ = makeNode(DefElem);
$$->defname = "security";
$$->arg = (Node *)makeInteger(FALSE);
}
- | IMPLICIT CAST
+ | IMPLICIT CAST
{
$$ = makeNode(DefElem);
$$->defname = "implicit";
}
;
-func_as: Sconst
- { $$ = makeList1(makeString($1)); }
- | Sconst ',' Sconst
- { $$ = makeList2(makeString($1), makeString($3)); }
+func_as: Sconst { $$ = makeList1(makeString($1)); }
+ | Sconst ',' Sconst { $$ = makeList2(makeString($1), makeString($3)); }
;
-opt_definition: WITH definition { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
+opt_definition:
+ WITH definition { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
;
*
*****************************************************************************/
-RemoveFuncStmt: DROP FUNCTION func_name func_args
+RemoveFuncStmt:
+ DROP FUNCTION func_name func_args
{
RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
n->funcname = $3;
}
;
-RemoveAggrStmt: DROP AGGREGATE func_name '(' aggr_argtype ')'
+RemoveAggrStmt:
+ DROP AGGREGATE func_name '(' aggr_argtype ')'
{
RemoveAggrStmt *n = makeNode(RemoveAggrStmt);
n->aggname = $3;
}
;
-aggr_argtype: Typename { $$ = $1; }
- | '*' { $$ = NULL; }
+aggr_argtype:
+ Typename { $$ = $1; }
+ | '*' { $$ = NULL; }
;
-RemoveOperStmt: DROP OPERATOR any_operator '(' oper_argtypes ')'
+RemoveOperStmt:
+ DROP OPERATOR any_operator '(' oper_argtypes ')'
{
RemoveOperStmt *n = makeNode(RemoveOperStmt);
n->opname = $3;
}
;
-oper_argtypes: Typename
+oper_argtypes:
+ Typename
{
elog(ERROR,"parser: argument type missing (use NONE for unary operators)");
}
- | Typename ',' Typename
- { $$ = makeList2($1, $3); }
- | NONE ',' Typename /* left unary */
- { $$ = makeList2(NULL, $3); }
- | Typename ',' NONE /* right unary */
- { $$ = makeList2($1, NULL); }
+ | Typename ',' Typename { $$ = makeList2($1, $3); }
+ | NONE ',' Typename /* left unary */ { $$ = makeList2(NULL, $3); }
+ | Typename ',' NONE /* right unary */ { $$ = makeList2($1, NULL); }
;
-any_operator: all_Op
- { $$ = makeList1(makeString($1)); }
- | ColId '.' any_operator
- { $$ = lcons(makeString($1), $3); }
+any_operator:
+ all_Op { $$ = makeList1(makeString($1)); }
+ | ColId '.' any_operator { $$ = lcons(makeString($1), $3); }
;
*
*****************************************************************************/
-ReindexStmt: REINDEX reindex_type qualified_name opt_force
+ReindexStmt:
+ REINDEX reindex_type qualified_name opt_force
{
ReindexStmt *n = makeNode(ReindexStmt);
n->reindexType = $2;
n->force = $4;
$$ = (Node *)n;
}
- | REINDEX DATABASE name opt_force
+ | REINDEX DATABASE name opt_force
{
ReindexStmt *n = makeNode(ReindexStmt);
n->reindexType = DATABASE;
}
;
-reindex_type: INDEX { $$ = INDEX; }
- | TABLE { $$ = TABLE; }
+reindex_type:
+ INDEX { $$ = INDEX; }
+ | TABLE { $$ = TABLE; }
;
opt_force: FORCE { $$ = TRUE; }
- | /* EMPTY */ { $$ = FALSE; }
+ | /* EMPTY */ { $$ = FALSE; }
;
*
*****************************************************************************/
-RenameStmt: ALTER TABLE relation_expr RENAME opt_column opt_name TO name
+RenameStmt: ALTER TABLE relation_expr RENAME opt_column opt_name TO name
{
RenameStmt *n = makeNode(RenameStmt);
n->relation = $3;
n->renameType = RENAME_COLUMN;
$$ = (Node *)n;
}
- | ALTER TRIGGER name ON relation_expr RENAME TO name
+ | ALTER TRIGGER name ON relation_expr RENAME TO name
{
RenameStmt *n = makeNode(RenameStmt);
n->relation = $5;
}
;
-opt_name: name { $$ = $1; }
- | /*EMPTY*/ { $$ = NULL; }
+opt_name: name { $$ = $1; }
+ | /*EMPTY*/ { $$ = NULL; }
;
-opt_column: COLUMN { $$ = COLUMN; }
- | /*EMPTY*/ { $$ = 0; }
+opt_column: COLUMN { $$ = COLUMN; }
+ | /*EMPTY*/ { $$ = 0; }
;
*
*****************************************************************************/
-RuleStmt: CREATE RULE name AS
+RuleStmt: CREATE RULE name AS
{ QueryIsRule=TRUE; }
ON event TO qualified_name where_clause
DO opt_instead RuleActionList
}
;
-RuleActionList: NOTHING { $$ = NIL; }
- | RuleActionStmt { $$ = makeList1($1); }
- | '(' RuleActionMulti ')' { $$ = $2; }
+RuleActionList:
+ NOTHING { $$ = NIL; }
+ | RuleActionStmt { $$ = makeList1($1); }
+ | '(' RuleActionMulti ')' { $$ = $2; }
;
/* the thrashing around here is to discard "empty" statements... */
-RuleActionMulti: RuleActionMulti ';' RuleActionStmtOrEmpty
+RuleActionMulti:
+ RuleActionMulti ';' RuleActionStmtOrEmpty
{ if ($3 != (Node *) NULL)
$$ = lappend($1, $3);
else
$$ = $1;
}
- | RuleActionStmtOrEmpty
+ | RuleActionStmtOrEmpty
{ if ($1 != (Node *) NULL)
$$ = makeList1($1);
else
}
;
-RuleActionStmt: SelectStmt
- | InsertStmt
- | UpdateStmt
- | DeleteStmt
- | NotifyStmt
+RuleActionStmt:
+ SelectStmt
+ | InsertStmt
+ | UpdateStmt
+ | DeleteStmt
+ | NotifyStmt
;
-RuleActionStmtOrEmpty: RuleActionStmt
- | /*EMPTY*/
- { $$ = (Node *)NULL; }
+RuleActionStmtOrEmpty:
+ RuleActionStmt { $$ = $1; }
+ | /*EMPTY*/ { $$ = (Node *)NULL; }
;
/* change me to select, update, etc. some day */
-event: SELECT { $$ = CMD_SELECT; }
- | UPDATE { $$ = CMD_UPDATE; }
- | DELETE_P { $$ = CMD_DELETE; }
- | INSERT { $$ = CMD_INSERT; }
+event: SELECT { $$ = CMD_SELECT; }
+ | UPDATE { $$ = CMD_UPDATE; }
+ | DELETE_P { $$ = CMD_DELETE; }
+ | INSERT { $$ = CMD_INSERT; }
;
-opt_instead: INSTEAD { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_instead:
+ INSTEAD { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-DropRuleStmt: DROP RULE name ON qualified_name
+DropRuleStmt:
+ DROP RULE name ON qualified_name
{
DropPropertyStmt *n = makeNode(DropPropertyStmt);
n->relation = $5;
/*****************************************************************************
*
* QUERY:
- * NOTIFY <qualified_name> can appear both in rule bodies and
+ * NOTIFY <qualified_name> can appear both in rule bodies and
* as a query-level command
*
*****************************************************************************/
-NotifyStmt: NOTIFY qualified_name
+NotifyStmt: NOTIFY qualified_name
{
NotifyStmt *n = makeNode(NotifyStmt);
n->relation = $2;
}
;
-ListenStmt: LISTEN qualified_name
+ListenStmt: LISTEN qualified_name
{
ListenStmt *n = makeNode(ListenStmt);
n->relation = $2;
}
;
-UnlistenStmt: UNLISTEN qualified_name
+UnlistenStmt:
+ UNLISTEN qualified_name
{
UnlistenStmt *n = makeNode(UnlistenStmt);
n->relation = $2;
$$ = (Node *)n;
}
- | UNLISTEN '*'
+ | UNLISTEN '*'
{
UnlistenStmt *n = makeNode(UnlistenStmt);
n->relation = makeNode(RangeVar);
*
* Transactions:
*
- * BEGIN / COMMIT / ROLLBACK
- * (also older versions END / ABORT)
+ * BEGIN / COMMIT / ROLLBACK
+ * (also older versions END / ABORT)
*
*****************************************************************************/
-TransactionStmt: ABORT_TRANS opt_trans
+TransactionStmt:
+ ABORT_TRANS opt_trans
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = ROLLBACK;
$$ = (Node *)n;
}
- | BEGIN_TRANS opt_trans
+ | BEGIN_TRANS opt_trans
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = BEGIN_TRANS;
$$ = (Node *)n;
}
- | COMMIT opt_trans
+ | COMMIT opt_trans
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = COMMIT;
$$ = (Node *)n;
}
- | COMMIT opt_trans opt_chain
+ | COMMIT opt_trans opt_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = COMMIT;
$$ = (Node *)n;
}
- | END_TRANS opt_trans
+ | END_TRANS opt_trans
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = COMMIT;
$$ = (Node *)n;
}
- | ROLLBACK opt_trans
+ | ROLLBACK opt_trans
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = ROLLBACK;
$$ = (Node *)n;
}
- | ROLLBACK opt_trans opt_chain
+ | ROLLBACK opt_trans opt_chain
{
TransactionStmt *n = makeNode(TransactionStmt);
n->command = ROLLBACK;
}
;
-opt_trans: WORK { $$ = TRUE; }
- | TRANSACTION { $$ = TRUE; }
- | /*EMPTY*/ { $$ = TRUE; }
+opt_trans: WORK { $$ = TRUE; }
+ | TRANSACTION { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = TRUE; }
;
-opt_chain: AND NO CHAIN
- { $$ = FALSE; }
- | AND CHAIN
+opt_chain: AND NO CHAIN { $$ = FALSE; }
+ | AND CHAIN
{
/* SQL99 asks that conforming dbs reject AND CHAIN
* if they don't support it. So we can't just ignore it.
*
*****************************************************************************/
-ViewStmt: CREATE VIEW qualified_name opt_column_list AS SelectStmt
+ViewStmt: CREATE VIEW qualified_name opt_column_list AS SelectStmt
{
ViewStmt *n = makeNode(ViewStmt);
n->view = $3;
*
*****************************************************************************/
-LoadStmt: LOAD file_name
+LoadStmt: LOAD file_name
{
LoadStmt *n = makeNode(LoadStmt);
n->filename = $2;
*
*****************************************************************************/
-CreatedbStmt: CREATE DATABASE database_name opt_with createdb_opt_list
+CreatedbStmt:
+ CREATE DATABASE database_name opt_with createdb_opt_list
{
CreatedbStmt *n = makeNode(CreatedbStmt);
List *l;
}
$$ = (Node *)n;
}
- | CREATE DATABASE database_name
+ | CREATE DATABASE database_name
{
CreatedbStmt *n = makeNode(CreatedbStmt);
n->dbname = $3;
}
;
-createdb_opt_list: createdb_opt_item
- { $$ = makeList1($1); }
- | createdb_opt_list createdb_opt_item
- { $$ = lappend($1, $2); }
+createdb_opt_list:
+ createdb_opt_item { $$ = makeList1($1); }
+ | createdb_opt_list createdb_opt_item { $$ = lappend($1, $2); }
;
/*
* createdb_opt_item returns 2-element lists, with the first element
* being an integer code to indicate which item was specified.
*/
-createdb_opt_item: LOCATION opt_equal Sconst
+createdb_opt_item:
+ LOCATION opt_equal Sconst
{
$$ = lconsi(1, makeList1($3));
}
- | LOCATION opt_equal DEFAULT
+ | LOCATION opt_equal DEFAULT
{
$$ = lconsi(1, makeList1(NULL));
}
- | TEMPLATE opt_equal name
+ | TEMPLATE opt_equal name
{
$$ = lconsi(2, makeList1($3));
}
- | TEMPLATE opt_equal DEFAULT
+ | TEMPLATE opt_equal DEFAULT
{
$$ = lconsi(2, makeList1(NULL));
}
- | ENCODING opt_equal Sconst
+ | ENCODING opt_equal Sconst
{
int encoding;
#ifdef MULTIBYTE
#endif
$$ = lconsi(3, makeListi1(encoding));
}
- | ENCODING opt_equal Iconst
+ | ENCODING opt_equal Iconst
{
#ifdef MULTIBYTE
if (!pg_get_enconv_by_encoding($3))
#endif
$$ = lconsi(3, makeListi1($3));
}
- | ENCODING opt_equal DEFAULT
+ | ENCODING opt_equal DEFAULT
{
$$ = lconsi(3, makeListi1(-1));
}
- | OWNER opt_equal name
+ | OWNER opt_equal name
{
$$ = lconsi(4, makeList1($3));
}
- | OWNER opt_equal DEFAULT
+ | OWNER opt_equal DEFAULT
{
$$ = lconsi(4, makeList1(NULL));
}
/*
* Though the equals sign doesn't match other WITH options, pg_dump uses
- * equals for backward compability, and it doesn't seem worth removing it.
- * 2002-02-25
+ * equals for backward compability, and it doesn't seem worth removing it.
+ * 2002-02-25
*/
-opt_equal: '=' { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_equal: '=' { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
*
*****************************************************************************/
-AlterDatabaseSetStmt: ALTER DATABASE database_name SET set_rest
+AlterDatabaseSetStmt:
+ ALTER DATABASE database_name SET set_rest
{
AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
n->dbname = $3;
n->value = $5->args;
$$ = (Node *)n;
}
- | ALTER DATABASE database_name VariableResetStmt
+ | ALTER DATABASE database_name VariableResetStmt
{
AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt);
n->dbname = $3;
*
*****************************************************************************/
-DropdbStmt: DROP DATABASE database_name
+DropdbStmt: DROP DATABASE database_name
{
DropdbStmt *n = makeNode(DropdbStmt);
n->dbname = $3;
*
*****************************************************************************/
-CreateDomainStmt: CREATE DOMAIN_P any_name opt_as Typename ColQualList opt_collate
+CreateDomainStmt:
+ CREATE DOMAIN_P any_name opt_as Typename ColQualList opt_collate
{
CreateDomainStmt *n = makeNode(CreateDomainStmt);
n->domainname = $3;
}
;
-opt_as: AS {$$ = TRUE; }
- | /* EMPTY */ {$$ = FALSE; }
- ;
+opt_as: AS {$$ = TRUE; }
+ | /* EMPTY */ {$$ = FALSE; }
+ ;
/*****************************************************************************
*
*****************************************************************************/
-ClusterStmt: CLUSTER index_name ON qualified_name
+ClusterStmt:
+ CLUSTER index_name ON qualified_name
{
ClusterStmt *n = makeNode(ClusterStmt);
n->relation = $4;
*
*****************************************************************************/
-VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
+VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
{
VacuumStmt *n = makeNode(VacuumStmt);
n->vacuum = true;
n->va_cols = NIL;
$$ = (Node *)n;
}
- | VACUUM opt_full opt_freeze opt_verbose qualified_name
+ | VACUUM opt_full opt_freeze opt_verbose qualified_name
{
VacuumStmt *n = makeNode(VacuumStmt);
n->vacuum = true;
n->va_cols = NIL;
$$ = (Node *)n;
}
- | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
+ | VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
{
VacuumStmt *n = (VacuumStmt *) $5;
n->vacuum = true;
}
;
-AnalyzeStmt: analyze_keyword opt_verbose
+AnalyzeStmt:
+ analyze_keyword opt_verbose
{
VacuumStmt *n = makeNode(VacuumStmt);
n->vacuum = false;
n->va_cols = NIL;
$$ = (Node *)n;
}
- | analyze_keyword opt_verbose qualified_name opt_name_list
+ | analyze_keyword opt_verbose qualified_name opt_name_list
{
VacuumStmt *n = makeNode(VacuumStmt);
n->vacuum = false;
}
;
-analyze_keyword: ANALYZE { $$ = TRUE; }
- | ANALYSE /* British */ { $$ = TRUE; }
+analyze_keyword:
+ ANALYZE { $$ = TRUE; }
+ | ANALYSE /* British */ { $$ = TRUE; }
;
-opt_verbose: VERBOSE { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_verbose:
+ VERBOSE { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-opt_full: FULL { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_full: FULL { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-opt_freeze: FREEZE { $$ = TRUE; }
- | /*EMPTY*/ { $$ = FALSE; }
+opt_freeze: FREEZE { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
;
-opt_name_list: '(' name_list ')' { $$ = $2; }
- | /*EMPTY*/ { $$ = NIL; }
+opt_name_list:
+ '(' name_list ')' { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
;
*
*****************************************************************************/
-ExplainStmt: EXPLAIN opt_verbose OptimizableStmt
+ExplainStmt:
+ EXPLAIN opt_verbose OptimizableStmt
{
ExplainStmt *n = makeNode(ExplainStmt);
n->verbose = $2;
* *
*****************************************************************************/
-OptimizableStmt: SelectStmt
- | CursorStmt
- | UpdateStmt
- | InsertStmt
- | DeleteStmt /* by default all are $$=$1 */
+OptimizableStmt:
+ SelectStmt
+ | CursorStmt
+ | UpdateStmt
+ | InsertStmt
+ | DeleteStmt /* by default all are $$=$1 */
;
*
*****************************************************************************/
-InsertStmt: INSERT INTO qualified_name insert_rest
+InsertStmt:
+ INSERT INTO qualified_name insert_rest
{
- $4->relation = $3;
+ $4->relation = $3;
$$ = (Node *) $4;
}
;
-insert_rest: VALUES '(' insert_target_list ')'
+insert_rest:
+ VALUES '(' insert_target_list ')'
{
$$ = makeNode(InsertStmt);
$$->cols = NIL;
$$->targetList = $3;
$$->selectStmt = NULL;
}
- | DEFAULT VALUES
+ | DEFAULT VALUES
{
$$ = makeNode(InsertStmt);
$$->cols = NIL;
$$->targetList = NIL;
$$->selectStmt = NULL;
}
- | SelectStmt
+ | SelectStmt
{
$$ = makeNode(InsertStmt);
$$->cols = NIL;
$$->targetList = NIL;
$$->selectStmt = $1;
}
- | '(' insert_column_list ')' VALUES '(' insert_target_list ')'
+ | '(' insert_column_list ')' VALUES '(' insert_target_list ')'
{
$$ = makeNode(InsertStmt);
$$->cols = $2;
$$->targetList = $6;
$$->selectStmt = NULL;
}
- | '(' insert_column_list ')' SelectStmt
+ | '(' insert_column_list ')' SelectStmt
{
$$ = makeNode(InsertStmt);
$$->cols = $2;
}
;
-insert_column_list: insert_column_list ',' insert_column_item
- { $$ = lappend($1, $3); }
- | insert_column_item
- { $$ = makeList1($1); }
+insert_column_list:
+ insert_column_list ',' insert_column_item { $$ = lappend($1, $3); }
+ | insert_column_item { $$ = makeList1($1); }
;
-insert_column_item: ColId opt_indirection
+insert_column_item:
+ ColId opt_indirection
{
ResTarget *n = makeNode(ResTarget);
n->name = $1;
*
*****************************************************************************/
-DeleteStmt: DELETE_P FROM relation_expr where_clause
+DeleteStmt: DELETE_P FROM relation_expr where_clause
{
DeleteStmt *n = makeNode(DeleteStmt);
n->relation = $3;
}
;
-opt_lock: IN_P lock_type MODE { $$ = $2; }
- | /*EMPTY*/ { $$ = AccessExclusiveLock; }
+opt_lock: IN_P lock_type MODE { $$ = $2; }
+ | /*EMPTY*/ { $$ = AccessExclusiveLock; }
;
-lock_type: ACCESS SHARE { $$ = AccessShareLock; }
- | ROW SHARE { $$ = RowShareLock; }
projects / users / hanada / postgres.git / commitdiff