BNF for SQL Grammar

Main Entry Points
Reserved Keywords
Non-Reserved Keywords
Reserved Keywords For Future Use
Tokens
Production Cross-Reference
Productions

Reserved Keywords

Keyword	Usage
ADD	add set option
ALL	standard aggregate function, function, query expression body, query term select clause, quantified comparison predicate
ALTER	alter, alter column options, alter options
AND	between predicate, boolean term
ANY	standard aggregate function, quantified comparison predicate
ARRAY_AGG	ordered aggreate function
AS	alter, array table, create procedure, option namespace create table, create trigger, derived column, dynamic data statement function, loop statement, xml namespace element, object table select derived column, table subquery, text table, table name unescapedFunction, with list element, xml serialize, xml table
ASC	sort specification
ATOMIC	compound statement, for each row trigger action
BEGIN	compound statement, for each row trigger action
BETWEEN	between predicate
BIGDECIMAL	simple data type
BIGINT	simple data type
BIGINTEGER	simple data type
BLOB	simple data type, xml serialize
BOOLEAN	simple data type
BOTH	function
BREAK	branching statement
BY	group by clause, order by clause, window specification
BYTE	simple data type
CALL	callable statement, call statement
CASE	case expression, searched case expression
CAST	function
CHAR	function, simple data type
CLOB	simple data type, xml serialize
COLUMN	alter column options
COMMIT	create temporary table
CONSTRAINT	create table body
CONTINUE	branching statement
CONVERT	function
CREATE	create procedure, create foreign temp table, create table, create temporary table create trigger, procedure body definition
CROSS	cross join
DATE	non numeric literal, simple data type
DAY	function
DECIMAL	simple data type
DECLARE	declare statement
DEFAULT	table element, xml namespace element, object table column, procedure parameter xml table column
DELETE	alter, create trigger, delete statement
DESC	sort specification
DISTINCT	standard aggregate function, function, if statement, query expression body query term, select clause
DOUBLE	simple data type
DROP	drop option, drop table
EACH	for each row trigger action
ELSE	case expression, if statement, searched case expression
END	case expression, compound statement, for each row trigger action, searched case expression
ERROR	raise error statement
ESCAPE	match predicate, text table
EXCEPT	query expression body
EXEC	dynamic data statement, call statement
EXECUTE	dynamic data statement, call statement
EXISTS	exists predicate
FALSE	non numeric literal
FETCH	fetch clause
FILTER	filter clause
FLOAT	simple data type
FOR	for each row trigger action, function, text aggreate function, text table column xml table column
FOREIGN	alter options, create procedure, create foreign temp table, create table foreign key
FROM	delete statement, from clause, function, if statement
FULL	qualified table
FUNCTION	create procedure
GEOMETRY	simple data type
GLOBAL	create table
GROUP	group by clause
HAVING	having clause
HOUR	function
IF	if statement
IMMEDIATE	dynamic data statement
IN	procedure parameter, in predicate
INNER	qualified table
INOUT	procedure parameter
INSERT	alter, create trigger, function, insert statement
INTEGER	simple data type
INTERSECT	query term
INTO	dynamic data statement, insert statement, into clause
IS	if statement, is null predicate
JOIN	cross join, make dep options, qualified table
LANGUAGE	object table
LATERAL	table subquery
LEADING	function
LEAVE	branching statement
LEFT	function, qualified table
LIKE	match predicate
LIKE_REGEX	like regex predicate
LIMIT	limit clause
LOCAL	create foreign temp table, create temporary table
LONG	simple data type
LOOP	loop statement
MAKEDEP	option clause, table primary
MAKEIND	option clause, table primary
MAKENOTDEP	option clause, table primary
MERGE	insert statement
MINUTE	function
MONTH	function
NO	make dep options, xml namespace element, text table column, text table
NOCACHE	option clause
NOT	between predicate, compound statement, table element, if statement is null predicate, match predicate, boolean factor, procedure parameter procedure result column, like regex predicate, in predicate, temporary table element
NULL	table element, is null predicate, non numeric literal, procedure parameter procedure result column, temporary table element, xml query
OBJECT	simple data type
OF	alter, create trigger
OFFSET	limit clause
ON	alter, create foreign temp table, create temporary table, create trigger loop statement, qualified table, xml query
ONLY	fetch clause
OPTION	option clause
OPTIONS	alter options list, options clause
OR	boolean value expression
ORDER	order by clause
OUT	procedure parameter
OUTER	qualified table
OVER	window specification
PARAMETER	alter column options
PARTITION	window specification
PRIMARY	table element, create temporary table, primary key
PROCEDURE	alter, alter options, create procedure, procedure body definition
REAL	simple data type
REFERENCES	foreign key
RETURN	assignment statement, return statement, data statement
RETURNS	create procedure
RIGHT	function, qualified table
ROLLUP	group by clause
ROW	fetch clause, for each row trigger action, limit clause, text table
ROWS	create temporary table, fetch clause, limit clause
SECOND	function
SELECT	select clause
SET	add set option, option namespace, update statement
SHORT	simple data type
SIMILAR	match predicate
SMALLINT	simple data type
SOME	standard aggregate function, quantified comparison predicate
SQLEXCEPTION	sql exception
SQLSTATE	sql exception
SQLWARNING	raise statement
STRING	dynamic data statement, simple data type, xml serialize
TABLE	alter options, create procedure, create foreign temp table, create table create temporary table, drop table, query primary, table subquery
TEMPORARY	create foreign temp table, create table, create temporary table
THEN	case expression, searched case expression
TIME	non numeric literal, simple data type
TIMESTAMP	non numeric literal, simple data type
TINYINT	simple data type
TO	match predicate
TRAILING	function
TRANSLATE	function
TRIGGER	alter, create trigger
TRUE	non numeric literal
UNION	cross join, query expression body
UNIQUE	other constraints, table element
UNKNOWN	non numeric literal
UPDATE	alter, create trigger, dynamic data statement, update statement
USER	function
USING	dynamic data statement
VALUES	query primary
VARBINARY	simple data type, xml serialize
VARCHAR	simple data type, xml serialize
VIRTUAL	alter options, create procedure, create table, procedure body definition
WHEN	case expression, searched case expression
WHERE	filter clause, where clause
WHILE	while statement
WITH	assignment statement, query expression, data statement
WITHOUT	assignment statement, data statement
XML	simple data type
XMLAGG	ordered aggreate function
XMLATTRIBUTES	xml attributes
XMLCAST	unescapedFunction
XMLCOMMENT	function
XMLCONCAT	function
XMLELEMENT	xml element
XMLEXISTS	xml query
XMLFOREST	xml forest
XMLNAMESPACES	xml namespaces
XMLPARSE	xml parse
XMLPI	function
XMLQUERY	xml query
XMLSERIALIZE	xml serialize
XMLTABLE	xml table
XMLTEXT	function
YEAR	function

