*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.329 2002/06/18 17:27:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.330 2002/06/18 17:56:41 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
}
%type <node> stmt, schema_stmt,
- AlterDatabaseSetStmt, AlterGroupStmt, AlterSchemaStmt, AlterTableStmt,
- AlterUserStmt, AlterUserSetStmt, AnalyzeStmt,
- ClosePortalStmt, ClusterStmt, CommentStmt, ConstraintsSetStmt,
- CopyStmt, CreateAsStmt, CreateDomainStmt, CreateGroupStmt, CreatePLangStmt,
- CreateSchemaStmt, CreateSeqStmt, CreateStmt, CreateAssertStmt, CreateTrigStmt,
- CreateUserStmt, CreatedbStmt, CursorStmt, DefineStmt, DeleteStmt,
- DropGroupStmt, DropPLangStmt, DropSchemaStmt, DropStmt, DropAssertStmt, DropTrigStmt,
- DropRuleStmt, DropUserStmt, DropdbStmt, ExplainStmt, FetchStmt,
- GrantStmt, IndexStmt, InsertStmt, ListenStmt, LoadStmt, LockStmt,
- NotifyStmt, OptimizableStmt, CreateFunctionStmt, ReindexStmt,
- RemoveAggrStmt, RemoveFuncStmt, RemoveOperStmt,
- RenameStmt, RevokeStmt, RuleActionStmt, RuleActionStmtOrEmpty,
- RuleStmt, SelectStmt, TransactionStmt, TruncateStmt,
- UnlistenStmt, UpdateStmt, VacuumStmt, VariableResetStmt,
- VariableSetStmt, VariableShowStmt, ViewStmt, CheckPointStmt
+ AlterDatabaseSetStmt, AlterGroupStmt, AlterSchemaStmt,
+ AlterTableStmt, AlterUserStmt, AlterUserSetStmt,
+ AnalyzeStmt, ClosePortalStmt, ClusterStmt, CommentStmt,
+ ConstraintsSetStmt, CopyStmt, CreateAsStmt,
+ CreateDomainStmt, CreateGroupStmt, CreatePLangStmt,
+ CreateSchemaStmt, CreateSeqStmt, CreateStmt,
+ CreateAssertStmt, CreateTrigStmt, CreateUserStmt,
+ CreatedbStmt, CursorStmt, DefineStmt, DeleteStmt,
+ DropGroupStmt, DropPLangStmt, DropSchemaStmt, DropStmt,
+ DropAssertStmt, DropTrigStmt, DropRuleStmt,
+ DropUserStmt, DropdbStmt, ExplainStmt, FetchStmt,
+ GrantStmt, IndexStmt, InsertStmt, ListenStmt, LoadStmt,
+ LockStmt, NotifyStmt, OptimizableStmt,
+ CreateFunctionStmt, ReindexStmt, RemoveAggrStmt,
+ RemoveFuncStmt, RemoveOperStmt, RenameStmt, RevokeStmt,
+ RuleActionStmt, RuleActionStmtOrEmpty, RuleStmt,
+ SelectStmt, TransactionStmt, TruncateStmt,
+ UnlistenStmt, UpdateStmt, VacuumStmt,
+ VariableResetStmt, VariableSetStmt, VariableShowStmt,
+ ViewStmt, CheckPointStmt
%type <node> select_no_parens, select_with_parens, select_clause,
simple_select
/* ordinary key words in alphabetical order */
%token <keyword> ABORT_TRANS, ABSOLUTE, ACCESS, ACTION, ADD, AFTER,
- AGGREGATE, ALL, ALTER, ANALYSE, ANALYZE, AND, ANY, AS, ASC, ASSERTION,
- AT, AUTHORIZATION,
+ AGGREGATE, ALL, ALTER, ANALYSE, ANALYZE, AND, ANY, AS, ASC,
+ ASSERTION, AT, AUTHORIZATION,
BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
BOOLEAN, BY,
- CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR_P, CHARACTER,
- CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE, CLUSTER, COALESCE, COLLATE,
- COLUMN, COMMENT, COMMIT, COMMITTED, CONSTRAINT, CONSTRAINTS, COPY,
- CREATE, CREATEDB, CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
+ CACHE, CALLED, CASCADE, CASE, CAST, CHAIN, CHAR_P,
+ CHARACTER, CHARACTERISTICS, CHECK, CHECKPOINT, CLOSE,
+ CLUSTER, COALESCE, COLLATE, COLUMN, COMMENT, COMMIT,
+ COMMITTED, CONSTRAINT, CONSTRAINTS, COPY, CREATE, CREATEDB,
+ CREATEUSER, CROSS, CURRENT_DATE, CURRENT_TIME,
CURRENT_TIMESTAMP, CURRENT_USER, CURSOR, CYCLE,
- DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT, DEFERRABLE, DEFERRED,
- DEFINER, DELETE_P, DELIMITERS, DESC, DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
+ DATABASE, DAY_P, DEC, DECIMAL, DECLARE, DEFAULT,
+ DEFERRABLE, DEFERRED, DEFINER, DELETE_P, DELIMITERS, DESC,
+ DISTINCT, DO, DOMAIN_P, DOUBLE, DROP,
- EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT, EXCLUSIVE,
- EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
+ EACH, ELSE, ENCODING, ENCRYPTED, END_TRANS, ESCAPE, EXCEPT,
+ EXCLUSIVE, EXECUTE, EXISTS, EXPLAIN, EXTERNAL, EXTRACT,
- FALSE_P, FETCH, FLOAT_P, FOR, FORCE, FOREIGN, FORWARD, FREEZE, FROM,
- FULL, FUNCTION,
+ FALSE_P, FETCH, FLOAT_P, FOR, FORCE, FOREIGN, FORWARD,
+ FREEZE, FROM, FULL, FUNCTION,
GET, GLOBAL, GRANT, GROUP_P,
+
HANDLER, HAVING, HOUR_P,
- ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN_P, INCREMENT, INDEX, INHERITS,
- INITIALLY, INNER_P, INOUT, INPUT, INSENSITIVE, INSERT, INSTEAD, INT,
- INTEGER, INTERSECT, INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
+ ILIKE, IMMEDIATE, IMMUTABLE, IMPLICIT, IN_P, INCREMENT,
+ INDEX, INHERITS, INITIALLY, INNER_P, INOUT, INPUT,
+ INSENSITIVE, INSERT, INSTEAD, INT, INTEGER, INTERSECT,
+ INTERVAL, INTO, INVOKER, IS, ISNULL, ISOLATION,
JOIN,
KEY,
- LANCOMPILER, LANGUAGE, LEADING, LEFT, LEVEL, LIKE, LIMIT, LISTEN,
- LOAD, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATION, LOCK_P,
+ LANCOMPILER, LANGUAGE, LEADING, LEFT, LEVEL, LIKE, LIMIT,
+ LISTEN, LOAD, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATION,
+ LOCK_P,
MATCH, MAXVALUE, MINUTE_P, MINVALUE, MODE, MONTH_P, MOVE,
NAMES, NATIONAL, NATURAL, NCHAR, NEW, NEXT, NO, NOCREATEDB,
- NOCREATEUSER, NONE, NOT, NOTHING, NOTIFY, NOTNULL, NULL_P, NULLIF,
- NUMERIC,
+ NOCREATEUSER, NONE, NOT, NOTHING, NOTIFY, NOTNULL, NULL_P,
+ NULLIF, NUMERIC,
+
+ OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR,
+ ORDER, OUT_P, OUTER_P, OVERLAPS, OVERLAY, OWNER,
- OF, OFF, OFFSET, OIDS, OLD, ON, ONLY, OPERATOR, OPTION, OR, ORDER,
- OUT_P, OUTER_P, OVERLAPS, OVERLAY, OWNER,
+ PARTIAL, PASSWORD, PATH_P, PENDANT, PLACING, POSITION,
+ PRECISION, PRIMARY, PRIOR, PRIVILEGES, PROCEDURE,
+ PROCEDURAL,
- PARTIAL, PASSWORD, PATH_P, PENDANT, PLACING, POSITION, PRECISION, PRIMARY,
- PRIOR, PRIVILEGES, PROCEDURE, PROCEDURAL,
+ READ, REAL, REFERENCES, REINDEX, RELATIVE, RENAME, REPLACE,
+ RESET, RESTRICT, RETURNS, REVOKE, RIGHT, ROLLBACK, ROW,
+ RULE,
- READ, REAL, REFERENCES, REINDEX, RELATIVE, RENAME, REPLACE, RESET,
- RESTRICT, RETURNS, REVOKE, RIGHT, ROLLBACK, ROW, RULE,
+ SCHEMA, SCROLL, SECOND_P, SECURITY, SELECT, SEQUENCE,
+ SERIALIZABLE, SESSION, SESSION_USER, SET, SETOF, SHARE,
+ SHOW, SIMILAR, SMALLINT, SOME, STABLE, START, STATEMENT,
+ STATISTICS, STDIN, STDOUT, STORAGE, STRICT, SUBSTRING,
+ SYSID,
- SCHEMA, SCROLL, SECOND_P, SECURITY, SELECT, SEQUENCE, SERIALIZABLE,
- SESSION, SESSION_USER, SET, SETOF, SHARE, SHOW, SIMILAR, SMALLINT, SOME,
- STABLE, START, STATEMENT, STATISTICS, STDIN, STDOUT, STORAGE, STRICT,
- SUBSTRING, SYSID,
+ TABLE, TEMP, TEMPLATE, TEMPORARY, THEN, TIME, TIMESTAMP,
+ TO, TOAST, TRAILING, TRANSACTION, TRIGGER, TRIM, TRUE_P,
+ TRUNCATE, TRUSTED, TYPE_P,
- TABLE, TEMP, TEMPLATE, TEMPORARY, THEN, TIME, TIMESTAMP, TO, TOAST,
- TRAILING, TRANSACTION, TRIGGER, TRIM, TRUE_P, TRUNCATE, TRUSTED, TYPE_P,
+ UNENCRYPTED, UNION, UNIQUE, UNKNOWN, UNLISTEN, UNTIL,
+ UPDATE, USAGE, USER, USING,
- UNENCRYPTED, UNION, UNIQUE, UNKNOWN, UNLISTEN, UNTIL, UPDATE, USAGE,
- USER, USING,
+ VACUUM, VALID, VALIDATOR, VALUES, VARCHAR, VARYING,
+ VERBOSE, VERSION, VIEW, VOLATILE,
- VACUUM, VALID, VALIDATOR, VALUES, VARCHAR, VARYING, VERBOSE, VERSION, VIEW, VOLATILE,
WHEN, WHERE, WITH, WITHOUT, WORK,
+
YEAR_P,
+
ZONE
/* The grammar thinks these are keywords, but they are not in the keywords.c
%left Op OPERATOR /* multi-character ops and user-defined operators */
%nonassoc NOTNULL
%nonassoc ISNULL
-%nonassoc IS NULL_P TRUE_P FALSE_P UNKNOWN /* sets precedence for IS NULL, etc */
+%nonassoc IS NULL_P TRUE_P FALSE_P UNKNOWN /* sets precedence for IS NULL, etc */
%left '+' '-'
%left '*' '/' '%'
%left '^'
CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
- /* One can omit the schema name or the authorization id... */
+ /* One can omit the schema name or the authorization id. */
if ($3 != NULL)
n->schemaname = $3;
else
{
if (($3 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
elog(ERROR,
- "Time zone interval must be HOUR or HOUR TO MINUTE");
+ "Time zone interval must be HOUR or HOUR TO MINUTE");
n->typename->typmod = ((($3 & 0x7FFF) << 16) | 0xFFFF);
}
$$ = (Node *)n;
{
if (($6 & ~(MASK(HOUR) | MASK(MINUTE))) != 0)
elog(ERROR,
- "Time zone interval must be HOUR or HOUR TO MINUTE");
+ "Time zone interval must be HOUR or HOUR TO MINUTE");
n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
}
else
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
+ /* 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->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
+ /* 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->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>
+ * 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->def = (Node *) makeString($9);
$$ = (Node *)n;
}
- /* ALTER TABLE <relation> DROP [COLUMN] <colname> {RESTRICT|CASCADE} */
+ /* ALTER TABLE <relation> DROP [COLUMN] <colname>
+ * {RESTRICT|CASCADE}
+ */
| ALTER TABLE relation_expr DROP opt_column ColId drop_behavior
{
AlterTableStmt *n = makeNode(AlterTableStmt);
n->def = $5;
$$ = (Node *)n;
}
- /* ALTER TABLE <relation> DROP CONSTRAINT <name> {RESTRICT|CASCADE} */
+ /* ALTER TABLE <relation> DROP CONSTRAINT <name>
+ * {RESTRICT|CASCADE}
+ */
| ALTER TABLE relation_expr DROP CONSTRAINT name drop_behavior
{
AlterTableStmt *n = makeNode(AlterTableStmt);
*
*****************************************************************************/
-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;
| LOCAL TEMP { $$ = TRUE; }
| GLOBAL TEMPORARY
{
- elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
+ elog(ERROR,
+ "GLOBAL TEMPORARY TABLE is not currently supported");
$$ = TRUE;
}
| GLOBAL TEMP
{
- elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
+ elog(ERROR,
+ "GLOBAL TEMPORARY TABLE is not currently supported");
$$ = TRUE;
}
| /*EMPTY*/ { $$ = FALSE; }
n->constraints = $3;
if ($4 != NULL)
- elog(NOTICE, "CREATE TABLE / COLLATE %s not yet implemented"
- "; clause ignored", $4);
+ elog(NOTICE,
+ "CREATE TABLE / COLLATE %s not yet implemented; "
+ "clause ignored", $4);
$$ = (Node *)n;
}
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);
| /*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; }
+ 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; }
* Work around by using name and dotted_name separately.
*/
handler_name:
- name { $$ = makeList1(makeString($1)); }
+ name
+ { $$ = makeList1(makeString($1)); }
| dotted_name { $$ = $1; }
;
| ConstraintDeferrabilitySpec ConstraintTimeSpec
{
if ($1 == 0 && $2 != 0)
- elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
+ elog(ERROR,
+ "INITIALLY DEFERRED constraint must be DEFERRABLE");
$$ = $1 | $2;
}
| ConstraintTimeSpec
| ConstraintTimeSpec ConstraintDeferrabilitySpec
{
if ($2 == 0 && $1 != 0)
- elog(ERROR, "INITIALLY DEFERRED constraint must be DEFERRABLE");
+ elog(ERROR,
+ "INITIALLY DEFERRED constraint must be DEFERRABLE");
$$ = $1 | $2;
}
| /*EMPTY*/
*****************************************************************************/
CreateAssertStmt:
- CREATE ASSERTION name CHECK '(' a_expr ')' ConstraintAttributeSpec
+ CREATE ASSERTION name CHECK '(' a_expr ')'
+ ConstraintAttributeSpec
{
CreateTrigStmt *n = makeNode(CreateTrigStmt);
n->trigname = $3;
;
/* 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); }
;
| 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; }
;
/*****************************************************************************
n->comment = $6;
$$ = (Node *) n;
}
- | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')' IS comment_text
+ | COMMENT ON AGGREGATE func_name '(' aggr_argtype ')'
+ IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
n->objtype = AGGREGATE;
n->comment = $7;
$$ = (Node *) n;
}
- | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')' IS comment_text
+ | COMMENT ON OPERATOR any_operator '(' oper_argtypes ')'
+ IS comment_text
{
CommentStmt *n = makeNode(CommentStmt);
n->objtype = OPERATOR;
if ($2 == RELATIVE)
{
if ($3 == 0)
- elog(ERROR,"FETCH / RELATIVE at current position is not supported");
+ elog(ERROR,
+ "FETCH / RELATIVE at current position is not supported");
$2 = FORWARD;
}
if ($3 < 0)
| RELATIVE { $$ = RELATIVE; }
| ABSOLUTE
{
- elog(NOTICE,"FETCH / ABSOLUTE not supported, using RELATIVE");
+ elog(NOTICE,
+ "FETCH / ABSOLUTE not supported, using RELATIVE");
$$ = RELATIVE;
}
;
fetch_how_many:
Iconst { $$ = $1; }
| '-' Iconst { $$ = - $2; }
- | ALL { $$ = 0; /* 0 means fetch all tuples*/ }
+ /* 0 means fetch all tuples*/
+ | ALL { $$ = 0; }
| NEXT { $$ = 1; }
| PRIOR { $$ = -1; }
;
*
*****************************************************************************/
-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:
grantee: ColId
{
PrivGrantee *n = makeNode(PrivGrantee);
- /* This hack lets us avoid reserving PUBLIC as a keyword */
+ /* This hack lets us avoid reserving PUBLIC as a keyword*/
if (strcmp($1, "public") == 0)
n->username = NULL;
else
opt_arg: IN_P { $$ = FALSE; }
| OUT_P
{
- elog(ERROR, "CREATE FUNCTION / OUT parameters are not supported");
+ elog(ERROR,
+ "CREATE FUNCTION / OUT parameters are not supported");
$$ = TRUE;
}
| INOUT
{
- elog(ERROR, "CREATE FUNCTION / INOUT parameters are not supported");
+ elog(ERROR,
+ "CREATE FUNCTION / INOUT parameters are not supported");
$$ = FALSE;
}
;
}
;
-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:
{
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); }
+ all_Op
+ { $$ = makeList1(makeString($1)); }
+ | ColId '.' any_operator
+ { $$ = lcons(makeString($1), $3); }
;
insert_column_list:
insert_column_item { $$ = makeList1($1); }
- | insert_column_list ',' insert_column_item { $$ = lappend($1, $3); }
+ | insert_column_list ',' insert_column_item
+ { $$ = lappend($1, $3); }
;
insert_column_item:
}
;
-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; }
- | ROW EXCLUSIVE { $$ = RowExclusiveLock; }
- | SHARE UPDATE EXCLUSIVE { $$ = ShareUpdateExclusiveLock; }
- | SHARE { $$ = ShareLock; }
- | SHARE ROW EXCLUSIVE { $$ = ShareRowExclusiveLock; }
- | EXCLUSIVE { $$ = ExclusiveLock; }
- | ACCESS EXCLUSIVE { $$ = AccessExclusiveLock; }
+lock_type: ACCESS SHARE { $$ = AccessShareLock; }
+ | ROW SHARE { $$ = RowShareLock; }
+ | ROW EXCLUSIVE { $$ = RowExclusiveLock; }
+ | SHARE UPDATE EXCLUSIVE { $$ = ShareUpdateExclusiveLock; }
+ | SHARE { $$ = ShareLock; }
+ | SHARE ROW EXCLUSIVE { $$ = ShareRowExclusiveLock; }
+ | EXCLUSIVE { $$ = ExclusiveLock; }
+ | ACCESS EXCLUSIVE { $$ = AccessExclusiveLock; }
;
}
| GLOBAL TEMPORARY opt_table qualified_name
{
- elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
+ elog(ERROR,
+ "GLOBAL TEMPORARY TABLE is not currently supported");
$$ = $4;
$$->istemp = true;
}
| GLOBAL TEMP opt_table qualified_name
{
- elog(ERROR, "GLOBAL TEMPORARY TABLE is not currently supported");
+ elog(ERROR,
+ "GLOBAL TEMPORARY TABLE is not currently supported");
$$ = $4;
$$->istemp = true;
}
{ $$ = makeList2($2, NULL); }
| LIMIT select_limit_value ',' select_offset_value
/* Disabled because it was too confusing, bjm 2002-02-18 */
- { elog(ERROR, "LIMIT #,# syntax not supported.\n\tUse separate LIMIT and OFFSET clauses."); }
+ { elog(ERROR,
+ "LIMIT #,# syntax not supported.\n\tUse separate LIMIT and OFFSET clauses."); }
;
opt_select_limit:
select_limit { $$ = $1; }
- | /* EMPTY */ { $$ = makeList2(NULL,NULL); }
+ | /* EMPTY */
+ { $$ = makeList2(NULL,NULL); }
;
select_limit_value:
where_clause:
WHERE a_expr { $$ = $2; }
- | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ /* no qualifiers */
+ | /*EMPTY*/ { $$ = NULL; }
;
{
$$ = $1;
if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
- elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "INTERVAL(%d) precision must be between %d and %d",
$3, 0, MAX_INTERVAL_PRECISION);
$$->typmod = ((($5 & 0x7FFF) << 16) | $3);
}
opt_float: '(' Iconst ')'
{
if ($2 < 1)
- elog(ERROR, "precision for FLOAT must be at least 1");
+ elog(ERROR,
+ "precision for FLOAT must be at least 1");
else if ($2 < 7)
$$ = SystemTypeName("float4");
else if ($2 < 16)
$$ = SystemTypeName("float8");
else
- elog(ERROR, "precision for FLOAT must be less than 16");
+ elog(ERROR,
+ "precision for FLOAT must be less than 16");
}
| /*EMPTY*/
{
'(' Iconst ',' Iconst ')'
{
if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
- elog(ERROR, "NUMERIC precision %d must be between 1 and %d",
+ elog(ERROR,
+ "NUMERIC precision %d must be between 1 and %d",
$2, NUMERIC_MAX_PRECISION);
if ($4 < 0 || $4 > $2)
- elog(ERROR, "NUMERIC scale %d must be between 0 and precision %d",
+ elog(ERROR,
+ "NUMERIC scale %d must be between 0 and precision %d",
$4,$2);
$$ = (($2 << 16) | $4) + VARHDRSZ;
| '(' Iconst ')'
{
if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
- elog(ERROR, "NUMERIC precision %d must be between 1 and %d",
+ elog(ERROR,
+ "NUMERIC precision %d must be between 1 and %d",
$2, NUMERIC_MAX_PRECISION);
$$ = ($2 << 16) + VARHDRSZ;
'(' Iconst ',' Iconst ')'
{
if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
- elog(ERROR, "DECIMAL precision %d must be between 1 and %d",
+ elog(ERROR,
+ "DECIMAL precision %d must be between 1 and %d",
$2, NUMERIC_MAX_PRECISION);
if ($4 < 0 || $4 > $2)
- elog(ERROR, "DECIMAL scale %d must be between 0 and precision %d",
+ elog(ERROR,
+ "DECIMAL scale %d must be between 0 and precision %d",
$4,$2);
$$ = (($2 << 16) | $4) + VARHDRSZ;
| '(' Iconst ')'
{
if ($2 < 1 || $2 > NUMERIC_MAX_PRECISION)
- elog(ERROR, "DECIMAL precision %d must be between 1 and %d",
+ elog(ERROR,
+ "DECIMAL precision %d must be between 1 and %d",
$2, NUMERIC_MAX_PRECISION);
$$ = ($2 << 16) + VARHDRSZ;
*/
$$->timezone = $5;
if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
- elog(ERROR, "TIMESTAMP(%d)%s precision must be between %d and %d",
- $3, ($5 ? " WITH TIME ZONE": ""), 0, MAX_TIMESTAMP_PRECISION);
+ elog(ERROR,
+ "TIMESTAMP(%d)%s precision must be between %d and %d",
+ $3, ($5 ? " WITH TIME ZONE": ""), 0,
+ MAX_TIMESTAMP_PRECISION);
$$->typmod = $3;
}
| TIMESTAMP opt_timezone
else
$$ = SystemTypeName("time");
if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
- elog(ERROR, "TIME(%d)%s precision must be between %d and %d",
- $3, ($5 ? " WITH TIME ZONE": ""), 0, MAX_TIME_PRECISION);
+ elog(ERROR,
+ "TIME(%d)%s precision must be between %d and %d",
+ $3, ($5 ? " WITH TIME ZONE": ""), 0,
+ MAX_TIME_PRECISION);
$$->typmod = $3;
}
| TIME opt_timezone
| HOUR_P { $$ = MASK(HOUR); }
| MINUTE_P { $$ = MASK(MINUTE); }
| SECOND_P { $$ = MASK(SECOND); }
- | YEAR_P TO MONTH_P { $$ = MASK(YEAR) | MASK(MONTH); }
- | DAY_P TO HOUR_P { $$ = MASK(DAY) | MASK(HOUR); }
- | DAY_P TO MINUTE_P { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE); }
- | DAY_P TO SECOND_P { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
- | HOUR_P TO MINUTE_P { $$ = MASK(HOUR) | MASK(MINUTE); }
- | HOUR_P TO SECOND_P { $$ = MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
- | MINUTE_P TO SECOND_P { $$ = MASK(MINUTE) | MASK(SECOND); }
+ | YEAR_P TO MONTH_P
+ { $$ = MASK(YEAR) | MASK(MONTH); }
+ | DAY_P TO HOUR_P
+ { $$ = MASK(DAY) | MASK(HOUR); }
+ | DAY_P TO MINUTE_P
+ { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE); }
+ | DAY_P TO SECOND_P
+ { $$ = MASK(DAY) | MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
+ | HOUR_P TO MINUTE_P
+ { $$ = MASK(HOUR) | MASK(MINUTE); }
+ | HOUR_P TO SECOND_P
+ { $$ = MASK(HOUR) | MASK(MINUTE) | MASK(SECOND); }
+ | MINUTE_P TO SECOND_P
+ { $$ = MASK(MINUTE) | MASK(SECOND); }
| /*EMPTY*/ { $$ = -1; }
;
n->subselect = $6;
$$ = (Node *)n;
}
- | '(' row_descriptor ')' qual_all_Op sub_type select_with_parens %prec Op
+ | '(' row_descriptor ')' qual_all_Op sub_type select_with_parens
+ %prec Op
{
SubLink *n = makeNode(SubLink);
n->lefthand = $2;
n->subselect = $6;
$$ = (Node *)n;
}
- | '(' row_descriptor ')' qual_all_Op select_with_parens %prec Op
+ | '(' row_descriptor ')' qual_all_Op select_with_parens
+ %prec Op
{
SubLink *n = makeNode(SubLink);
n->lefthand = $2;
n->subselect = $5;
$$ = (Node *)n;
}
- | '(' row_descriptor ')' qual_all_Op '(' row_descriptor ')' %prec Op
+ | '(' row_descriptor ')' qual_all_Op '(' row_descriptor ')'
+ %prec Op
{
$$ = makeRowExpr($4, $2, $6);
}
| '=' { $$ = "="; }
;
-qual_Op: Op { $$ = makeList1(makeString($1)); }
+qual_Op: Op
+ { $$ = makeList1(makeString($1)); }
| OPERATOR '(' any_operator ')' { $$ = $3; }
;
qual_all_Op:
- all_Op { $$ = makeList1(makeString($1)); }
+ all_Op
+ { $$ = makeList1(makeString($1)); }
| OPERATOR '(' any_operator ')' { $$ = $3; }
;
* it's factored out just to eliminate redundant coding.
*/
a_expr: c_expr { $$ = $1; }
- | a_expr TYPECAST Typename { $$ = makeTypeCast($1, $3); }
+ | a_expr TYPECAST Typename
+ { $$ = makeTypeCast($1, $3); }
| a_expr COLLATE ColId
{
FuncCall *n = makeNode(FuncCall);
$$ = n;
}
}
- | a_expr qual_all_Op sub_type select_with_parens %prec Op
+ | a_expr qual_all_Op sub_type select_with_parens %prec Op
{
SubLink *n = makeNode(SubLink);
n->lefthand = makeList1($1);
s->typename = SystemTypeName("text");
d = SystemTypeName("timetz");
if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
- elog(ERROR, "CURRENT_TIME(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "CURRENT_TIME(%d) precision must be between %d and %d",
$3, 0, MAX_TIME_PRECISION);
d->typmod = $3;
d = SystemTypeName("timestamptz");
if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
- elog(ERROR, "CURRENT_TIMESTAMP(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "CURRENT_TIMESTAMP(%d) precision "
+ "must be between %d and %d",
$3, 0, MAX_TIMESTAMP_PRECISION);
d->typmod = $3;
s->typename = SystemTypeName("text");
d = SystemTypeName("time");
if (($3 < 0) || ($3 > MAX_TIME_PRECISION))
- elog(ERROR, "LOCALTIME(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "LOCALTIME(%d) precision must be between %d and %d",
$3, 0, MAX_TIME_PRECISION);
d->typmod = $3;
d = SystemTypeName("timestamp");
if (($3 < 0) || ($3 > MAX_TIMESTAMP_PRECISION))
- elog(ERROR, "LOCALTIMESTAMP(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "LOCALTIMESTAMP(%d) precision must be "
+ "between %d and %d",
$3, 0, MAX_TIMESTAMP_PRECISION);
d->typmod = $3;
;
dotted_name:
- relation_name attrs { $$ = lcons(makeString($1), $2); }
+ relation_name attrs
+ { $$ = lcons(makeString($1), $2); }
;
-attrs: '.' attr_name { $$ = makeList1(makeString($2)); }
- | '.' '*' { $$ = makeList1(makeString("*")); }
- | '.' attr_name attrs { $$ = lcons(makeString($2), $3); }
+attrs: '.' attr_name
+ { $$ = makeList1(makeString($2)); }
+ | '.' '*'
+ { $$ = makeList1(makeString("*")); }
+ | '.' attr_name attrs
+ { $$ = lcons(makeString($2), $3); }
;
$$->relname = strVal(lfirst(lnext(lnext($1))));
break;
default:
- elog(ERROR, "Improper qualified name (too many dotted names): %s",
+ elog(ERROR,
+ "Improper qualified name "
+ "(too many dotted names): %s",
NameListToString($1));
break;
}
}
;
-name_list: name { $$ = makeList1(makeString($1)); }
- | name_list ',' name { $$ = lappend($1, makeString($3)); }
+name_list: name
+ { $$ = makeList1(makeString($1)); }
+ | name_list ',' name
+ { $$ = lappend($1, makeString($3)); }
;
file_name: Sconst { $$ = $1; };
-func_name: function_name { $$ = makeList1(makeString($1)); }
+func_name: function_name
+ { $$ = makeList1(makeString($1)); }
| dotted_name { $$ = $1; }
;
n->val.val.str = $5;
/* precision specified, and fields may be... */
if (($3 < 0) || ($3 > MAX_INTERVAL_PRECISION))
- elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
+ elog(ERROR,
+ "INTERVAL(%d) precision must be between %d and %d",
$3, 0, MAX_INTERVAL_PRECISION);
n->typename->typmod = ((($6 & 0x7FFF) << 16) | $3);
$$ = (Node *)n;
projects / postgresql / commitdiff