- Main Entry Points
- Reserved Keywords
- Non-Reserved Keywords
- Reserved Keywords For Future Use
- Tokens
- Production Cross-Reference
- Productions
Reserved Keywords
Non-Reserved Keywords
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
Production Cross-Reference
Productions
string ::=
A string literal value. Use '' to escape ' in the string.
Example:
non-reserved identifier ::=
Allows non-reserved keywords to be parsed as identifiers
Example:
SELECT COUNT FROM ...
identifier ::=
Partial or full name of a single entity.
Example:
create trigger ::=
Creates a trigger action on the given target.
Example:
alter ::=
ALTER ( ( VIEW <identifier> AS <query expression> ) | ( PROCEDURE <identifier> AS <statement> ) | ( TRIGGER ON <identifier> INSTEAD OF ( INSERT | UPDATE | DELETE ) ( ( AS <for each row trigger action> ) | ENABLED | DISABLED ) ) )
Alter the given target.
Example:
for each row trigger action ::=
Defines an action to perform on each row.
Example:
directly executable statement ::=
<alter>
A statement that can be executed at runtime.
Example:
drop table ::=
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 ::=
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 ::=
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> ) )
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 ::=
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 ::=
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 ::=
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 ::=
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 ::=
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 ::=
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 ::=
<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 ::=
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 ::=
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> )
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 ::=
An INNER or OUTER join.
Example:
table primary ::=
( <text table> | <array table> | <xml table> | <object table> | <table name> | <table subquery> | ( <lparen> <joined table> <rparen> ) ) ( ( MAKEDEP <make dep options> ) | MAKENOTDEP )? ( ( MAKEIND <make dep options> ) )?
A single source of rows.
Example:
make dep options ::=
options for the make dep hint
Example:
xml serialize ::=
XMLSERIALIZE <lparen> ( DOCUMENT | CONTENT )? <expression> ( AS ( STRING | VARCHAR | CLOB | VARBINARY | BLOB ) )? ( ENCODING <identifier> )? ( VERSION <string> )? ( ( INCLUDING | EXCLUDING ) XMLDECLARATION )? <rparen>
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 ::=
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 ::=
Specifies a search condition
Example:
condition ::=
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 ::=
( <common value expression> ( <between predicate> | <match predicate> | <like regex predicate> | <in predicate> | <is null predicate> | <quantified comparison predicate> | <comparison predicate> )? )
A boolean predicate or simple expression.
Example:
comparison operator ::=
A comparison operator.
Example:
comparison predicate ::=
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 ::=
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 ::=
A comparison between two values.
Example:
is null predicate ::=
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 ::=
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 ::=
Search condition applied after grouping.
Example:
order by clause ::=
ORDER BY <sort specification> ( <comma> <sort specification> )*
Specifices row ordering.
Example:
sort specification ::=
Defines how to sort on a particular expression
Example:
sort key ::=
A sort expression.
Example:
integer parameter ::=
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> )? )
Limits and/or offsets the resultant rows.
Example:
fetch clause ::=
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 ::=
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 ::=
The + or - operator.
Example:
term ::=
( <value expression primary> ( <star or slash> <value expression primary> )* )
A numeric term
Example:
star or slash ::=
The * or / operator.
Example:
value expression primary ::=
( <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> )? )
nested expression ::=
( <lparen> ( <expression> ( <comma> <expression> )* )? ( <comma> )? <rparen> )
An expression nested in parens
Example:
unsigned value expression primary ::=
( <escaped function> <function> <rbrace> ) <subquery>
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 ::=
( SUBSTRING <lparen> <expression> ( ( FROM <expression> ( FOR <expression> )? ) | ( <comma> <expression list> ) ) <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> ) ( ( TRANSLATE | INSERT ) <lparen> ( <expression list> )? <rparen> ) ( XMLPI <lparen> ( ( NAME )? <identifier> ) ( <comma> <expression> )? <rparen> ) ( <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 ::=
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> )
An xml namespace
Example:
simple data type ::=
( STRING ( <lparen> <unsigned integer> <rparen> )? ) ( VARCHAR ( <lparen> <unsigned integer> <rparen> )? ) ( CHAR ( <lparen> <unsigned integer> <rparen> )? ) ( BIGINTEGER ( <lparen> <unsigned integer> <rparen> )? ) ( BIGDECIMAL ( <lparen> <unsigned integer> ( <comma> <unsigned integer> )? <rparen> )? ) ( DECIMAL ( <lparen> <unsigned integer> ( <comma> <unsigned integer> )? <rparen> )? ) ( OBJECT ( <lparen> <unsigned integer> <rparen> )? ) ( BLOB ( <lparen> <unsigned integer> <rparen> )? ) ( CLOB ( <lparen> <unsigned integer> <rparen> )? ) ( VARBINARY ( <lparen> <unsigned integer> <rparen> )? )
A non-collection data type.
Example:
data type ::=
<simple data type> ( <lsbrace> <rsbrace> )*
A data type.
Example:
time interval ::=
A time interval keyword.
Example:
non numeric literal ::=
<string> ( <escaped type> <string> <rbrace> )
An escaped or simple non numeric literal.
Example:
unsigned 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 ::=
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 ::=
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 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:
2 Comments
comments.show.hideNov 16, 2016
Tom Johnston
I see no method for COMMENTS (DESCRIPTIONS). There should be a method to include comments/descriptions on all objects both at CREATE as well as ALTER.
Nov 16, 2016
Steven Hawkins
Are you a member of confluence-writers? This should be closed to comments as the docs have moved to gitbook.
In any case altering a comment is beyond the scope of the 9.1 and earlier alter support - but should be available with TEIID-2578.
On a create you use the ANNOTATION option to set the description, which is shown on the DDL Metadata page.