Non-Reserved Keywords

Keyword	Usage
ACCESSPATTERN	other constraints, non-reserved identifier
ARRAYTABLE	array table, non-reserved identifier
AUTO_INCREMENT	table element, non-reserved identifier
AVG	standard aggregate function, non-reserved identifier
CHAIN	sql exception, non-reserved identifier
COLUMNS	array table, non-reserved identifier, object table, text table xml table
CONTENT	non-reserved identifier, xml parse, xml serialize
COUNT	standard aggregate function, non-reserved identifier
DELIMITER	non-reserved identifier, text aggreate function, text table
DENSE_RANK	analytic aggregate function, non-reserved identifier
DISABLED	alter, non-reserved identifier
DOCUMENT	non-reserved identifier, xml parse, xml serialize
EMPTY	non-reserved identifier, xml query
ENABLED	alter, non-reserved identifier
ENCODING	non-reserved identifier, text aggreate function, xml serialize
EVERY	standard aggregate function, non-reserved identifier
EXCEPTION	compound statement, declare statement, non-reserved identifier
EXCLUDING	non-reserved identifier, xml serialize
EXTRACT	function, non-reserved identifier
FIRST	fetch clause, non-reserved identifier, sort specification
HEADER	non-reserved identifier, text aggreate function, text table column, text table
INCLUDING	non-reserved identifier, xml serialize
INDEX	other constraints, table element, non-reserved identifier
INSTEAD	alter, create trigger, non-reserved identifier
JSONARRAY_AGG	non-reserved identifier, ordered aggreate function
JSONOBJECT	json object, non-reserved identifier
KEY	table element, create temporary table, foreign key, non-reserved identifier primary key
LAST	non-reserved identifier, sort specification
MAX	standard aggregate function, make dep options, non-reserved identifier
MIN	standard aggregate function, non-reserved identifier
NAME	function, non-reserved identifier, xml element
NAMESPACE	option namespace, non-reserved identifier
NEXT	fetch clause, non-reserved identifier
NULLS	non-reserved identifier, sort specification
OBJECTTABLE	non-reserved identifier, object table
ORDINALITY	non-reserved identifier, text table column, xml table column
PASSING	non-reserved identifier, object table, xml query, xml query xml table
PATH	non-reserved identifier, xml table column
PRESERVE	create temporary table, non-reserved identifier
QUERYSTRING	non-reserved identifier, querystring function
QUOTE	non-reserved identifier, text aggreate function, text table
RAISE	non-reserved identifier, raise statement
RANK	analytic aggregate function, non-reserved identifier
RESULT	non-reserved identifier, procedure parameter
ROW_NUMBER	analytic aggregate function, non-reserved identifier
SELECTOR	non-reserved identifier, text table column, text table
SERIAL	table element, non-reserved identifier, temporary table element
SKIP	non-reserved identifier, text table
SQL_TSI_DAY	time interval, non-reserved identifier
SQL_TSI_FRAC_SECOND	time interval, non-reserved identifier
SQL_TSI_HOUR	time interval, non-reserved identifier
SQL_TSI_MINUTE	time interval, non-reserved identifier
SQL_TSI_MONTH	time interval, non-reserved identifier
SQL_TSI_QUARTER	time interval, non-reserved identifier
SQL_TSI_SECOND	time interval, non-reserved identifier
SQL_TSI_WEEK	time interval, non-reserved identifier
SQL_TSI_YEAR	time interval, non-reserved identifier
STDDEV_POP	standard aggregate function, non-reserved identifier
STDDEV_SAMP	standard aggregate function, non-reserved identifier
SUBSTRING	function, non-reserved identifier
SUM	standard aggregate function, non-reserved identifier
TEXTAGG	non-reserved identifier, text aggreate function
TEXTTABLE	non-reserved identifier, text table
TIMESTAMPADD	function, non-reserved identifier
TIMESTAMPDIFF	function, non-reserved identifier
TO_BYTES	function, non-reserved identifier
TO_CHARS	function, non-reserved identifier
TRIM	function, non-reserved identifier, text table column, text table
VARIADIC	non-reserved identifier, procedure parameter
VAR_POP	standard aggregate function, non-reserved identifier
VAR_SAMP	standard aggregate function, non-reserved identifier
VERSION	non-reserved identifier, xml serialize
VIEW	alter, alter options, create table, non-reserved identifier
WELLFORMED	non-reserved identifier, xml parse
WIDTH	non-reserved identifier, text table column
XMLDECLARATION	non-reserved identifier, xml serialize

Reserved Keywords For Future Use

ALLOCATE	ARE	ARRAY	ASENSITIVE	ASYMETRIC	AUTHORIZATION	BINARY	CALLED
CASCADED	CHARACTER	CHECK	CLOSE	COLLATE	CONNECT	CORRESPONDING	CRITERIA
CURRENT_DATE	CURRENT_TIME	CURRENT_TIMESTAMP	CURRENT_USER	CURSOR	CYCLE	DATALINK	DEALLOCATE
DEC	DEREF	DESCRIBE	DETERMINISTIC	DISCONNECT	DLNEWCOPY	DLPREVIOUSCOPY	DLURLCOMPLETE
DLURLCOMPLETEONLY	DLURLCOMPLETEWRITE	DLURLPATH	DLURLPATHONLY	DLURLPATHWRITE	DLURLSCHEME	DLURLSERVER	DLVALUE
DYNAMIC	ELEMENT	EXTERNAL	FREE	GET	GRANT	HAS	HOLD
IDENTITY	IMPORT	INDICATOR	INPUT	INSENSITIVE	INT	INTERVAL	ISOLATION
LARGE	LOCALTIME	LOCALTIMESTAMP	MATCH	MEMBER	METHOD	MODIFIES	MODULE
MULTISET	NATIONAL	NATURAL	NCHAR	NCLOB	NEW	NONE	NUMERIC
OLD	OPEN	OUTPUT	OVERLAPS	PRECISION	PREPARE	RANGE	READS
RECURSIVE	REFERENCING	RELEASE	REVOKE	ROLLBACK	SAVEPOINT	SCROLL	SEARCH
SENSITIVE	SESSION_USER	SPECIFIC	SPECIFICTYPE	SQL	START	STATIC	SUBMULTILIST
SYMETRIC	SYSTEM	SYSTEM_USER	TIMEZONE_HOUR	TIMEZONE_MINUTE	TRANSLATION	TREAT	VALUE
VARYING	WHENEVER	WINDOW	WITHIN	XMLBINARY	XMLDOCUMENT	XMLITERATE	XMLVALIDATE

Tokens

Name	Definition	Usage
all in group identifier	<identifier> <period> <star>	all in group
binary string literal	"X" \| "x" "\'" (<hexit> <hexit>)+ "\'"	non numeric literal
colon	":"	make dep options, statement
comma	","	alter options list, column list, create procedure, typed element list create table body, create temporary table, derived column list, sql exception named parameter list, expression list, from clause, function limit clause, nested expression, object table, option clause options clause, order by clause, simple data type, query expression query primary, querystring function, select clause, set clause list in predicate, text aggreate function, text table, xml attributes xml element, xml query, xml forest, xml namespaces xml query, xml table
concat_op	"\|\|"	common value expression
decimal numeric literal	(<digit>)* <period> <unsigned integer literal>	unsigned numeric literal
digit	["0"-"9"]
dollar	"$"	parameter reference
eq	"="	assignment statement, callable statement, declare statement, named parameter list comparison operator, set clause list
escaped function	"{" "fn"	unsigned value expression primary
escaped join	"{" "oj"	table reference
escaped type	"{" ("d" \| "t" \| "ts" \| "b")	non numeric literal
approximate numeric literal	<digit> <period> <unsigned integer literal> ["e","E"] (<plus> \| <minus>)? <unsigned integer literal>	unsigned numeric literal
ge	">="	comparison operator
gt	">"	named parameter list, comparison operator
hexit	["a"-"f","A"-"F"] \| <digit>
identifier	<quoted_id> (<period> <quoted_id>)*	identifier, unsigned value expression primary
id_part	("@" \| "#" \| <letter>) (<letter> \| "_" \| <digit>)*
lbrace	"{"	callable statement, match predicate
le	"<="	comparison operator
letter	["a"-"z","A"-"Z"] \| ["\u0153"-"\ufffd"]
lparen	"("	standard aggregate function, alter options list, analytic aggregate function, array table callable statement, column list, other constraints, create procedure create table body, create temporary table, filter clause, function group by clause, if statement, json object, loop statement make dep options, nested expression, object table, options clause ordered aggreate function, simple data type, query primary, querystring function in predicate, call statement, subquery, table subquery table primary, text aggreate function, text table, unescapedFunction while statement, window specification, with list element, xml attributes xml element, xml query, xml forest, xml namespaces xml parse, xml query, xml serialize, xml table
lsbrace	"["	data type, value expression primary
lt	"<"	comparison operator
minus	"-"	plus or minus
ne	"<>"	comparison operator
ne2	"!="	comparison operator
period	"."
plus	"+"	plus or minus
qmark	"?"	callable statement, parameter reference
quoted_id	<id_part> \| "\"" ("\"\"" \| ~["\""])+ "\""
rbrace	"}"	callable statement, match predicate, non numeric literal, table reference unsigned value expression primary
rparen	")"	standard aggregate function, alter options list, analytic aggregate function, array table callable statement, column list, other constraints, create procedure create table body, create temporary table, filter clause, function group by clause, if statement, json object, loop statement make dep options, nested expression, object table, options clause ordered aggreate function, simple data type, query primary, querystring function in predicate, call statement, subquery, table subquery table primary, text aggreate function, text table, unescapedFunction while statement, window specification, with list element, xml attributes xml element, xml query, xml forest, xml namespaces xml parse, xml query, xml serialize, xml table
rsbrace	"]"	data type, value expression primary
semicolon	";"	ddl statement, delimited statement
slash	"/"	star or slash
star	"*"	standard aggregate function, dynamic data statement, select clause, star or slash
string literal	("N" \| "E")? "\'" ("\'\'" \| ~["\'"])* "\'"	string
unsigned integer literal	(<digit>)+	unsigned integer, unsigned numeric literal

Production Cross-Reference

Name	Usage
add set option	alter options list
standard aggregate function	unescapedFunction
all in group	select sublist
alter	directly executable statement
alter column options	alter options
alter options list	alter column options, alter options
alter options	ddl statement
analytic aggregate function	unescapedFunction
array table	table primary
assignment statement	delimited statement
assignment statement operand	assignment statement, declare statement
between predicate	boolean primary
boolean primary	filter clause, boolean factor
branching statement	delimited statement
case expression	unsigned value expression primary
character	match predicate, text aggreate function, text table
column list	other constraints, create temporary table, foreign key, insert statement primary key, with list element
common value expression	between predicate, boolean primary, comparison predicate, sql exception match predicate, like regex predicate, in predicate, text table
comparison predicate	boolean primary
boolean term	boolean value expression
boolean value expression	condition
compound statement	statement, directly executable statement
other constraints	create table body
table element	create table body
create procedure	ddl statement
typed element list	array table, dynamic data statement
create foreign temp table	directly executable statement
option namespace	ddl statement
create table	ddl statement
create table body	create foreign temp table, create table
create temporary table	directly executable statement
create trigger	ddl statement, directly executable statement
condition	expression, having clause, if statement, qualified table searched case expression, where clause, while statement
cross join	joined table
declare statement	delimited statement
delete statement	assignment statement operand, directly executable statement
delimited statement	statement
derived column	derived column list, object table, querystring function, text aggreate function xml attributes, xml query, xml query, xml table
derived column list	json object, xml forest
drop option	alter options list
drop table	directly executable statement
dynamic data statement	data statement
raise error statement	delimited statement
sql exception	assignment statement operand, exception reference
exception reference	sql exception, raise statement
named parameter list	callable statement, call statement
exists predicate	boolean primary
expression	standard aggregate function, assignment statement operand, case expression, derived column dynamic data statement, raise error statement, named parameter list, expression list function, nested expression, object table column, ordered aggreate function querystring function, return statement, searched case expression, select derived column set clause list, sort key, unescapedFunction, xml table column xml element, xml parse, xml serialize
expression list	callable statement, other constraints, function, group by clause query primary, call statement, window specification
fetch clause	limit clause
filter clause	function, unescapedFunction
for each row trigger action	alter, create trigger
foreign key	create table body
from clause	query
function	unescapedFunction, unsigned value expression primary
group by clause	query
having clause	query
identifier	alter, alter column options, alter options, array table assignment statement, branching statement, callable statement, column list compound statement, table element, create procedure, typed element list create foreign temp table, option namespace, create table, create table body create temporary table, create trigger, declare statement, delete statement derived column, drop option, drop table, dynamic data statement exception reference, named parameter list, foreign key, function if statement, insert statement, into clause, loop statement xml namespace element, object table column, object table, option clause option pair, procedure parameter, procedure result column, query primary select derived column, set clause list, statement, call statement table subquery, temporary table element, text aggreate function, text table column text table, table name, update statement, with list element xml table column, xml element, xml serialize, xml table
if statement	statement
insert statement	assignment statement operand, directly executable statement
integer parameter	fetch clause, limit clause
unsigned integer	dynamic data statement, integer parameter, make dep options, parameter reference simple data type, text table column, text table
time interval	function
into clause	query
is null predicate	boolean primary
joined table	table primary, table reference
json object	function
limit clause	query expression body
loop statement	statement
make dep options	option clause, table primary
match predicate	boolean primary
xml namespace element	xml namespaces
nested expression	unsigned value expression primary
non numeric literal	option pair, value expression primary
non-reserved identifier	identifier, unsigned value expression primary
boolean factor	boolean term
object table column	object table
object table	table primary
comparison operator	comparison predicate, quantified comparison predicate
option clause	callable statement, delete statement, insert statement, query expression body call statement, update statement
option pair	add set option, options clause
options clause	table element, create procedure, create table, create table body procedure parameter, procedure result column
order by clause	function, ordered aggreate function, query expression body, text aggreate function window specification
ordered aggreate function	unescapedFunction
parameter reference	unsigned value expression primary
data type	table element, create procedure, typed element list, declare statement function, object table column, procedure parameter, procedure result column temporary table element, text table column, unescapedFunction, xml table column
simple data type	data type
numeric value expression	common value expression, value expression primary
plus or minus	option pair, numeric value expression, value expression primary
primary key	create table body
procedure parameter	create procedure
procedure result column	create procedure
qualified table	joined table
query	query primary
query expression	alter, assignment statement operand, create table, insert statement loop statement, subquery, table subquery, directly executable statement with list element
query expression body	query expression, query primary
query primary	query term
querystring function	function
query term	query expression body
raise statement	delimited statement
like regex predicate	boolean primary
return statement	delimited statement
searched case expression	unsigned value expression primary
select clause	query
select derived column	select sublist
select sublist	select clause
set clause list	dynamic data statement, update statement
in predicate	boolean primary
sort key	sort specification
sort specification	order by clause
data statement	delimited statement
statement	alter, compound statement, create procedure, for each row trigger action if statement, loop statement, procedure body definition, while statement
call statement	assignment statement, subquery, table subquery, directly executable statement
string	character, table element, option namespace, function xml namespace element, non numeric literal, object table column, object table procedure parameter, text table column, text table, xml table column xml query, xml query, xml serialize, xml table
subquery	exists predicate, in predicate, quantified comparison predicate, unsigned value expression primary
quantified comparison predicate	boolean primary
table subquery	table primary
temporary table element	create temporary table
table primary	cross join, joined table
table reference	from clause, qualified table
text aggreate function	unescapedFunction
text table column	text table
text table	table primary
term	numeric value expression
star or slash	term
table name	table primary
unescapedFunction	unsigned value expression primary
unsigned numeric literal	option pair, value expression primary
unsigned value expression primary	integer parameter, value expression primary
update statement	assignment statement operand, directly executable statement
directly executable statement	data statement
value expression primary	array table, term
where clause	delete statement, query, update statement
while statement	statement
window specification	unescapedFunction
with list element	query expression
xml attributes	xml element
xml table column	xml table
xml element	function
xml query	boolean primary
xml forest	function
xml namespaces	xml element, xml query, xml forest, xml query xml table
xml parse	function
xml query	function
xml serialize	function
xml table	table primary

Productions

string ::=

<string literal>

A string literal value. Use '' to escape ' in the string.

Example:

non-reserved identifier ::=

INSTEAD
VIEW
ENABLED
DISABLED
KEY
SERIAL
TEXTAGG
COUNT
ROW_NUMBER
RANK
DENSE_RANK
SUM
AVG
MIN
MAX
EVERY
STDDEV_POP
STDDEV_SAMP
VAR_SAMP
VAR_POP
DOCUMENT
CONTENT
TRIM
EMPTY
ORDINALITY
PATH
FIRST
LAST
NEXT
SUBSTRING
EXTRACT
TO_CHARS
TO_BYTES
TIMESTAMPADD
TIMESTAMPDIFF
QUERYSTRING
NAMESPACE
RESULT
INDEX
ACCESSPATTERN
AUTO_INCREMENT
WELLFORMED
SQL_TSI_FRAC_SECOND
SQL_TSI_SECOND
SQL_TSI_MINUTE
SQL_TSI_HOUR
SQL_TSI_DAY
SQL_TSI_WEEK
SQL_TSI_MONTH
SQL_TSI_QUARTER
SQL_TSI_YEAR
TEXTTABLE
ARRAYTABLE
SELECTOR
SKIP
WIDTH
PASSING
NAME
ENCODING
COLUMNS
DELIMITER
QUOTE
HEADER
NULLS
OBJECTTABLE
VERSION
INCLUDING
EXCLUDING
XMLDECLARATION
VARIADIC
RAISE
EXCEPTION
CHAIN
JSONARRAY_AGG
JSONOBJECT
PRESERVE

Allows non-reserved keywords to be parsed as identifiers

Example:
SELECT COUNT FROM ...

Partial or full name of a single entity.

Example:

create trigger ::=

CREATE TRIGGER ON <identifier> INSTEAD OF ( INSERT | UPDATE | DELETE ) AS <for each row trigger action>

Creates a trigger action on the given target.

Example:

alter ::=

Alter the given target.

Example:

for each row trigger action ::=

FOR EACH ROW ( ( BEGIN ( ATOMIC )? ( <statement> )* END ) | <statement> )

Defines an action to perform on each row.

Example:

directly executable statement ::=

<query expression>
<call statement>
<insert statement>
<update statement>
<delete statement>
<drop table>
<create temporary table>
<create foreign temp table>
<alter>
<create trigger>
<compound statement>

A statement that can be executed at runtime.

Example:

drop table ::=

DROP TABLE <identifier>

Creates a trigger action on the given target.

Example:

create temporary table ::=

CREATE ( LOCAL )? TEMPORARY TABLE <identifier> <lparen> <temporary table element> ( <comma> <temporary table element> )* ( <comma> PRIMARY KEY <column list> )? <rparen> ( ON COMMIT PRESERVE ROWS )?

Creates a temporary table.

Example:

temporary table element ::=

<identifier> ( <data type> | SERIAL ) ( NOT NULL )?

Defines a temporary table column.

Example:

raise error statement ::=

ERROR <expression>

Raises an error with the given message.

Example:

raise statement ::=

RAISE ( SQLWARNING )? <exception reference>

Raises an error or warning with the given message.

Example:

exception reference ::=

<identifier>
<sql exception>

a reference to an exception

Example:

sql exception ::=

SQLEXCEPTION <common value expression> ( SQLSTATE <common value expression> ( <comma> <common value expression> )? )? ( CHAIN <exception reference> )?

creates a sql exception or warning with the specified message, state, and code

Example:

statement ::=

( ( <identifier> <colon> )? ( <loop statement> | <while statement> | <compound statement> ) )
<if statement> | <delimited statement>

A procedure statement.

Example:

delimited statement ::=

( <assignment statement> | <data statement> | <raise error statement> | <raise statement> | <declare statement> | <branching statement> | <return statement> ) <semicolon>

A procedure statement terminated by ;.

Example:

compound statement ::=

BEGIN ( ( NOT )? ATOMIC )? ( <statement> )* ( EXCEPTION <identifier> ( <statement> )* )? END

A procedure statement block contained in BEGIN END.

Example:

branching statement ::=

( ( BREAK | CONTINUE ) ( <identifier> )? )
( LEAVE <identifier> )

A procedure branching control statement, which typically specifies a label to return control to.

Example:

return statement ::=

RETURN ( <expression> )?

A return statement.

Example:

while statement ::=

WHILE <lparen> <condition> <rparen> <statement>

A procedure while statement that executes until its condition is false.

Example:

loop statement ::=

LOOP ON <lparen> <query expression> <rparen> AS <identifier> <statement>

A procedure loop statement that executes over the given cursor.

Example:

if statement ::=

IF <lparen> ( ( <identifier> IS ( NOT )? DISTINCT FROM <identifier> ) | <condition> ) <rparen> <statement> ( ELSE <statement> )?

A procedure loop statement that executes over the given cursor.

Example:

declare statement ::=

DECLARE ( <data type> | EXCEPTION ) <identifier> ( <eq> <assignment statement operand> )?

A procedure declaration statement that creates a variable and optionally assigns a value.

Example:

assignment statement ::=

<identifier> <eq> ( <assignment statement operand> | ( <call statement> ( ( WITH | WITHOUT ) RETURN )? ) )

Assigns a variable a value in a procedure.

Example:

assignment statement operand ::=

<insert statement>
<update statement>
<delete statement>
<expression>
<query expression>
<sql exception>

A value or command that can be used in an assignment.

All assigments except for expression are deprecated.

data statement ::=

( <directly executable statement> | <dynamic data statement> ) ( ( WITH | WITHOUT ) RETURN )?

A procedure statement that executes a SQL statement. An update statement can have its update count accessed via the ROWCOUNT variable.

procedure body definition ::=

( CREATE ( VIRTUAL )? PROCEDURE )? <statement>

Defines a procedure body on a Procedure metadata object.

Example:

dynamic data statement ::=

( EXECUTE | EXEC ) ( STRING | IMMEDIATE )? <expression> ( AS <typed element list> ( INTO <identifier> )? )? ( USING <set clause list> )? ( UPDATE ( <unsigned integer> | <star> ) )?

A procedure statement that can execute arbitrary sql.

Example:

set clause list ::=

<identifier> <eq> <expression> ( <comma> <identifier> <eq> <expression> )*

A list of value assignments.

Example:

typed element list ::=

<identifier> <data type> ( <comma> <identifier> <data type> )*

A list of typed elements.

Example:

callable statement ::=

<lbrace> ( <qmark> <eq> )? CALL <identifier> ( <lparen> ( <named parameter list> | ( <expression list> )? ) <rparen> )? <rbrace> ( <option clause> )?

A callable statement defined using JDBC escape syntax.

Example:

call statement ::=

( ( EXEC | EXECUTE | CALL ) <identifier> <lparen> ( <named parameter list> | ( <expression list> )? ) <rparen> ) ( <option clause> )?

Executes the procedure with the given parameters.

Example:

named parameter list ::=

( <identifier> <eq> ( <gt> )? <expression> ( <comma> <identifier> <eq> ( <gt> )? <expression> )* )

A list of named parameters.

Example:

insert statement ::=

( INSERT | MERGE ) INTO <identifier> ( <column list> )? <query expression> ( <option clause> )?

Inserts values into the given target.

Example:

expression list ::=

<expression> ( <comma> <expression> )*

A list of expressions.

Example:

update statement ::=

UPDATE <identifier> SET <set clause list> ( <where clause> )? ( <option clause> )?

Update values in the given target.

Example:

delete statement ::=

DELETE FROM <identifier> ( <where clause> )? ( <option clause> )?

Delete rows from the given target.

Example:

query expression ::=

( WITH <with list element> ( <comma> <with list element> )* )? <query expression body>

A declarative query for data.

Example:

with list element ::=

<identifier> ( <column list> )? AS <lparen> <query expression> <rparen>

A query expression for use in the enclosing query.

Example:

query expression body ::=

<query term> ( ( UNION | EXCEPT ) ( ALL | DISTINCT )? <query term> )* ( <order by clause> )? ( <limit clause> )? ( <option clause> )?

The body of a query expression, which can optionally be ordered and limited.

Example:

query term ::=

<query primary> ( INTERSECT ( ALL | DISTINCT )? <query primary> )*

Used to establish INTERSECT precedence.

Example:

query primary ::=

<query>
( VALUES <lparen> <expression list> <rparen> ( <comma> <lparen> <expression list> <rparen> )* )
( TABLE <identifier> )
( <lparen> <query expression body> <rparen> )

A declarative source of rows.

Example:

query ::=

<select clause> ( <into clause> )? ( <from clause> ( <where clause> )? ( <group by clause> )? ( <having clause> )? )?

A SELECT query.

Example:

into clause ::=

INTO <identifier>

Used to direct the query into a table.

This is deprecated. Use INSERT INTO with a query expression instead.

Example:

select clause ::=

SELECT ( ALL | DISTINCT )? ( <star> | ( <select sublist> ( <comma> <select sublist> )* ) )

The columns returned by a query. Can optionally be distinct.

Example:

select sublist ::=

<select derived column>
<all in group >

An element in the select clause

Example:

select derived column ::=

( <expression> ( ( AS )? <identifier> )? )

A select clause item that selects a single column.

This is slightly different than a derived column in that the AS keyword is optional.

Example:

derived column ::=

( <expression> ( AS <identifier> )? )

An optionally named expression.

Example:

all in group ::=

<all in group identifier>

A select sublist that can select all columns from the given group.

Example:

ordered aggreate function ::=

( XMLAGG | ARRAY_AGG | JSONARRAY_AGG ) <lparen> <expression> ( <order by clause> )? <rparen>

An aggregate function that can optionally be ordered.

Example:

text aggreate function ::=

TEXTAGG <lparen> ( FOR )? <derived column> ( <comma> <derived column> )* ( DELIMITER <character> )? ( QUOTE <character> )? ( HEADER )? ( ENCODING <identifier> )? ( <order by clause> )? <rparen>

An aggregate function for creating separated value clobs.

Example:

standard aggregate function ::=

( COUNT <lparen> <star> <rparen> )
( ( COUNT | SUM | AVG | MIN | MAX | EVERY | STDDEV_POP | STDDEV_SAMP | VAR_SAMP | VAR_POP | SOME | ANY ) <lparen> ( DISTINCT | ALL )? <expression> <rparen> )

A standard aggregate function.

Example:

analytic aggregate function ::=

( ROW_NUMBER | RANK | DENSE_RANK ) <lparen> <rparen>

An analytic aggregate function.

Example:

filter clause ::=

FILTER <lparen> WHERE <boolean primary> <rparen>

An aggregate filter clause applied prior to accumulating the value.

Example:

from clause ::=

FROM ( <table reference> ( <comma> <table reference> )* )

A query from clause containing a list of table references.

Example:

table reference ::=

( <escaped join> <joined table> <rbrace> )
<joined table>

An optionally escaped joined table.

Example:

joined table ::=

<table primary> ( <cross join> | <qualified table> )*

A table or join.

Example:

cross join ::=

( ( CROSS | UNION ) JOIN <table primary> )

A cross join.

Example:

qualified table ::=

( ( ( RIGHT ( OUTER )? ) | ( LEFT ( OUTER )? ) | ( FULL ( OUTER )? ) | INNER )? JOIN <table reference> ON <condition> )

An INNER or OUTER join.

Example:

table primary ::=

A single source of rows.

Example:

make dep options ::=

( <lparen> ( MAX <colon> <unsigned integer> )? ( ( NO )? JOIN )? <rparen> )?

options for the make dep hint

Example:

xml serialize ::=

Serializes an XML value.

Example:

array table ::=

ARRAYTABLE <lparen> <value expression primary> COLUMNS <typed element list> <rparen> ( AS )? <identifier>

The ARRAYTABLE table function creates tabular results from arrays. It can be used as a nested table reference.

Example:

text table ::=

TEXTTABLE <lparen> <common value expression> ( SELECTOR <string> )? COLUMNS <text table column> ( <comma> <text table column> )* ( ( NO ROW DELIMITER ) | ( ROW DELIMITER <character> ) )? ( DELIMITER <character> )? ( ( ESCAPE <character> ) | ( QUOTE <character> ) )? ( HEADER ( <unsigned integer> )? )? ( SKIP <unsigned integer> )? ( NO TRIM )? <rparen> ( AS )? <identifier>

The TEXTTABLE table function creates tabular results from text. It can be used as a nested table reference.

Example:

text table column ::=

<identifier> ( ( FOR ORDINALITY ) | ( ( HEADER <string> )? <data type> ( WIDTH <unsigned integer> ( NO TRIM )? )? ( SELECTOR <string> <unsigned integer> )? ) )

A text table column.

Example:

xml query ::=

XMLEXISTS <lparen> ( <xml namespaces> <comma> )? <string> ( PASSING <derived column> ( <comma> <derived column> )* )? <rparen>

Executes an XQuery to return an XML result.

Example:

xml query ::=

XMLQUERY <lparen> ( <xml namespaces> <comma> )? <string> ( PASSING <derived column> ( <comma> <derived column> )* )? ( ( NULL | EMPTY ) ON EMPTY )? <rparen>

Executes an XQuery to return an XML result.

Example:

object table ::=

OBJECTTABLE <lparen> ( LANGUAGE <string> )? <string> ( PASSING <derived column> ( <comma> <derived column> )* )? COLUMNS <object table column> ( <comma> <object table column> )* <rparen> ( AS )? <identifier>

Returns table results by processing a script.

Example:

object table column ::=

<identifier> <data type> <string> ( DEFAULT <expression> )?

object table column.

Example:

xml table ::=

XMLTABLE <lparen> ( <xml namespaces> <comma> )? <string> ( PASSING <derived column> ( <comma> <derived column> )* )? ( COLUMNS <xml table column> ( <comma> <xml table column> )* )? <rparen> ( AS )? <identifier>

Returns table results by processing an XQuery.

Example:

xml table column ::=

<identifier> ( ( FOR ORDINALITY ) | ( <data type> ( DEFAULT <expression> )? ( PATH <string> )? ) )

XML table column.

Example:

unsigned integer ::=

<unsigned integer literal>

An unsigned interger value.

Example:

table subquery ::=

( TABLE | LATERAL )? <lparen> ( <query expression> | <call statement> ) <rparen> ( AS )? <identifier>

A table defined by a subquery.

Example:

table name ::=

( <identifier> ( ( AS )? <identifier> )? )

A table named in the FROM clause.

Example:

where clause ::=

WHERE <condition>

Specifies a search condition

Example:

condition ::=

<boolean value expression>

A boolean expression.

boolean value expression ::=

<boolean term> ( OR <boolean term> )*

An optionally ORed boolean expression.

boolean term ::=

<boolean factor> ( AND <boolean factor> )*

An optional ANDed boolean factor.

boolean factor ::=

( NOT )? <boolean primary>

A boolean factor.

Example:

boolean primary ::=

<exists predicate>
<xml query>

A boolean predicate or simple expression.

Example:

comparison operator ::=

<eq>
<ne>
<ne2>
<lt>
<le>
<gt>
<ge>

A comparison operator.

Example:

comparison predicate ::=

<comparison operator> <common value expression>

A value comparison.

Example:

subquery ::=

<lparen> ( <query expression> | <call statement> ) <rparen>

A subquery.

Example:

quantified comparison predicate ::=

<comparison operator> ( ANY | SOME | ALL ) <subquery>

A subquery comparison.

Example:

match predicate ::=

( NOT )? ( LIKE | ( SIMILAR TO ) ) <common value expression> ( ESCAPE <character> | ( <lbrace> ESCAPE <character> <rbrace> ) )?

Matches based upon a pattern.

Example:

like regex predicate ::=

( NOT )? LIKE_REGEX <common value expression>

A regular expression match.

Example:

character ::=

<string>

A single character.

Example:

between predicate ::=

( NOT )? BETWEEN <common value expression> AND <common value expression>

A comparison between two values.

Example:

is null predicate ::=

IS ( NOT )? NULL

A null test.

Example:

in predicate ::=

( NOT )? IN ( <subquery> | ( <lparen> <common value expression> ( <comma> <common value expression> )* <rparen> ) )

A comparison with multiple values.

Example:

exists predicate ::=

EXISTS <subquery>

A test if rows exist.

Example:

group by clause ::=

GROUP BY ( ROLLUP <lparen> <expression list> <rparen> | <expression list> )

Defines the grouping columns

Example:

having clause ::=

HAVING <condition>

Search condition applied after grouping.

Example:

order by clause ::=

ORDER BY <sort specification> ( <comma> <sort specification> )*

Specifices row ordering.

Example:

sort specification ::=

<sort key> ( ASC | DESC )? ( NULLS ( FIRST | LAST ) )?

Defines how to sort on a particular expression

Example:

sort key ::=

<expression>

A sort expression.

Example:

integer parameter ::=

<unsigned integer>
<unsigned value expression primary>

A literal integer or parameter reference to an integer.

Example:

limit clause ::=

( LIMIT <integer parameter> ( <comma> <integer parameter> )? )
( OFFSET <integer parameter> ( ROW | ROWS ) ( <fetch clause> )? )
<fetch clause>

Limits and/or offsets the resultant rows.

Example:

fetch clause ::=

FETCH ( FIRST | NEXT ) ( <integer parameter> )? ( ROW | ROWS ) ONLY

ANSI limit.

Example:

option clause ::=

OPTION ( MAKEDEP <identifier> <make dep options> ( <comma> <identifier> <make dep options> )* | MAKEIND <identifier> <make dep options> ( <comma> <identifier> <make dep options> )* | MAKENOTDEP <identifier> ( <comma> <identifier> )* | NOCACHE ( <identifier> ( <comma> <identifier> )* )? )*

Specifies query options.

Example:

expression ::=

<condition>

A value.

Example:

common value expression ::=

( <numeric value expression> ( <concat_op> <numeric value expression> )* )

Establishes the precedence of concat.

Example:

numeric value expression ::=

( <term> ( <plus or minus> <term> )* )

Example:

plus or minus ::=

<plus>
<minus>

The + or - operator.

Example:

term ::=

( <value expression primary> ( <star or slash> <value expression primary> )* )

A numeric term

Example:

star or slash ::=

<star>
<slash>

The * or / operator.

Example:

value expression primary ::=

<non numeric literal>
( <plus or minus> )? ( <unsigned numeric literal> | ( <unsigned value expression primary> ( <lsbrace> <numeric value expression> <rsbrace> )* ) )

A simple value expression.

Example:

parameter reference ::=

<qmark>
( <dollar> <unsigned integer> )

A parameter reference to be bound later.

Example:

unescapedFunction ::=

( ( <text aggreate function> | <standard aggregate function> | <ordered aggreate function> ) ( <filter clause> )? ( <window specification> )? ) | ( <analytic aggregate function> ( <filter clause> )? <window specification> ) | ( <function> ( <window specification> )? )

( XMLCAST <lparen> <expression> AS <data type> <rparen> )

nested expression ::=

( <lparen> ( <expression> ( <comma> <expression> )* )? ( <comma> )? <rparen> )

An expression nested in parens

Example:

unsigned value expression primary ::=

<parameter reference>
( <escaped function> <function> <rbrace> )
<unescapedFunction>
<identifier> | <non-reserved identifier>
<subquery>
<nested expression>
<searched case expression>
<case expression>

An unsigned simple value expression.

Example:

window specification ::=

OVER <lparen> ( PARTITION BY <expression list> )? ( <order by clause> )? <rparen>

The window specification for an analytical or windowed aggregate function.

Example:

case expression ::=

CASE <expression> ( WHEN <expression> THEN <expression> )+ ( ELSE <expression> )? END

If/then/else chain using a common search predicand.

Example:

searched case expression ::=

CASE ( WHEN <condition> THEN <expression> )+ ( ELSE <expression> )? END

If/then/else chain using multiple search conditions.

Example:

function ::=

( CONVERT <lparen> <expression> <comma> <data type> <rparen> )
( CAST <lparen> <expression> AS <data type> <rparen> )
( SUBSTRING <lparen> <expression> ( ( FROM <expression> ( FOR <expression> )? ) | ( <comma> <expression list> ) ) <rparen> )
( EXTRACT <lparen> ( YEAR | MONTH | DAY | HOUR | MINUTE | SECOND ) FROM <expression> <rparen> )
( TRIM <lparen> ( ( ( ( LEADING | TRAILING | BOTH ) ( <expression> )? ) | <expression> ) FROM )? <expression> <rparen> )
( ( TO_CHARS | TO_BYTES ) <lparen> <expression> <comma> <string> ( <comma> <expression> )? <rparen> )
( ( TIMESTAMPADD | TIMESTAMPDIFF ) <lparen> <time interval> <comma> <expression> <comma> <expression> <rparen> )
<querystring function>
( ( LEFT | RIGHT | CHAR | USER | YEAR | MONTH | HOUR | MINUTE | SECOND | XMLCONCAT | XMLCOMMENT | XMLTEXT ) <lparen> ( <expression list> )? <rparen> )
( ( TRANSLATE | INSERT ) <lparen> ( <expression list> )? <rparen> )
<xml parse>
<xml element>
( XMLPI <lparen> ( ( NAME )? <identifier> ) ( <comma> <expression> )? <rparen> )
<xml forest>
<json object>
<xml serialize>
<xml query>
( <identifier> <lparen> ( ALL | DISTINCT )? ( <expression list> )? ( <order by clause> )? <rparen> ( <filter clause> )? )

Calls a scalar function.

Example:

xml parse ::=

XMLPARSE <lparen> ( DOCUMENT | CONTENT ) <expression> ( WELLFORMED )? <rparen>

Parses the given value as XML.

Example:

querystring function ::=

QUERYSTRING <lparen> <expression> ( <comma> <derived column> )* <rparen>

Produces a URL query string from the given arguments.

Example:

xml element ::=

XMLELEMENT <lparen> ( ( NAME )? <identifier> ) ( <comma> <xml namespaces> )? ( <comma> <xml attributes> )? ( <comma> <expression> )* <rparen>

Creates an XML element.

Example:

xml attributes ::=

XMLATTRIBUTES <lparen> <derived column> ( <comma> <derived column> )* <rparen>

Creates attributes for the containing element.

Example:

json object ::=

JSONOBJECT <lparen> <derived column list> <rparen>

Produces a JSON object containing name value pairs.

Example:

derived column list ::=

<derived column> ( <comma> <derived column> )*

a list of name value pairs

Example:

xml forest ::=

XMLFOREST <lparen> ( <xml namespaces> <comma> )? <derived column list> <rparen>

Produces an element for each derived column.

Example:

xml namespaces ::=

XMLNAMESPACES <lparen> <xml namespace element> ( <comma> <xml namespace element> )* <rparen>

Defines XML namespace URI/prefix combinations

Example:

xml namespace element ::=

( <string> AS <identifier> )
( NO DEFAULT )
( DEFAULT <string> )

An xml namespace

Example:

simple data type ::=

( STRING ( <lparen> <unsigned integer> <rparen> )? )
( VARCHAR ( <lparen> <unsigned integer> <rparen> )? )
BOOLEAN
BYTE
TINYINT
SHORT
SMALLINT
( CHAR ( <lparen> <unsigned integer> <rparen> )? )
INTEGER
LONG
BIGINT
( BIGINTEGER ( <lparen> <unsigned integer> <rparen> )? )
FLOAT
REAL
DOUBLE
( BIGDECIMAL ( <lparen> <unsigned integer> ( <comma> <unsigned integer> )? <rparen> )? )
( DECIMAL ( <lparen> <unsigned integer> ( <comma> <unsigned integer> )? <rparen> )? )
DATE
TIME
TIMESTAMP
( OBJECT ( <lparen> <unsigned integer> <rparen> )? )
( BLOB ( <lparen> <unsigned integer> <rparen> )? )
( CLOB ( <lparen> <unsigned integer> <rparen> )? )
( VARBINARY ( <lparen> <unsigned integer> <rparen> )? )
GEOMETRY
XML

A non-collection data type.

Example:

data type ::=

<simple data type> ( <lsbrace> <rsbrace> )*

A data type.

Example:

time interval ::=

SQL_TSI_FRAC_SECOND
SQL_TSI_SECOND
SQL_TSI_MINUTE
SQL_TSI_HOUR
SQL_TSI_DAY
SQL_TSI_WEEK
SQL_TSI_MONTH
SQL_TSI_QUARTER
SQL_TSI_YEAR

A time interval keyword.

Example:

non numeric literal ::=

<string>
<binary string literal>
FALSE
TRUE
UNKNOWN
NULL
( <escaped type> <string> <rbrace> )
( ( DATE | TIME | TIMESTAMP ) <string> )

An escaped or simple non numeric literal.

Example:

unsigned numeric literal ::=

<unsigned integer literal>
<approximate numeric literal>
<decimal numeric literal>

An unsigned numeric literal value.

Example:

ddl statement ::=

( <create table> | <create procedure> | <option namespace> | <alter options> | <create trigger> ) ( <semicolon> )?

A data definition statement.

Example:

option namespace ::=

SET NAMESPACE <string> AS <identifier>

A namespace used to shorten the full name of an option key.

Example:

create procedure ::=

CREATE ( VIRTUAL | FOREIGN )? ( PROCEDURE | FUNCTION ) ( <identifier> <lparen> ( <procedure parameter> ( <comma> <procedure parameter> )* )? <rparen> ( RETURNS ( <options clause> )? ( ( ( TABLE )? <lparen> <procedure result column> ( <comma> <procedure result column> )* <rparen> ) | <data type> ) )? ( <options clause> )? ( AS <statement> )? )

Defines a procedure or function invocation.

Example:

procedure parameter ::=

( IN | OUT | INOUT | VARIADIC )? <identifier> <data type> ( NOT NULL )? ( RESULT )? ( DEFAULT <string> )? ( <options clause> )?

A procedure or function parameter

Example:

procedure result column ::=

<identifier> <data type> ( NOT NULL )? ( <options clause> )?

A procedure result column.

Example:

create table ::=

CREATE ( ( FOREIGN TABLE ) | ( ( VIRTUAL )? VIEW ) | ( GLOBAL TEMPORARY TABLE ) ) <identifier> ( <create table body> | ( <options clause> )? ) ( AS <query expression> )?

Defines a table or view.

Example:

create foreign temp table ::=

CREATE ( LOCAL )? FOREIGN TEMPORARY TABLE <identifier> <create table body> ON <identifier>

Defines a foreign temp table

Example:

create table body ::=

<lparen> <table element> ( <comma> <table element> )* ( <comma> ( CONSTRAINT <identifier> )? ( <primary key> | <other constraints> | <foreign key> ) ( <options clause> )? )* <rparen> ( <options clause> )?

Defines a table.

Example:

foreign key ::=

FOREIGN KEY <column list> REFERENCES <identifier> ( <column list> )?

Defines the foreign key referential constraint.

Example:

primary key ::=

PRIMARY KEY <column list>

Defines the primary key.

Example:

other constraints ::=

( ( UNIQUE | ACCESSPATTERN ) <column list> )
( INDEX <lparen> <expression list> <rparen> )

Defines ACCESSPATTERN and UNIQUE constraints and INDEXes.

Example:

column list ::=

<lparen> <identifier> ( <comma> <identifier> )* <rparen>

A list of column names.

Example:

table element ::=

<identifier> ( SERIAL | ( <data type> ( NOT NULL )? ( AUTO_INCREMENT )? ) ) ( ( PRIMARY KEY ) | ( ( UNIQUE )? ( INDEX )? ) ) ( DEFAULT <string> )? ( <options clause> )?

Defines a table column.

Example:

options clause ::=

OPTIONS <lparen> <option pair> ( <comma> <option pair> )* <rparen>

A list of statement options.

Example:

option pair ::=

<identifier> ( <non numeric literal> | ( <plus or minus> )? <unsigned numeric literal> )

An option key/value pair.

Example:

alter options ::=

ALTER ( VIRTUAL | FOREIGN )? ( TABLE | VIEW | PROCEDURE ) <identifier> ( <alter options list> | <alter column options> )

alters options of tables/procedure

Example:

alter options list ::=

OPTIONS <lparen> ( <add set option> | <drop option> ) ( <comma> ( <add set option> | <drop option> ) )* <rparen>

a list of alterations to options

Example:

drop option ::=

DROP <identifier>

drop option

Example:

add set option ::=

( ADD | SET ) <option pair>

add or set an option pair

Example:

alter column options ::=

ALTER ( COLUMN | PARAMETER )? <identifier> <alter options list>

alters a set of column options

Example: