BNF Grammar for ISO/IEC 9075-2:2003 - Database Language SQL (SQL-2003) SQL/Foundation

Cross-Reference: rules
Cross-Reference: keywords

Derived from file sql-2003-2.bnf version 1.23 dated 2017/11/14 06:53:22
Generated on 2017-11-14 06:53:25+00:00 by file bnf2html.pl version 3.16 dated 2017/11/14 06:53:22

Information taken from the Final Committee Draft (FCD) of ISO/IEC 9075-2:2003. However, the page numbers and some section titles (9.14 through 9.23, for example) are from the final standard. This means there could be other as yet undiagnosed differences between the final standard and the notation in this document; you were warned!

The plain text version of this grammar is sql-2003-2.bnf .

Key SQL Statements and Fragments

ALTER DOMAIN <alter domain statement>

ALTER TABLE <alter table statement>

CLOSE cursor <close statement>

Column definition <column definition>

COMMIT WORK <commit statement>

CONNECT <connect statement>

CREATE ASSERTION <assertion definition>

CREATE CHARACTER SET <character set definition>

CREATE COLLATION <collation definition>

CREATE DOMAIN <domain definition>

CREATE FUNCTION <schema function>

CREATE PROCEDURE <schema procedure>

CREATE SCHEMA <schema definition>

CREATE TABLE <table definition>

CREATE TRANSLATION <translation definition>

CREATE TRIGGER <trigger definition>

CREATE VIEW <view definition>

Data type <data type>

DEALLOCATE PREPARE <deallocate prepared statement>

DECLARE cursor <declare cursor> <dynamic declare cursor>

DECLARE LOCAL TEMPORARY TABLE <temporary table declaration>

DELETE <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned>

DESCRIBE <describe statement>

DESCRIPTOR statements <system descriptor statement>

DISCONNECT <disconnect statement>

EXECUTE <execute statement>

EXECUTE IMMEDIATE <execute immediate statement>

FETCH cursor <fetch statement>

FROM clause <from clause>

GET DIAGNOSTICS <get diagnostics statement>

GRANT <grant statement>

GROUP BY clause <group by clause>

HAVING clause <having clause>

INSERT <insert statement>

Literals <literal>

Keywords <key word>

MERGE <merge statement>

OPEN cursor <open statement>

ORDER BY clause <order by clause>

PREPARE <prepare statement>

REVOKE <revoke statement>

ROLLBACK WORK <rollback statement>

SAVEPOINT <savepoint statement>

Search condition <search condition> <regular expression>

SELECT <query specification>

SET CATALOG <set catalog statement>

SET CONNECTION <set connection statement>

SET CONSTRAINTS <set constraints mode statement>

SET NAMES <set names statement>

SET SCHEMA <set schema statement>

SET SESSION AUTHORIZATION <set session user identifier statement>

SET TIME ZONE <set local time zone statement>

SET TRANSACTION <set transaction statement>

SQL Client MODULE <SQL-client module definition>

UPDATE <update statement: positioned> <update statement: searched> <dynamic update statement: positioned>

Value expression <value expression>

WHERE clause <where clause>

Top

5 Lexical Elements

Basic definitions of characters used, tokens, symbols, etc. Most of this section would normally be handled within the lexical analyzer rather than in the grammar proper. Further, the original document does not quote the various single characters, which makes it hard to process automatically.

5.1 <SQL terminal character> (p151)

<simple Latin upper case letter> ::=
A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

<simple Latin lower case letter> ::=
a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z

<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<space> ::= !! See the Syntax Rules.

<double quote> ::= "

<percent> ::= %

<ampersand> ::= &

<quote> ::= '

<left paren> ::= (

<right paren> ::= )

<asterisk> ::= *

<plus sign> ::= +

<comma> ::= ,

<minus sign> ::= -

<period> ::= .

<solidus> ::= /

<colon> ::= :

<semicolon> ::= ;

<less than operator> ::= <

<equals operator> ::= =

<question mark> ::= ?

The trigraphs are new in SQL-2003.

<left bracket> ::= [

<left bracket trigraph> ::= ??(

<right bracket> ::= ]

<right bracket trigraph> ::= ??)

<circumflex> ::= ^

<underscore> ::= _

<vertical bar> ::= |

<left brace> ::= {

<right brace> ::= }

Top

5.2 <token> and <separator> (p134)

Specifying lexical units (tokens and separators) that participate in SQL language.

<identifier body> ::= <identifier start> [ <identifier part> ... ]

The previous version of the SQL standard defined an identifier start as either an <initial alphabetic character> or an <ideographic character>. Neither of the defining terms is defined in SQL 2003 (and the SQL 99 definitions of those defininng terms referred to the syntax rules), but the result of the SQL 2003 syntax rules will be similar to SQL 99 ones except with Unicode support added.

<identifier start> ::= !! See the Syntax Rules.

<identifier extend> ::= !! See the Syntax Rules.

<multiplier> ::= K | M | G

<delimited identifier body> ::= <delimited identifier part> ...

The productions for <Unicode delimited identifier> and so on are new in SQL-2003.

<Unicode escape specifier> ::= [ UESCAPE <quote> <Unicode escape character> <quote> ]

<Unicode delimiter body> ::= <Unicode identifier part> ...

Syntax rule 20: <Unicode 4 digit escape value>'<Unicode escape character>+xyzw' is equivalent to the Unicode code point specified by U+xyzw.

Syntax rule 21: <Unicode 6 digit escape value>'<Unicode escape character>+xyzwrs' is equivalent to the Unicode code point specified by U+xyzwrs.

NOTE 64: The 6-hexit notation is derived by taking the UCS-4 notation defined by ISO/IEC 10646-1 and removing the leading two hexits, whose values are always 0 (zero).

Syntax rule 22: <Unicode character escape value> is equivalent to a single instance of <Unicode escape character>.

Syntax rule 15: <Unicode escape character> shall be a single character from the source language character set other than a <hexit>, <plus sign>, or <white space>.

Syntax rule 16: If the source language character set contains <reverse solidus>, then let DEC be <reverse solidus>; otherwise, let DEC be an implementation-defined character from the source language character set that is not a <hexit>, <plus sign>, <double quote>, or <white space>.

Syntax rule 17: If a <Unicode escape specifier> does not contain <Unicode escape character>, then "UESCAPE <quote>DEC<quote>" is implicit.

Syntax rule 18: In a <Unicode escape value> there shall be no <separator> between the <Unicode escape character> and the first <hexit>, nor between any of the <hexit>s.

<Unicode escape character> ::= !! See the Syntax Rules (15-18 above).

Syntax rule 6: A <nondoublequote character> is any character of the source language character set other than a <double quote>.

<nondoublequote character> ::= !! See the Syntax Rules.

The rule for <doublequote symbol> in the standard uses two adjacent literal double quotes rather than referencing <double quote>; the reasons are not clear. It is annotated '!! two consecutive double quote characters'.

The rules for <not equals operator> etc in the standard uses two adjacent literal characters rather than referencing <less than> and <greater than>; the reasons are not clear. Note that two characters must be adjacent with no intervening space, not a pair of characters separated by arbitrary white space.

<separator> ::= { <comment> | <white space> }...

<simple comment introducer> ::= <minus sign> <minus sign> [ <minus sign> ... ]

The <bracketed comment> rule included '!! See the Syntax Rules'. This probably says something about the <slash> <asterisk> and <asterisk> <slash> needing to be adjacent characters rather than adjacent tokens.

<bracketed comment contents> ::= [ { <comment character> | <separator> }... ]

<newline> ::= !! See the Syntax Rules.

There was a surprising amount of movement of keywords between the reserved and non-reserved word classes between SQL-99 and SQL-2003-2 FCD and again between SQL 2003-2 FCD and SQL 2003-2 IS. There is also room to think that much of the host language support moved out of Part 2 (SQL/Foundation).

Top

5.3 <literal> (p143)

<character string literal>    ::=
         [ <introducer> <character set specification> ]
         <quote> [ <character representation> ... ] <quote>
         [ { <separator> <quote> [ <character representation> ... ] <quote> }... ]

<nonquote character> ::= !! See the Syntax Rules.

The <quote symbol> rule consists of two immediately adjacent <quote> marks with no spaces. As usual, this would be best handled in the lexical analyzer, not in the grammar.

<national character string literal>    ::=
         N <quote> [ <character representation> ... ] <quote>
         [ { <separator> <quote> [ <character representation> ... ] <quote> }... ]

<Unicode character string literal>    ::=
         [ <introducer> <character set specification> ]
         U <ampersand> <quote> [ <Unicode representation> ... ] <quote>
         [ { <separator> <quote> [ <Unicode representation> ... ] <quote> }... ]
         [ ESCAPE <escape character> ]

<binary string literal>    ::=
         X <quote> [ { <hexit> <hexit> }... ] <quote>
         [ { <separator> <quote> [ { <hexit> <hexit> }... ] <quote> }... ]
         [ ESCAPE <escape character> ]

<hexit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f

<unsigned integer> ::= <digit> ...

<timestamp literal> ::= TIMESTAMP <timestamp string>

<interval literal> ::= INTERVAL [ <sign> ] <interval string> <interval qualifier>

<unquoted time string> ::= <time value> [ <time zone interval> ]

<unquoted interval string> ::= [ <sign> ] { <year-month literal> | <day-time literal> }

<year-month literal> ::= <years value> | [ <years value> <minus sign> ] <months value>

<day-time literal> ::= <day-time interval> | <time interval>

<day-time interval> ::=
<days value> [ <space> <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ] ]

<seconds value> ::= <seconds integer value> [ <period> [ <seconds fraction> ] ]

<boolean literal> ::= TRUE | FALSE | UNKNOWN

Top

5.4 Names and identifiers (p151)

<SQL language identifier> ::=
<SQL language identifier start> [ { <underscore> | <SQL language identifier part> }... ]

<local or schema qualifier> ::= <schema name> | MODULE

<SQL-client module name> ::= <identifier>

<local qualifier> ::= MODULE

<user-defined type name> ::= <schema qualified type name>

<schema-resolved user-defined type name> ::= <user-defined type name>

<SQL-server name> ::= <simple value specification>

<scope option> ::= GLOBAL | LOCAL

Top

6 Scalar expressions

6.25 <value expression> (p236)

Specify a value.

<user-defined type value expression> ::= <value expression primary>

6.26 <numeric value expression> (p240)

Specify a numeric value.

6.27 <numeric value function> (p242)

Specify a function yielding a value of type numeric.

<string position expression> ::=
POSITION <left paren> <string value expression> IN <string value expression> [ USING <char length units> ] <right paren>

<blob position expression> ::=
POSITION <left paren> <blob value expression> IN <blob value expression> <right paren>

<char length expression> ::=
{ CHAR_LENGTH | CHARACTER_LENGTH } <left paren> <string value expression> [ USING <char length units> ] <right paren>

<octet length expression> ::= OCTET_LENGTH <left paren> <string value expression> <right paren>

<extract expression> ::= EXTRACT <left paren> <extract field> FROM <extract source> <right paren>

<time zone field> ::= TIMEZONE_HOUR | TIMEZONE_MINUTE

<cardinality expression> ::= CARDINALITY <left paren> <collection value expression> <right paren>

<power function> ::= POWER <left paren> <numeric value expression base> <comma> <numeric value expression exponent> <right paren>

<floor function> ::= FLOOR <left paren> <numeric value expression> <right paren>

<ceiling function> ::= { CEIL | CEILING } <left paren> <numeric value expression> <right paren>

<width bucket function> ::= WIDTH_BUCKET <left paren> <width bucket operand> <comma> <width bucket bound 1> <comma> <width bucket bound 2> <comma> <width bucket count> <right paren>

6.28 <string value expression> (p251)

Specify a character string value or a binary string value.

<character factor> ::= <character primary> [ <collate clause> ]

6.29 <string value function> (p255)

Specify a function yielding a value of type character string or binary string.

<character substring function>    ::=
         SUBSTRING <left paren> <character value expression> FROM <start position>
         [ FOR <string length> ] [ USING <char length units> ] <right paren>

<regular expression substring function>    ::=
         SUBSTRING <left paren> <character value expression>
         SIMILAR <character value expression> ESCAPE <escape character> <right paren>

<fold> ::= { UPPER | LOWER } <left paren> <character value expression> <right paren>

<transcoding> ::= CONVERT <left paren> <character value expression> USING <transcoding name> <right paren>

<character transliteration> ::= TRANSLATE <left paren> <character value expression> USING <transliteration name> <right paren>

<trim specification> ::= LEADING | TRAILING | BOTH

<character overlay function>    ::=
         OVERLAY <left paren> <character value expression> PLACING <character value expression>
         FROM <start position> [ FOR <string length> ] [ USING <char length units> ] <right paren>

<normalize function> ::= NORMALIZE <left paren> <character value expression> <right paren>

<specific type method> ::= <user-defined type value expression> <period> SPECIFICTYPE

<blob substring function> ::=
SUBSTRING <left paren> <blob value expression> FROM <start position> [ FOR <string length> ] <right paren>

<blob overlay function>    ::=
         OVERLAY <left paren> <blob value expression> PLACING <blob value expression>
         FROM <start position> [ FOR <string length> ] <right paren>

6.30 <datetime value expression> (p266)

Specify a datetime value.

<datetime factor> ::= <datetime primary> [ <time zone> ]

<time zone specifier> ::= LOCAL | TIME ZONE <interval primary>

6.31 <datetime value function> (p269)

Specify a function yielding a value of type datetime.

<current date value function> ::= CURRENT_DATE

<current time value function> ::= CURRENT_TIME [ <left paren> <time precision> <right paren> ]

<current local time value function> ::= LOCALTIME [ <left paren> <time precision> <right paren> ]

<current timestamp value function> ::= CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]

<current local timestamp value function> ::= LOCALTIMESTAMP [ <left paren> <timestamp precision> <right paren> ]

6.32 <interval value expression> (p271)

Specify an interval value.

6.33 <interval value function> (p276)

6.34 <boolean value expression> (p277)

<boolean test> ::= <boolean primary> [ IS [ NOT ] <truth value> ]

<truth value> ::= TRUE | FALSE | UNKNOWN

6.35 <array value expression> (p284)

6.36 <array value constructor> (p284)

<array value constructor by enumeration> ::=
ARRAY <left bracket or trigraph> <array element list> <right bracket or trigraph>

<array element list> ::= <array element> [ { <comma> <array element> }... ]

<array value constructor by query> ::=
ARRAY <left paren> <query expression> [ <order by clause> ] <right paren>

6.37 <multiset value expression> (p286)

<multiset value expression>    ::=
         <multiset term>
     |     <multiset value expression> MULTISET UNION [ ALL | DISTINCT ] <multiset term>
     |     <multiset value expression> MULTISET EXCEPT [ ALL | DISTINCT ] <multiset term>

<multiset term>    ::=
         <multiset primary>
     |     <multiset term> MULTISET INTERSECT [ ALL | DISTINCT ] <multiset primary>

6.38 <multiset value function> (p289)

6.39 <multiset value constructor> (p290)

<multiset value constructor by enumeration> ::= MULTISET <left bracket or trigraph> <multiset element list> <right bracket or trigraph>

<multiset element list> ::= <multiset element> [ { <comma> <multiset element> } ]

<multiset value constructor by query> ::= MULTISET <left paren> <query expression> <right paren>

<table value constructor by query> ::= TABLE <left paren> <query expression> <right paren>

Top

7 Query expressions

7.1 <row value constructor> (p293)

Specify a value or list of values to be constructed into a row or partial row.

<row value constructor element list> ::=
<row value constructor element> [ { <comma> <row value constructor element> }... ]

<contextually typed row value constructor element list>    ::=
         <contextually typed row value constructor element>
         [ { <comma> <contextually typed row value constructor element> }... ]

7.2 <row value expression> (p296)

Specify a row value.

7.3 <table value constructor> (p298)

Specify a set of <row value expression>s to be constructed into a table.

<table value constructor> ::= VALUES <row value expression list>

<row value expression list> ::= <table row value expression> [ { <comma> <table row value expression> }... ]

<contextually typed table value constructor> ::= VALUES <contextually typed row value expression list>

<contextually typed row value expression list> ::= <contextually typed row value expression> [ { <comma> <contextually typed row value expression> }... ]

7.4 <table expression> (p300)

Specify a table or a grouped table.

<table expression>    ::=
         <from clause>
         [ <where clause> ]
         [ <group by clause> ]
         [ <having clause> ]
         [ <window clause> ]

7.5 <from clause> (p301)

Specify a table derived from one or more tables.

<table reference list> ::= <table reference> [ { <comma> <table reference> }... ]

7.6 <table reference> (p303)

Reference a table.

<table reference> ::= <table primary or joined table> [ <sample clause> ]

<sample clause> ::=
TABLESAMPLE <sample method> <left paren> <sample percentage> <right paren> [ <repeatable clause> ]

<sample method> ::= BERNOULLI | SYSTEM

<repeatable clause> ::= REPEATABLE <left paren> <repeat argument> <right paren>

<lateral derived table> ::= LATERAL <table subquery>

<collection derived table> ::= UNNEST <left paren> <collection value expression> <right paren> [ WITH ORDINALITY ]

<table function derived table> ::= TABLE <left paren> <collection value expression> <right paren>

<column name list> ::= <column name> [ { <comma> <column name> }... ]

7.7 <joined table> (p312)

Specify a table derived from a Cartesian product, inner or outer join, or union join.

<cross join> ::= <table reference> CROSS JOIN <table primary>

<natural join> ::= <table reference> NATURAL [ <join type> ] JOIN <table primary>

<union join> ::= <table reference> UNION JOIN <table primary>

<named columns join> ::= USING <left paren> <join column list> <right paren>

<join type> ::= INNER | <outer join type> [ OUTER ]

<outer join type> ::= LEFT | RIGHT | FULL

7.8 <where clause> (p319)

Specify a table derived by the application of a <search condition> to the result of the preceding <from clause>.

<where clause> ::= WHERE <search condition>

7.9 <group by clause> (p320)

Specify a grouped table derived by the application of the <group by clause> to the result of the previously specified clause.

<group by clause> ::= GROUP BY [ <set quantifier> ] <grouping element list>

<grouping element list> ::= <grouping element> [ { <comma> <grouping element> }... ]

<grouping column reference> ::= <column reference> [ <collate clause> ]

<grouping column reference list> ::= <grouping column reference> [ { <comma> <grouping column reference> }... ]

<rollup list> ::= ROLLUP <left paren> <ordinary grouping set list> <right paren>

<ordinary grouping set list> ::= <ordinary grouping set> [ { <comma> <ordinary grouping set> }... ]

<grouping sets specification> ::= GROUPING SETS <left paren> <grouping set list> <right paren>

<grouping set list> ::= <grouping set> [ { <comma> <grouping set> }... ]

7.10 <having clause> (p329)

Specify a grouped table derived by the elimination of groups that do not satisfy a <search condition>.

<having clause> ::= HAVING <search condition>

7.11 <window clause> (p331)

Specify one or more window definitions.

<window clause> ::= WINDOW <window definition list>

<window definition list> ::= <window definition> [ { <comma> <window definition> }... ]

<window specification details> ::=
[ <existing window name> ] [ <window partition clause> ] [ <window order clause> ] [ <window frame clause> ]

<window partition clause> ::= PARTITION BY <window partition column reference list>

<window partition column reference list> ::= <window partition column reference> [ { <comma> <window partition column reference> }... ]

<window partition column reference> ::= <column reference> [ <collate clause> ]

<window order clause> ::= ORDER BY <sort specification list>

<window frame clause> ::= <window frame units> <window frame extent> [ <window frame exclusion> ]

<window frame units> ::= ROWS | RANGE

<window frame start> ::= UNBOUNDED PRECEDING | <window frame preceding> | CURRENT ROW

<window frame preceding> ::= <unsigned value specification> PRECEDING

<window frame between> ::= BETWEEN <window frame bound 1> AND <window frame bound 2>

<window frame bound>    ::=
         <window frame start>
     |     UNBOUNDED FOLLOWING
     |     <window frame following>

<window frame following> ::= <unsigned value specification> FOLLOWING

<window frame exclusion>    ::=
         EXCLUDE CURRENT ROW
     |     EXCLUDE GROUP
     |     EXCLUDE TIES
     |     EXCLUDE NO OTHERS

7.12 <query specification> (p341)

Specify a table derived from the result of a <table expression>.

<query specification> ::= SELECT [ <set quantifier> ] <select list> <table expression>

<select list> ::= <asterisk> | <select sublist> [ { <comma> <select sublist> }... ]

<asterisked identifier chain> ::= <asterisked identifier> [ { <period> <asterisked identifier> }... ]

<derived column> ::= <value expression> [ <as clause> ]

<all fields reference> ::= <value expression primary> <period> <asterisk> [ AS <left paren> <all fields column name list> <right paren> ]

7.13 <query expression> (p350)

Specify a table.

<with clause> ::= WITH [ RECURSIVE ] <with list>

<with list> ::= <with list element> [ { <comma> <with list element> }... ]

<with list element>    ::=
         <query name> [ <left paren> <with column list> <right paren> ]
         AS <left paren> <query expression> <right paren> [ <search or cycle clause> ]

<non-join query expression>    ::=
         <non-join query term>
     |     <query expression body> UNION [ ALL | DISTINCT ] [ <corresponding spec> ] <query term>
     |     <query expression body> EXCEPT [ ALL | DISTINCT ] [ <corresponding spec> ] <query term>

<non-join query term>    ::=
         <non-join query primary>
     |     <query term> INTERSECT [ ALL | DISTINCT ] [ <corresponding spec> ] <query primary>

<non-join query primary> ::= <simple table> | <left paren> <non-join query expression> <right paren>

<explicit table> ::= TABLE <table or query name>

<corresponding spec> ::= CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]

7.14 <search or cycle clause> (p363)

Specify the generation of ordering and cycle detection information in the result of recursive query expressions.

<search clause> ::= SEARCH <recursive search order> SET <sequence column>

<recursive search order>    ::=
         DEPTH FIRST BY <sort specification list>
     |     BREADTH FIRST BY <sort specification list>

<cycle clause>    ::=
         CYCLE <cycle column list>
         SET <cycle mark column> TO <cycle mark value>
         DEFAULT <non-cycle mark value>
         USING <path column>

<cycle column list> ::= <cycle column> [ { <comma> <cycle column> }... ]

<non-cycle mark value> ::= <value expression>

7.15 <subquery> (p368)

Specify a scalar value, a row, or a table derived from a <query expression>.

Top

8 Predicates

8.1 <predicate> (p371)

Specify a condition that can be evaluated to give a boolean value.

8.2 <comparison predicate> (p373)

Specify a comparison of two row values.

8.3 <between predicate> (p380)

Specify a range comparison.

<between predicate part 2> ::= [ NOT ] BETWEEN [ ASYMMETRIC | SYMMETRIC ] <row value predicand> AND <row value predicand>

8.4 <in predicate> (p381)

Specify a quantified comparison.

<in value list> ::= <row value expression> [ { <comma> <row value expression> }... ]

8.5 <like predicate> (p383)

Specify a pattern-match comparison.

<character like predicate part 2> ::= [ NOT ] LIKE <character pattern> [ ESCAPE <escape character> ]

<octet like predicate part 2> ::= [ NOT ] LIKE <octet pattern> [ ESCAPE <escape octet> ]

8.6 <similar predicate> (p389)

Specify a character string similarity by means of a regular expression.

<upper limit> ::= <comma> [ <high value> ]

<non-escaped character> ::= !! See the Syntax Rules.

<escaped character> ::= !! See the Syntax Rules.

8.7 <null predicate> (p395)

Specify a test for a null value.

<null predicate part 2> ::= IS [ NOT ] NULL

8.8 <quantified comparison predicate> (p397)

Specify a quantified comparison.

<all> ::= ALL

<some> ::= SOME | ANY

8.9 <exists predicate> (p399)

Specify a test for a non-empty set.

<exists predicate> ::= EXISTS <table subquery>

8.10 <unique predicate> (p400)

Specify a test for the absence of duplicate rows

<unique predicate> ::= UNIQUE <table subquery>

8.11 <normalized predicate> (p401)

Determine whether a character string value is normalized.

<normalized predicate> ::= <string value expression> IS [ NOT ] NORMALIZED

8.12 <match predicate> (p402)

Specify a test for matching rows.

<match predicate part 2> ::= MATCH [ UNIQUE ] [ SIMPLE | PARTIAL | FULL ] <table subquery>

8.13 <overlaps predicate> (p405)

Specify a test for an overlap between two datetime periods.

<overlaps predicate part 2> ::= OVERLAPS <row value predicand 2>

8.14 <distinct predicate> (p407)

Specify a test of whether two row values are distinct

<distinct predicate part 2> ::= IS DISTINCT FROM <row value predicand 4>

8.15 <member predicate> (p409)

Specify a test of whether a value is a member of a multiset.

<member predicate part 2> ::= [ NOT ] MEMBER [ OF ] <multiset value expression>

8.16 <submultiset predicate> (p411)

Specify a test of whether a multiset is a submultiset of another multiset.

<submultiset predicate part 2> ::= [ NOT ] SUBMULTISET [ OF ] <multiset value expression>

8.17 <set predicate> (p413)

Specify a test of whether a multiset is a set (that is, does not contain any duplicates).

<set predicate part 2> ::= IS [ NOT ] A SET

8.18 <type predicate> (p414)

Specify a type test.

<type list> ::= <user-defined type specification> [ { <comma> <user-defined type specification> }... ]

<user-defined type specification>    ::=
         <inclusive user-defined type specification>
     |     <exclusive user-defined type specification>

8.19 <search condition> (p416)

Specify a condition that is True , False , or Unknown , depending on the value of a <boolean value expression>.

Top

9 Additional common rules

9.1 Retrieval assignment (p417)

9.2 Store assignment (p422)

9.3 Data types of results of aggregations (p427)

9.4 Subject routine determination (p430)

9.5 Type precedence list determination (p431)

9.6 Host parameter mode determination (p434)

9.7 Type name determination (p436)

9.8 Determination of identical values (p438)

9.9 Equality operations (p440)

9.10 Grouping operations (p443)

9.11 Multiset element grouping operations (p445)

9.12 Ordering operations (p447)

9.13 Collation determination (p449)

9.14 Execution of array-returning functions (p450)

9.15 Execution of multiset-returning functions (p453)

9.16 Data type identity (p454)

9.17 Determination of a from-sql function (p456)

9.18 Determination of a from-sql function for an overriding method (p457)

9.19 Determination of a to-sql function (p458)

9.20 Determination of a to-sql function for an overriding method (p459)

9.21 Generation of the next value of a sequence generator (p460)

9.22 Creation of a sequence generator (p461)

9.23 Altering a sequence generator (p463)

Top

10 Additional common elements

10.1 <interval qualifier> (p465)

Specify the precision of an interval data type.

<start field> ::= <non-second primary datetime field> [ <left paren> <interval leading field precision> <right paren> ]

<end field>    ::=
         <non-second primary datetime field>
     |     SECOND [ <left paren> <interval fractional seconds precision> <right paren> ]

<single datetime field>    ::=
         <non-second primary datetime field> [ <left paren> <interval leading field precision> <right paren> ]
     |     SECOND [ <left paren> <interval leading field precision> [ <comma> <interval fractional seconds precision> ] <right paren> ]

<primary datetime field>    ::=
         <non-second primary datetime field>
     |     SECOND

<non-second primary datetime field> ::= YEAR | MONTH | DAY | HOUR | MINUTE

10.2 <language clause> (p469)

Specify a standard programming language.

<language clause> ::= LANGUAGE <language name>

Table 14 -- Standard programming languages

Language keyword	Relevant standard
ADA	ISO/IEC 8652
C	ISO/IEC 9899
COBOL	ISO 1989
FORTRAN	ISO 1539
MUMPS	ISO/IEC 11756
PASCAL	ISO/IEC 7185 and ISO/IEC 10206
PLI	ISO 6160
SQL	ISO/IEC 9075

10.3 <path specification> (p471)

Specify an order for searching for an SQL-invoked routine.

<schema name list> ::= <schema name> [ { <comma> <schema name> }... ]

10.4 <routine invocation> (p472)

Invoke an SQL-invoked routine.

10.5 <character set specification> (p495)

Identify a character set.

<implementation-defined character set name> ::= <character set name>

<user-defined character set name> ::= <character set name>

10.6 <specific routine designator> (p497)

Specify an SQL-invoked routine.

<specific routine designator>    ::=
         SPECIFIC <routine type> <specific name>
             |     <routine type> <member name>
         [ FOR <schema-resolved user-defined type name> ]

<member name> ::= <member name alternatives> [ <data type list> ]

10.7 <collate clause> (p500)

Specify a default collating sequence.

<collate clause> ::= COLLATE <collation name>

10.8 <constraint name definition> and <constraint characteristics> (p501)

Specify the name of a constraint and its characteristics.

<constraint name definition> ::= CONSTRAINT <constraint name>

<constraint characteristics>    ::=
         <constraint check time> [ [ NOT ] DEFERRABLE ]
     |     [ NOT ] DEFERRABLE [ <constraint check time> ]

<constraint check time> ::= INITIALLY DEFERRED | INITIALLY IMMEDIATE

10.9 <aggregate function> (p503)

Specify a value computed from a collection of rows.

<aggregate function>    ::=
         COUNT <left paren> <asterisk> <right paren> [ <filter clause> ]
     |     <general set function> [ <filter clause> ]
     |     <binary set function> [ <filter clause> ]
     |     <ordered set function> [ <filter clause> ]

<set quantifier> ::= DISTINCT | ALL

<filter clause> ::= FILTER <left paren> WHERE <search condition> <right paren>

<within group specification> ::= WITHIN GROUP <left paren> ORDER BY <sort specification list> <right paren>

<hypothetical set function value expression list> ::= <value expression> [ { <comma> <value expression> }... ]

<inverse distribution function type> ::= PERCENTILE_CONT | PERCENTILE_DISC

10.10 <sort specification list> (p515)

Specify a sort order.

<sort specification list> ::= <sort specification> [ { <comma> <sort specification> }... ]

<sort specification> ::= <sort key> [ <ordering specification> ] [ <null ordering> ]

<ordering specification> ::= ASC | DESC

<null ordering> ::= NULLS FIRST | NULLS LAST

Top

11 Schema definition and manipulation

11.1 <schema definition> (p517)

Define a schema.

<schema definition> ::= CREATE SCHEMA <schema name clause> [ <schema character set or path> ] [ <schema element> ... ]

<schema name clause>    ::=
         <schema name>
     |     AUTHORIZATION <schema authorization identifier>
     |     <schema name> AUTHORIZATION <schema authorization identifier>

<schema character set specification> ::= DEFAULT CHARACTER SET <character set specification>

11.2 <drop schema statement> (p520)

Destroy a schema.

<drop schema statement> ::= DROP SCHEMA <schema name> <drop behavior>

<drop behavior> ::= CASCADE | RESTRICT

11.3 <table definition> (p523)

Define a persistent base table, a created local temporary table, or a global temporary table.

<table definition>    ::=
         CREATE [ <table scope> ] TABLE <table name> <table contents source>
         [ ON COMMIT <table commit action> ROWS ]

<table scope> ::= <global or local> TEMPORARY

<global or local> ::= GLOBAL | LOCAL

<table commit action> ::= PRESERVE | DELETE

<self-referencing column specification> ::= REF IS <self-referencing column name> <reference generation>

<reference generation> ::= SYSTEM GENERATED | USER GENERATED | DERIVED

<self-referencing column name> ::= <column name>

<column options> ::= <column name> WITH OPTIONS <column option list>

<column option list> ::= [ <scope clause> ] [ <default clause> ] [ <column constraint definition> ... ]

<subtable clause> ::= UNDER <supertable clause>

<like clause> ::= LIKE <table name> [ <like options> ]

<identity option> ::= INCLUDING IDENTITY | EXCLUDING IDENTITY

<column default option> ::= INCLUDING DEFAULTS | EXCLUDING DEFAULTS

<with or without data> ::= WITH NO DATA | WITH DATA

11.4 <column definition> (p534)

Define a column of a base table.

<column definition>    ::=
         <column name> [ <data type> | <domain name> ] [ <reference scope check> ]
         [ <default clause> | <identity column specification> | <generation clause> ]
         [ <column constraint definition> ... ] [ <collate clause> ]

<column constraint definition> ::= [ <constraint name definition> ] <column constraint> [ <constraint characteristics> ]

<reference scope check> ::= REFERENCES ARE [ NOT ] CHECKED [ ON DELETE <reference scope check action> ]

<identity column specification>    ::=
         GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY
         [ <left paren> <common sequence generator options> <right paren> ]

<generation rule> ::= GENERATED ALWAYS

11.5 <default clause> (p539)

Specify the default for a column, domain, or attribute.

<default clause> ::= DEFAULT <default option>

11.6 <table constraint definition> (p543)

Specify an integrity constraint.

<table constraint definition> ::= [ <constraint name definition> ] <table constraint> [ <constraint characteristics> ]

11.7 <unique constraint definition> (p545)

Specify a uniqueness constraint for a table.

<unique constraint definition>    ::=
         <unique specification> <left paren> <unique column list> <right paren>
     |     UNIQUE ( VALUE )

<unique specification> ::= UNIQUE | PRIMARY KEY

11.8 <referential constraint definition> (p547)

Specify a referential constraint.

<referential constraint definition> ::= FOREIGN KEY <left paren> <referencing columns> <right paren> <references specification>

<references specification> ::= REFERENCES <referenced table and columns> [ MATCH <match type> ] [ <referential triggered action> ]

<match type> ::= FULL | PARTIAL | SIMPLE

<referenced table and columns> ::= <table name> [ <left paren> <reference column list> <right paren> ]

<referential triggered action> ::= <update rule> [ <delete rule> ] | <delete rule> [ <update rule> ]

<update rule> ::= ON UPDATE <referential action>

<delete rule> ::= ON DELETE <referential action>

<referential action> ::= CASCADE | SET NULL | SET DEFAULT | RESTRICT | NO ACTION

11.9 <check constraint definition> (p567)

Specify a condition for the SQL-data.

<check constraint definition> ::= CHECK <left paren> <search condition> <right paren>

11.10 <alter table statement> (p569)

Change the definition of a table.

<alter table statement> ::= ALTER TABLE <table name> <alter table action>

11.11 <add column definition> (p570)

Add a column to a table.

<add column definition> ::= ADD [ COLUMN ] <column definition>

11.12 <alter column definition> (p572)

Change a column and its definition.

<alter column definition> ::= ALTER [ COLUMN ] <column name> <alter column action>

11.13 <set column default clause> (p573)

Set the default clause for a column.

11.14 <drop column default clause> (p574)

Drop the default clause from a column.

<drop column default clause> ::= DROP DEFAULT

11.15 <add column scope clause> (p575)

Add a non-empty scope for an existing column of data type REF in a base table.

11.16 <drop column scope clause> (p576)

Drop the scope from an existing column of data type REF in a base table.

<drop column scope clause> ::= DROP SCOPE <drop behavior>

11.17 <alter identity column specification> (p578)

Change the options specified for an identity column.

<alter identity column specification> ::= <alter identity column option> ...

11.18 <drop column definition> (p579)

Destroy a column of a base table.

<drop column definition> ::= DROP [ COLUMN ] <column name> <drop behavior>

11.19 <add table constraint definition> (p581)

Add a constraint to a table.

11.20 <drop table constraint definition> (p582)

Destroy a constraint on a table.

<drop table constraint definition> ::= DROP CONSTRAINT <constraint name> <drop behavior>

11.21 <drop table statement> (p585)

Destroy a table.

<drop table statement> ::= DROP TABLE <table name> <drop behavior>

11.22 <view definition> (p588)

Define a viewed table.

<view definition>    ::=
         CREATE [ RECURSIVE ] VIEW <table name> <view specification> AS <query expression>
         [ WITH [ <levels clause> ] CHECK OPTION ]

<regular view specification> ::= [ <left paren> <view column list> <right paren> ]

<referenceable view specification> ::= OF <path-resolved user-defined type name> [ <subview clause> ] [ <view element list> ]

<subview clause> ::= UNDER <table name>

<view column option> ::= <column name> WITH OPTIONS <scope clause>

<levels clause> ::= CASCADED | LOCAL

11.23 <drop view statement> (p598)

Destroy a view.

11.24 <domain definition> (p601)

Define a domain.

<domain definition>    ::=
         CREATE DOMAIN <domain name> [ AS ] <data type>
         [ <default clause> ] [ <domain constraint> ... ] [ <collate clause> ]

<domain constraint> ::= [ <constraint name definition> ] <check constraint definition> [ <constraint characteristics> ]

11.25 <alter domain statement> (p603)

Change a domain and its definition.

<alter domain statement> ::= ALTER DOMAIN <domain name> <alter domain action>

11.26 <set domain default clause> (p604)

Set the default value in a domain.

11.27 <drop domain default clause> (p605)

Remove the default clause of a domain.

<drop domain default clause> ::= DROP DEFAULT

11.28 <add domain constraint definition> (p606)

Add a constraint to a domain.

11.29 <drop domain constraint definition> (p607)

Destroy a constraint on a domain.

<drop domain constraint definition> ::= DROP CONSTRAINT <constraint name>

11.30 <drop domain statement> (p608)

Destroy a domain.

<drop domain statement> ::= DROP DOMAIN <domain name> <drop behavior>

11.31 <character set definition> (p610)

Define a character set.

<character set definition> ::=
CREATE CHARACTER SET <character set name> [ AS ] <character set source> [ <collate clause> ]

11.32 <drop character set statement> (p612)

Destroy a character set.

<drop character set statement> ::= DROP CHARACTER SET <character set name>

11.33 <collation definition> (p614)

Define a collating sequence.

<collation definition>    ::=
         CREATE COLLATION <collation name> FOR <character set specification>
         FROM <existing collation name> [ <pad characteristic> ]

<pad characteristic> ::= NO PAD | PAD SPACE

11.34 <drop collation statement> (p616)

Destroy a collating sequence.

<drop collation statement> ::= DROP COLLATION <collation name> <drop behavior>

11.35 <transliteration definition> (p618)

Define a character transliteration.

<transliteration definition>    ::=
         CREATE TRANSLATION <transliteration name> FOR <source character set specification>
         TO <target character set specification> FROM <transliteration source>

11.36 <drop transliteration statement> (p621)

Destroy a character transliteration.

<drop transliteration statement> ::= DROP TRANSLATION <transliteration name>

11.37 <assertion definition> (p623)

Specify an integrity constraint.

<assertion definition> ::=
CREATE ASSERTION <constraint name> CHECK <left paren> <search condition> <right paren> [ <constraint characteristics> ]

11.38 <drop assertion statement> (p625)

Destroy an assertion.

<drop assertion statement> ::= DROP ASSERTION <constraint name>

11.39 <trigger definition> (p627)

Define triggered SQL-statements.

<trigger definition>    ::=
         CREATE TRIGGER <trigger name> <trigger action time> <trigger event>
         ON <table name> [ REFERENCING <old or new values alias list> ]
         <triggered action>

<trigger action time> ::= BEFORE | AFTER

<trigger event> ::= INSERT | DELETE | UPDATE [ OF <trigger column list> ]

<triggered action>    ::=
         [ FOR EACH { ROW | STATEMENT } ]
         [ WHEN <left paren> <search condition> <right paren> ]
         <triggered SQL statement>

<triggered SQL statement>    ::=
         <SQL procedure statement>
     |     BEGIN ATOMIC { <SQL procedure statement> <semicolon> }... END

<old or new values alias list> ::= <old or new values alias> ...

<old or new values alias>    ::=
         OLD [ ROW ] [ AS ] <old values correlation name>
     |     NEW [ ROW ] [ AS ] <new values correlation name>
     |     OLD TABLE [ AS ] <old values table alias>
     |     NEW TABLE [ AS ] <new values table alias>

11.40 <drop trigger statement> (p631)

Destroy a trigger.

<drop trigger statement> ::= DROP TRIGGER <trigger name>

11.41 <user-defined type definition> (p632)

Define a user-defined type.

<user-defined type definition> ::= CREATE TYPE <user-defined type body>

<user-defined type body>    ::=
         <schema-resolved user-defined type name> [ <subtype clause> ]
         [ AS <representation> ] [ <user-defined type option list> ] [ <method specification list> ]

<user-defined type option list> ::= <user-defined type option> [ <user-defined type option> ... ]

<user-defined type option>    ::=
         <instantiable clause>
     |     <finality>
     |     <reference type specification>
     |     <ref cast option>
     |     <cast option>

<subtype clause> ::=
UNDER <supertype name>

<instantiable clause> ::= INSTANTIABLE | NOT INSTANTIABLE

<finality> ::= FINAL | NOT FINAL

<user-defined representation> ::= REF USING <predefined type>

<system-generated representation> ::= REF IS SYSTEM GENERATED

<ref cast option> ::= [ <cast to ref> ] [ <cast to type> ]

<cast to ref> ::= CAST <left paren> SOURCE AS REF <right paren> WITH <cast to ref identifier>

<cast to type> ::= CAST <left paren> REF AS SOURCE <right paren> WITH <cast to type identifier>

<cast option> ::= [ <cast to distinct> ] [ <cast to source> ]

<cast to distinct>    ::=
         CAST <left paren> SOURCE AS DISTINCT <right paren>
         WITH <cast to distinct identifier>

<cast to source>    ::=
         CAST <left paren> DISTINCT AS SOURCE <right paren>
         WITH <cast to source identifier>

<method specification list> ::= <method specification> [ { <comma> <method specification> }... ]

<original method specification> ::=
<partial method specification> [ SELF AS RESULT ] [ SELF AS LOCATOR ] [ <method characteristics> ]

<overriding method specification> ::= OVERRIDING <partial method specification>

<partial method specification>    ::=
         [ INSTANCE | STATIC | CONSTRUCTOR ] METHOD <method name> <SQL parameter declaration list>
         <returns clause> [ SPECIFIC <specific method name> ]

<method characteristics> ::= <method characteristic> ...

11.42 <attribute definition> (p648)

Define an attribute of a structured type.

<attribute definition> ::=
<attribute name> <data type> [ <reference scope check> ] [ <attribute default> ] [ <collate clause> ]

11.43 <alter type statement> (p650)

Change the definition of a user-defined type.

<alter type statement> ::= ALTER TYPE <schema-resolved user-defined type name> <alter type action>

11.44 <add attribute definition> (p651)

Add an attribute to a user-defined type.

<add attribute definition> ::= ADD ATTRIBUTE <attribute definition>

11.45 <drop attribute definition> (p653)

Destroy an attribute of a user-defined type.

<drop attribute definition> ::= DROP ATTRIBUTE <attribute name> RESTRICT

11.46 <add original method specification> (p655)

Add an original method specification to a user-defined type.

11.47 <add overriding method specification> (p661)

Add an overriding method specification to a user-defined type.

11.48 <drop method specification> (p666)

Remove a method specification from a user-defined type.

<drop method specification> ::= DROP <specific method specification designator> RESTRICT

<specific method specification designator> ::= [ INSTANCE | STATIC | CONSTRUCTOR ] METHOD <method name> <data type list>

11.49 <drop data type statement> (p670)

Destroy a user-defined type.

11.50 <SQL-invoked routine> (p673)

Define an SQL-invoked routine.

<SQL-invoked routine> ::= <schema routine>

<schema procedure> ::= CREATE <SQL-invoked procedure>

<schema function> ::= CREATE <SQL-invoked function>

<SQL-invoked procedure> ::=
PROCEDURE <schema qualified routine name> <SQL parameter declaration list> <routine characteristics> <routine body>

<SQL-invoked function> ::=
{ <function specification> | <method specification designator> } <routine body>

<SQL parameter declaration> ::= [ <parameter mode> ] [ <SQL parameter name> ] <parameter type> [ RESULT ]

<parameter mode> ::= IN | OUT | INOUT

<parameter type> ::= <data type> [ <locator indication> ]

<locator indication> ::= AS LOCATOR

<function specification>    ::=
         FUNCTION <schema qualified routine name>
         <SQL parameter declaration list> <returns clause> <routine characteristics> [ <dispatch clause> ]

<method specification designator>    ::=
         SPECIFIC METHOD <specific method name>
     |     [ INSTANCE | STATIC | CONSTRUCTOR ] METHOD <method name> <SQL parameter declaration list>
         [ <returns clause> ] FOR <schema-resolved user-defined type name>

<routine characteristics> ::= [ <routine characteristic> ... ]

<savepoint level indication> ::= NEW SAVEPOINT LEVEL | OLD SAVEPOINT LEVEL

<dynamic result sets characteristic> ::= DYNAMIC RESULT SETS <maximum dynamic result sets>

<parameter style clause> ::= PARAMETER STYLE <parameter style>

<dispatch clause> ::= STATIC DISPATCH

<returns clause> ::= RETURNS <returns type>

<returns table type> ::= TABLE <table function column list>

<result cast from type> ::= <data type> [ <locator indication> ]

<returns data type> ::= <data type> [ <locator indication> ]

<rights clause> ::= SQL SECURITY INVOKER | SQL SECURITY DEFINER

<external body reference>    ::=
         EXTERNAL [ NAME <external routine name> ] [ <parameter style clause> ]
         [ <transform group specification> ] [ <external security clause> ]

<external security clause>    ::=
         EXTERNAL SECURITY DEFINER
     |     EXTERNAL SECURITY INVOKER
     |     EXTERNAL SECURITY IMPLEMENTATION DEFINED

<parameter style> ::= SQL | GENERAL

<deterministic characteristic> ::= DETERMINISTIC | NOT DETERMINISTIC

<SQL-data access indication>    ::=
         NO SQL
     |     CONTAINS SQL
     |     READS SQL DATA
     |     MODIFIES SQL DATA

<null-call clause>    ::=
         RETURNS NULL ON NULL INPUT
     |     CALLED ON NULL INPUT

<transform group specification> ::= TRANSFORM GROUP { <single group specification> | <multiple group specification> }

<multiple group specification> ::= <group specification> [ { <comma> <group specification> }... ]

11.51 <alter routine statement> (p698)

Alter a characteristic of an SQL-invoked routine.

<alter routine statement> ::= ALTER <specific routine designator> <alter routine characteristics> <alter routine behavior>

<alter routine characteristics> ::= <alter routine characteristic> ...

<alter routine behavior> ::= RESTRICT

11.52 <drop routine statement> (p701)

Destroy an SQL-invoked routine.

11.53 <user-defined cast definition> (p703)

Define a user-defined cast.

<user-defined cast definition>    ::=
         CREATE CAST <left paren> <source data type> AS <target data type> <right paren>
         WITH <cast function> [ AS ASSIGNMENT ]

11.54 <drop user-defined cast statement> (p705)

Destroy a user-defined cast.

11.55 <user-defined ordering definition> (p707)

Define a user-defined ordering for a user-defined type.

<user-defined ordering definition> ::=
CREATE ORDERING FOR <schema-resolved user-defined type name> <ordering form>

<equals ordering form> ::= EQUALS ONLY BY <ordering category>

<full ordering form> ::= ORDER FULL BY <ordering category>

<relative category> ::= RELATIVE WITH <relative function specification>

<state category> ::= STATE [ <specific name> ]

11.56 <drop user-defined ordering statement> (p710)

Destroy a user-defined ordering method.

<drop user-defined ordering statement> ::=
DROP ORDERING FOR <schema-resolved user-defined type name> <drop behavior>

11.57 <transform definition> (p712)

Define one or more transform functions for a user-defined type.

<transform definition> ::= CREATE { TRANSFORM | TRANSFORMS } FOR <schema-resolved user-defined type name> <transform group> ...

<transform element list> ::= <transform element> [ <comma> <transform element> ]

11.58 <alter transform statement> (p715)

Change the definition of one or more transform groups.

<alter transform statement> ::=
ALTER { TRANSFORM | TRANSFORMS } FOR <schema-resolved user-defined type name> <alter group> ...

<alter transform action list> ::= <alter transform action> [ { <comma> <alter transform action> }... ]

11.59 <add transform element list> (p717)

Add a transform element (<to sql> and/or <from sql>) to an existing transform group.

11.60 <drop transform element list> (p719)

Remove a transform element (<to sql> and/or <from sql>) from a transform group.

<transform kind> ::= TO SQL | FROM SQL

11.61 <drop transform statement> (p721)

Remove one or more transform functions associated with a transform.

<drop transform statement> ::=
DROP { TRANSFORM | TRANSFORMS } <transforms to be dropped> FOR <schema-resolved user-defined type name> <drop behavior>

11.62 <sequence generator definition> (p724)

Define an external sequence generator.

<sequence generator definition> ::= CREATE SEQUENCE <sequence generator name> [ <sequence generator options> ]

<sequence generator options> ::= <sequence generator option> ...

<common sequence generator options> ::= <common sequence generator option> ...

<sequence generator start with option> ::= START WITH <sequence generator start value>

<sequence generator increment by option> ::= INCREMENT BY <sequence generator increment>

<sequence generator maxvalue option>    ::=
         MAXVALUE <sequence generator max value>
     |     NO MAXVALUE

<sequence generator minvalue option> ::= MINVALUE <sequence generator min value> | NO MINVALUE

<sequence generator cycle option> ::= CYCLE | NO CYCLE

11.63 <alter sequence generator statement> (p726)

Change the definition of an external sequence generator.

<alter sequence generator statement> ::=
ALTER SEQUENCE <sequence generator name> <alter sequence generator options>

<alter sequence generator options> ::= <alter sequence generator option> ...

<alter sequence generator restart option> ::= RESTART WITH <sequence generator restart value>

11.64 <drop sequence generator statement> (p727)

Destroy an external sequence generator.

<drop sequence generator statement> ::= DROP SEQUENCE <sequence generator name> <drop behavior>

Top

12 Access control

12.1 <grant statement> (p729)

Define privileges and role authorizations.

12.2 <grant privilege statement> (p734)

Define privileges.

<grant privilege statement>    ::=
         GRANT <privileges> TO <grantee> [ { <comma> <grantee> }... ]
         [ WITH HIERARCHY OPTION ] [ WITH GRANT OPTION ] [ GRANTED BY <grantor> ]

12.3 <privileges> (p737)

Specify privileges.

<privilege method list> ::= <specific routine designator> [ { <comma> <specific routine designator> }... ]

<grantee> ::= PUBLIC | <authorization identifier>

<grantor> ::= CURRENT_USER | CURRENT_ROLE

12.4 <role definition> (p741)

Define a role.

<role definition> ::= CREATE ROLE <role name> [ WITH ADMIN <grantor> ]

12.5 <grant role statement> (p742)

Define role authorizations.

<grant role statement>    ::=
         GRANT <role granted> [ { <comma> <role granted> }... ]
         TO <grantee> [ { <comma> <grantee> }... ] [ WITH ADMIN OPTION ] [ GRANTED BY <grantor> ]

12.6 <drop role statement> (p744)

Destroy a role.

12.7 <revoke statement> (p745)

Destroy privileges and role authorizations.

<revoke privilege statement>    ::=
         REVOKE [ <revoke option extension> ] <privileges> FROM <grantee> [ { <comma> <grantee> }... ]
         [ GRANTED BY <grantor> ] <drop behavior>

<revoke option extension> ::= GRANT OPTION FOR | HIERARCHY OPTION FOR

<revoke role statement>    ::=
         REVOKE [ ADMIN OPTION FOR ] <role revoked> [ { <comma> <role revoked> }... ]
         FROM <grantee> [ { <comma> <grantee> }... ] [ GRANTED BY <grantor> ] <drop behavior>

Top

13 SQL-client modules

13.1 <SQL-client module definition> (p763)

Define an SQL-client module.

<SQL-client module definition>    ::=
         <module name clause> <language clause> <module authorization clause>
         [ <module path specification> ]
         [ <module transform group specification> ]
         [ <module collation> ]
         [ <temporary table declaration> ... ]
         <module contents> ...

<module authorization clause>    ::=
         SCHEMA <schema name>
     |     AUTHORIZATION <module authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]
     |     SCHEMA <schema name> AUTHORIZATION <module authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]

<module collation> ::= <module collation specification> ...

<module collation specification> ::= COLLATION <collation name> [ FOR <character set specification list> ]

There was another definition <character set specification list> in section 18.3. That was slightly different in format (simpler) but functionally equivalent. It is not clear why it was repeated. The alternative definition is now commented out.

<character set specification list> ::= <character set specification> [ { <comma> <character set specification> }... ]

13.2 <module name clause> (p768)

Name an SQL-client module.

<module name clause> ::=
MODULE [ <SQL-client module name> ] [ <module character set specification> ]

<module character set specification> ::= NAMES ARE <character set specification>

13.3 <externally-invoked procedure> (p769)

Define an externally-invoked procedure.

<externally-invoked procedure>    ::=
         PROCEDURE <procedure name> <host parameter declaration list> <semicolon>
         <SQL procedure statement> <semicolon>

<host parameter data type> ::= <data type> [ <locator indication> ]

<status parameter> ::= SQLSTATE

13.4 Calls to an <externally-invoked procedure> (p772)

13.5 <SQL procedure statement> (p788)

Define all of the SQL-statements that are <SQL procedure statement>s.

13.6 Data type correspondences (p796)

Table 16 -- Data type correspondences for C

SQL Data Type	C Data Type
SQLSTATE	char, with length 6
CHARACTER (L)³	char, with length (L+1)*k¹
CHARACTER VARYING (L)³	char, with length (L+1)*k¹
CHARACTER LARGE OBJECT(L)	struct { long hvn³_reserved unsigned long hvn²_length char³ hvn²_data[L]; } hvn²
BINARY LARGE OBJECT(L)	struct { long hvn²_reserved unsigned long hvn²_length char hvn²_data[L]; } hvn²
NUMERIC(P,S)	None
DECIMAL(P,S)	None
SMALLINT	pointer to short
INTEGER	pointer to long
BIGINT	pointer to long long
FLOAT(P)	None
REAL	pointer to float
DOUBLE PRECISION	pointer to double
BOOLEAN	pointer to long
DATE	None
TIME(T)	None
TIMESTAMP(T)	None
INTERVAL(Q)	None
user-defined type	None
REF	char, with length N
ROW	None
ARRAY	None
MULTISET	None

¹ For character set UTF16, as well as other implementation-defined character sets in which a code unit occupies two octets, k is the length in units of C unsigned short of the character encoded using the greatest number of such units in the character set; for character set UTF32, as well as other implementation-defined character sets in which a code unit occupies four octets, k is four; for other character sets, k is the length in units of C char of the character encoded using the greatest number of such units in the character set.
² hvn is the name of the host variable defined to correspond to the SQL data type
³ For character set UTF16, as well as other implementation-defined character sets in which a code unit occupies two octets, char or unsigned char should be replaced with unsigned short; for character set UTF32, as well as other implementation-defined character sets in which a code unit occupies four octets, char or unsigned char should be replaced with unsigned int. Otherwise, char or unsigned char should be used.

Top

14 Data manipulation

14.1 <declare cursor> (p807)

Define a cursor.

<declare cursor>    ::=
         DECLARE <cursor name> [ <cursor sensitivity> ] [ <cursor scrollability> ] CURSOR
         [ <cursor holdability> ] [ <cursor returnability> ] FOR <cursor specification>

<cursor sensitivity> ::= SENSITIVE | INSENSITIVE | ASENSITIVE

<cursor scrollability> ::= SCROLL | NO SCROLL

<cursor holdability> ::= WITH HOLD | WITHOUT HOLD

<cursor returnability> ::= WITH RETURN | WITHOUT RETURN

<cursor specification> ::= <query expression> [ <order by clause> ] [ <updatability clause> ]

<updatability clause> ::= FOR { READ ONLY | UPDATE [ OF <column name list> ] }

<order by clause> ::= ORDER BY <sort specification list>

14.2 <open statement> (p813)

Open a cursor.

14.3 <fetch statement> (p815)

Position a cursor on a specified row of a table and retrieve values from that row.

<fetch statement> ::=
FETCH [ [ <fetch orientation> ] FROM ] <cursor name> INTO <fetch target list>

<fetch orientation>    ::=
         NEXT
     |     PRIOR
     |     FIRST
     |     LAST
     |     { ABSOLUTE | RELATIVE } <simple value specification>

<fetch target list> ::= <target specification> [ { <comma> <target specification> }... ]

14.4 <close statement> (p820)

Close a cursor.

<close statement> ::= CLOSE <cursor name>

14.5 <select statement: single row> (p822)

Retrieve values from a specified row of a table.

<select statement: single row> ::=
SELECT [ <set quantifier> ] <select list> INTO <select target list> <table expression>

<select target list> ::= <target specification> [ { <comma> <target specification> }... ]

14.6 <delete statement: positioned> (p826)

Delete a row of a table.

<delete statement: positioned> ::= DELETE FROM <target table> WHERE CURRENT OF <cursor name>

14.7 <delete statement: searched> (p829)

Delete rows of a table.

<delete statement: searched> ::= DELETE FROM <target table> [ WHERE <search condition> ]

14.8 <insert statement> (p832)

Create new rows in a table.

<insert statement> ::= INSERT INTO <insertion target> <insert columns and source>

<override clause> ::= OVERRIDING USER VALUE | OVERRIDING SYSTEM VALUE

<from default> ::= DEFAULT VALUES

14.9 <merge statement> (p837)

Conditionally update rows of a table, or insert new rows into a table, or both.

<merge statement>    ::=
         MERGE INTO <target table> [ [ AS ] <merge correlation name> ]
         USING <table reference> ON <search condition> <merge operation specification>

<merge operation specification> ::= <merge when clause> ...

<merge when matched clause> ::= WHEN MATCHED THEN <merge update specification>

<merge when not matched clause> ::= WHEN NOT MATCHED THEN <merge insert specification>

<merge update specification> ::= UPDATE SET <set clause list>

<merge insert specification>    ::=
         INSERT [ <left paren> <insert column list> <right paren> ]
         [ <override clause> ] VALUES <merge insert value list>

14.10 <update statement: positioned> (p844)

Update a row of a table.

<update statement: positioned> ::= UPDATE <target table> SET <set clause list> WHERE CURRENT OF <cursor name>

14.11 <update statement: searched> (p847)

Update rows of a table.

<update statement: searched> ::= UPDATE <target table> SET <set clause list> [ WHERE <search condition> ]

14.12 <set clause list> (p851)

Specify a list of updates.

<set clause list> ::= <set clause> [ { <comma> <set clause> }... ]

14.13 <temporary table declaration> (p856)

Declare a declared local temporary table.

<temporary table declaration>    ::=
         DECLARE LOCAL TEMPORARY TABLE <table name> <table element list>
         [ ON COMMIT <table commit action> ROWS ]

14.14 <free locator statement> (p858)

Remove the association between a locator variable and the value that is represented by that locator.

<free locator statement> ::= FREE LOCATOR <locator reference> [ { <comma> <locator reference> }... ]

14.15 <hold locator statement> (p859)

Mark a locator variable as being holdable.

<hold locator statement> ::= HOLD LOCATOR <locator reference> [ { <comma> <locator reference> }... ]

14.16 Effect of deleting rows from base tables (p860)

14.17 Effect of deleting some rows from a derived table (p862)

14.18 Effect of deleting some rows from a viewed table (p864)

14.19 Effect of inserting tables into base tables (p865)

14.20 Effect of inserting a table into a derived table (p867)

14.21 Effect of inserting a table into a viewed table (p869)

14.22 Effect of replacing rows in base tables (p871)

14.23 Effect of replacing some rows in a derived table (p874)

14.24 Effect of replacing some rows in a viewed table (p877)

14.25 Execution of BEFORE triggers (p879)

14.26 Execution of AFTER triggers (p880)

14.27 Execution of triggers (p881)

Top

15 Control statements

15.1 <call statement> (p883)

Invoke an SQL-invoked routine.

15.2 <return statement> (p884)

Return a value from an SQL function.

<return statement> ::= RETURN <return value>

<return value> ::= <value expression> | NULL

Top

16 Transaction management

16.1 <start transaction statement> (p885)

Start an SQL-transaction and set its characteristics.

<start transaction statement> ::= START TRANSACTION [ <transaction mode> [ { <comma> <transaction mode> }...] ]

<transaction access mode> ::= READ ONLY | READ WRITE

<isolation level> ::= ISOLATION LEVEL <level of isolation>

<level of isolation> ::= READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE

<diagnostics size> ::= DIAGNOSTICS SIZE <number of conditions>

16.2 <set transaction statement> (p888)

Set the characteristics of the next SQL-transaction for the SQL-agent. NOTE 402 - This statement has no effect on any SQL-transactions subsequent to the next SQL-transaction.

<set transaction statement> ::= SET [ LOCAL ] <transaction characteristics>

<transaction characteristics> ::= TRANSACTION <transaction mode> [ { <comma> <transaction mode> }... ]

16.3 <set constraints mode statement> (p890)

If an SQL-transaction is currently active, then set the constraint mode for that SQL-transaction in the current SQL-session. If no SQL-transaction is currently active, then set the constraint mode for the next SQL-transaction in the current SQL-session for the SQL-agent. NOTE 404: This statement has no effect on any SQL-transactions subsequent to this SQL-transaction.

<set constraints mode statement> ::= SET CONSTRAINTS <constraint name list> { DEFERRED | IMMEDIATE }

<constraint name list> ::= ALL | <constraint name> [ { <comma> <constraint name> }... ]

16.4 <savepoint statement> (p892)

Establish a savepoint.

<savepoint statement> ::= SAVEPOINT <savepoint specifier>

16.5 <release savepoint statement> (p893)

Destroy a savepoint.

<release savepoint statement> ::= RELEASE SAVEPOINT <savepoint specifier>

16.6 <commit statement> (p894)

Terminate the current SQL-transaction with commit.

<commit statement> ::= COMMIT [ WORK ] [ AND [ NO ] CHAIN ]

16.7 <rollback statement> (p896)

Terminate the current SQL-transaction with rollback, or rollback all actions affecting SQL-data and/or schemas since the establishment of a savepoint.

<rollback statement> ::= ROLLBACK [ WORK ] [ AND [ NO ] CHAIN ] [ <savepoint clause> ]

<savepoint clause> ::= TO SAVEPOINT <savepoint specifier>

Top

17 Connection management

17.1 <connect statement> (p899)

Establish an SQL-session.

<connect statement> ::= CONNECT TO <connection target>

<connection target>    ::=
         <SQL-server name> [ AS <connection name> ] [ USER <connection user name> ]
     |     DEFAULT

17.2 <set connection statement> (p902)

Select an SQL-connection from the available SQL-connections.

<set connection statement> ::= SET CONNECTION <connection object>

<connection object> ::= DEFAULT | <connection name>

17.3 <disconnect statement> (p904)

Terminate an SQL-connection.

<disconnect statement> ::= DISCONNECT <disconnect object>

<disconnect object> ::= <connection object> | ALL | CURRENT

Top

18 Session management

18.1 <set session characteristics statement> (p907)

Set one or more characteristics for the current SQL-session.

<set session characteristics statement> ::= SET SESSION CHARACTERISTICS AS <session characteristic list>

<session characteristic list> ::= <session characteristic> [ { <comma> <session characteristic> }... ]

18.2 <set session user identifier statement> (p908)

Set the SQL-session user identifier and the current user identifier of the current SQL-session context.

<set session user identifier statement> ::= SET SESSION AUTHORIZATION <value specification>

18.3 <set role statement> (p909)

Set the current role name for the current SQL-session context.

<role specification> ::= <value specification> | NONE

18.4 <set local time zone statement> (p911)

Set the default local time zone displacement for the current SQL-session.

<set time zone value> ::= <interval value expression> | LOCAL

18.5 <set catalog statement> (p912)

Set the default catalog name for unqualified <schema name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

<catalog name characteristic> ::= CATALOG <value specification>

18.6 <set schema statement> (p913)

Set the default schema name for unqualified <schema qualified name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

<schema name characteristic> ::= SCHEMA <value specification>

18.7 <set names statement> (p915)

Set the default character set name for <character string literal>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

<character set name characteristic> ::= NAMES <value specification>

18.8 <set path statement> (p916)

Set the SQL-path used to determine the subject routine of <routine invocation>s with unqualified <routine name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s, respectively, that are invoked directly. The SQL-path remains the current SQL-path of the SQLsession until another SQL-path is successfully set.

<SQL-path characteristic> ::= PATH <value specification>

18.9 <set transform group statement> (p917)

Set the group name that identifies the group of transform functions for mapping values of userdefined types to predefined data types.

<transform group characteristic>    ::=
         DEFAULT TRANSFORM GROUP <value specification>
     |     TRANSFORM GROUP FOR TYPE <path-resolved user-defined type name> <value specification>

18.10 <set session collation statement> (p918)

Set the SQL-session collation of the SQL-session for one or more character sets. An SQL-session collation remains effective until another SQL-session collation for the same character set is successfully set.

<set session collation statement>    ::=
         SET COLLATION <collation specification> [ FOR <character set specification list> ]
     |     SET NO COLLATION [ FOR <character set specification list> ]

Top

19 Dynamic SQL

19.1 Description of SQL descriptor areas (p921)

19.2 <allocate descriptor statement> (p931)

Allocate an SQL descriptor area.

<allocate descriptor statement> ::= ALLOCATE [ SQL ] DESCRIPTOR <descriptor name> [ WITH MAX <occurrences> ]

19.3 <deallocate descriptor statement> (p933)

Deallocate an SQL descriptor area.

<deallocate descriptor statement> ::= DEALLOCATE [ SQL ] DESCRIPTOR <descriptor name>

19.4 <get descriptor statement> (p934)

Get information from an SQL descriptor area.

<get descriptor statement> ::= GET [ SQL ] DESCRIPTOR <descriptor name> <get descriptor information>

<get descriptor information>    ::=
         <get header information> [ { <comma> <get header information> }... ]
     |     VALUE <item number> <get item information> [ { <comma> <get item information> }... ]

<header item name> ::= COUNT | KEY_TYPE | DYNAMIC_FUNCTION | DYNAMIC_FUNCTION_CODE | TOP_LEVEL_COUNT

The rule for <item number> was repeated verbatim in section 19.5. That rule is now omitted.

19.5 <set descriptor statement> (p937)

Set information in an SQL descriptor area.

<set descriptor statement> ::= SET [ SQL ] DESCRIPTOR <descriptor name> <set descriptor information>

<set descriptor information>    ::=
         <set header information> [ { <comma> <set header information> }... ]
     |     VALUE <item number> <set item information> [ { <comma> <set item information> }... ]

19.6 <prepare statement> (p941)

Prepare a statement for execution.

<prepare statement> ::=
PREPARE <SQL statement name> [ <attributes specification> ] FROM <SQL statement variable>

<attributes specification> ::= ATTRIBUTES <attributes variable>

<preparable implementation-defined statement> ::= !! See the Syntax Rules.

19.7 <cursor attributes> (p953)

Specify a list of cursor attributes.

<cursor attributes> ::= <cursor attribute> ...

19.8 <deallocate prepared statement> (p954)

Deallocate SQL-statements that have been prepared with a <prepare statement>.

<deallocate prepared statement> ::= DEALLOCATE PREPARE <SQL statement name>

19.9 <describe statement> (p955)

Obtain information about the <select list> columns or <dynamic parameter specification>s contained in a prepared statement or about the columns of the result set associated with a cursor.

<describe input statement> ::= DESCRIBE INPUT <SQL statement name> <using descriptor> [ <nesting option> ]

<describe output statement> ::= DESCRIBE [ OUTPUT ] <described object> <using descriptor> [ <nesting option> ]

<nesting option> ::= WITH NESTING | WITHOUT NESTING

<using descriptor> ::= USING [ SQL ] DESCRIPTOR <descriptor name>

<described object>    ::=
         <SQL statement name>
     |     CURSOR <extended cursor name> STRUCTURE

19.10 <input using clause> (p961)

Supply input values for an <SQL dynamic statement>.

<using arguments> ::= USING <using argument> [ { <comma> <using argument> }... ]

19.11 <output using clause> (p965)

Supply output variables for an <SQL dynamic statement>.

<into arguments> ::= INTO <into argument> [ { <comma> <into argument> }... ]

<into descriptor> ::= INTO [ SQL ] DESCRIPTOR <descriptor name>

19.12 <execute statement> (p970)

Associate input SQL parameters and output targets with a prepared statement and execute the statement.

<execute statement> ::= EXECUTE <SQL statement name> [ <result using clause> ] [ <parameter using clause> ]

19.13 <execute immediate statement> (p972)

Dynamically prepare and execute a preparable statement.

<execute immediate statement> ::= EXECUTE IMMEDIATE <SQL statement variable>

19.14 <dynamic declare cursor> (p973)

Declare a cursor to be associated with a <statement name>, which may in turn be associated with a <cursor specification>.

<dynamic declare cursor>    ::=
         DECLARE <cursor name> [ <cursor sensitivity> ] [ <cursor scrollability> ] CURSOR
         [ <cursor holdability> ] [ <cursor returnability> ] FOR <statement name>

19.15 <allocate cursor statement> (p974)

Define a cursor based on a prepared statement for a <cursor specification> or assign a cursor to the ordered set of result sets returned from an SQL-invoked procedure.

<allocate cursor statement> ::= ALLOCATE <extended cursor name> <cursor intent>

<statement cursor>    ::=
         [ <cursor sensitivity> ] [ <cursor scrollability> ] CURSOR
         [ <cursor holdability> ] [ <cursor returnability> ] FOR <extended statement name>

<result set cursor> ::= FOR PROCEDURE <specific routine designator>

19.16 <dynamic open statement> (p976)

Associate input dynamic parameters with a <cursor specification> and open the cursor.

<dynamic open statement> ::= OPEN <dynamic cursor name> [ <input using clause> ]

19.17 <dynamic fetch statement> (p977)

Fetch a row for a cursor declared with a <dynamic declare cursor>.

<dynamic fetch statement> ::= FETCH [ [ <fetch orientation> ] FROM ] <dynamic cursor name> <output using clause>

19.18 <dynamic single row select statement> (p978)

Retrieve values from a dynamically-specified row of a table.

19.19 <dynamic close statement> (p979)

Close a cursor.

<dynamic close statement> ::= CLOSE <dynamic cursor name>

19.20 <dynamic delete statement: positioned> (p980)

Delete a row of a table.

<dynamic delete statement: positioned> ::= DELETE FROM <target table> WHERE CURRENT OF <dynamic cursor name>

19.21 <dynamic update statement: positioned> (p982)

Update a row of a table.

<dynamic update statement: positioned> ::=
UPDATE <target table> SET <set clause list> WHERE CURRENT OF <dynamic cursor name>

19.22 <preparable dynamic delete statement: positioned> (p984)

Delete a row of a table through a dynamic cursor.

<preparable dynamic delete statement: positioned> ::=
DELETE [ FROM <target table> ] WHERE CURRENT OF [ <scope option> ] <cursor name>

19.23 <preparable dynamic update statement: positioned> (p986)

Update a row of a table through a dynamic cursor.

<preparable dynamic update statement: positioned> ::=
UPDATE [ <target table> ] SET <set clause list> WHERE CURRENT OF [ <scope option> ] <cursor name>

Top

20 Embedded SQL

20.1 <embedded SQL host program> (p989)

Specify an <embedded SQL host program>.

<embedded SQL statement> ::= <SQL prefix> <statement or declaration> [ <SQL terminator> ]

<embedded authorization declaration> ::= DECLARE <embedded authorization clause>

<embedded authorization clause>    ::=
         SCHEMA <schema name>
     |     AUTHORIZATION <embedded authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]
     |     SCHEMA <schema name> AUTHORIZATION <embedded authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]

<embedded character set declaration> ::= SQL NAMES ARE <character set specification>

<embedded SQL begin declare> ::= <SQL prefix> BEGIN DECLARE SECTION [ <SQL terminator> ]

<embedded SQL end declare> ::= <SQL prefix> END DECLARE SECTION [ <SQL terminator> ]

<embedded SQL MUMPS declare>    ::=
         <SQL prefix> BEGIN DECLARE SECTION [ <embedded character set declaration> ]
         [ <host variable definition> ... ] END DECLARE SECTION <SQL terminator>

20.2 <embedded exception declaration> (p1001)

Specify the action to be taken when an SQL-statement causes a specific class of condition to be raised.

<embedded exception declaration> ::= WHENEVER <condition> <condition action>

<SQL condition>    ::=
         <major category>
     |     SQLSTATE ( <SQLSTATE class value> [ , <SQLSTATE subclass value> ] )
     |     CONSTRAINT <constraint name>

<major category> ::= SQLEXCEPTION | SQLWARNING | NOT FOUND

<SQLSTATE class value> ::= <SQLSTATE char> <SQLSTATE char> !! See the Syntax Rules.

<SQLSTATE subclass value> ::= <SQLSTATE char> <SQLSTATE char> <SQLSTATE char> !! See the Syntax Rules.

<condition action> ::= CONTINUE | <go to>

<host label identifier> ::= !! See the Syntax Rules.

<host PL/I label variable> ::= !! See the Syntax Rules.

20.3 <embedded SQL Ada program> (p1005)

Specify an <embedded SQL Ada program>.

<embedded SQL Ada program> ::= !! See the Syntax Rules.

<Ada variable definition> ::=
<Ada host identifier> [ { <comma> <Ada host identifier> }... ] <colon> <Ada type specification> [ <Ada initial value> ]

<Ada initial value> ::= <Ada assignment operator> <character representation> ...

<Ada host identifier> ::= !! See the Syntax Rules.

<Ada CLOB variable> ::=
SQL TYPE IS CLOB <left paren> <large object length> <right paren> [ CHARACTER SET [ IS ] <character set specification> ]

<Ada CLOB locator variable> ::= SQL TYPE IS CLOB AS LOCATOR

<Ada BLOB locator variable> ::= SQL TYPE IS BLOB AS LOCATOR

<Ada user-defined type locator variable> ::= SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<Ada array locator variable> ::= SQL TYPE IS <array type> AS LOCATOR

<Ada multiset locator variable> ::= SQL TYPE IS <multiset type> AS LOCATOR

20.4 <embedded SQL C program> (p1011)

Specify an <embedded SQL C program>.

<embedded SQL C program> ::= !! See the Syntax Rules.

<C storage class> ::= auto | extern | static

<C class modifier> ::= const | volatile

It is curious that the C types in SQL 2003 don't include the C keywords int or signed. It is slightly less surprising that the grammar doesn't include C99 keywords such as restrict.

<C numeric variable>    ::=
         { long long | long | short | float | double } <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] }... ]

<C character variable>    ::=
         <C character type> [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> <C array specification> [ <C initial value> ]
         [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] }... ]

<C character type> ::= char | unsigned char | unsigned short

<C host identifier> ::= !! See the Syntax Rules.

<C VARCHAR variable>    ::=
         VARCHAR [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> <C array specification> [ <C initial value> ]
         [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] }... ]

<C NCHAR variable>    ::=
         NCHAR [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> <C array specification> [ <C initial value> ]
         [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] } ... ]

<C NCHAR VARYING variable>    ::=
         NCHAR VARYING [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> <C array specification> [ <C initial value> ]
         [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] } ... ]

<C CLOB variable>    ::=
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] }... ]

<C NCLOB variable>    ::=
         SQL TYPE IS NCLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] }... ]

<C user-defined type variable>    ::=
         SQL TYPE IS <path-resolved user-defined type name> AS <predefined type>
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C BLOB variable>    ::=
         SQL TYPE IS BLOB <left paren> <large object length> <right paren>
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C CLOB locator variable>    ::=
         SQL TYPE IS CLOB AS LOCATOR
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C BLOB locator variable>    ::=
         SQL TYPE IS BLOB AS LOCATOR
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C array locator variable>    ::=
         SQL TYPE IS <array type> AS LOCATOR
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C multiset locator variable>    ::=
         SQL TYPE IS <multiset type> AS LOCATOR
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

<C user-defined type locator variable>    ::=
         SQL TYPE IS
         <path-resolved user-defined type name> AS LOCATOR
         <C host identifier> [ <C initial value> ]
         [ { <comma> <C host identifier> [ <C initial value> ] }... ]

<C initial value> ::= <equals operator> <character representation> ...

20.5 <embedded SQL COBOL program> (p1019)

Specify an <embedded SQL COBOL program>.

<embedded SQL COBOL program> ::= !! See the Syntax Rules.

<COBOL host identifier> ::= !! See the Syntax Rules.

<COBOL character type>    ::=
         [ CHARACTER SET [ IS ] <character set specification> ]
         { PIC | PICTURE } [ IS ] { X [ <left paren> <length> <right paren> ] }...

<COBOL national character type>    ::=
         [ CHARACTER SET [ IS ] <character set specification> ]
         { PIC | PICTURE } [ IS ] { N [ <left paren> <length> <right paren> ] }...

<COBOL CLOB variable>    ::=
         [ USAGE [ IS ] ]
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<COBOL NCLOB variable>    ::=
         [ USAGE [ IS ] ]
         SQL TYPE IS NCLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<COBOL BLOB variable>    ::=
         [ USAGE [ IS ] ]
         SQL TYPE IS BLOB <left paren> <large object length> <right paren>

<COBOL user-defined type variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS <path-resolved user-defined type name> AS <predefined type>

<COBOL CLOB locator variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS CLOB AS LOCATOR

<COBOL BLOB locator variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS BLOB AS LOCATOR

<COBOL array locator variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS <array type> AS LOCATOR

<COBOL multiset locator variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS <multiset type> AS LOCATOR

<COBOL user-defined type locator variable> ::=
[ USAGE [ IS ] ] SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<COBOL REF variable> ::= [ USAGE [ IS ] ] SQL TYPE IS <reference type>

<COBOL numeric type> ::=
{ PIC | PICTURE } [ IS ] S <COBOL nines specification> [ USAGE [ IS ] ] DISPLAY SIGN LEADING SEPARATE

<COBOL binary integer> ::= { PIC | PICTURE } [ IS ] S <COBOL nines> [ USAGE [ IS ] ] BINARY

<COBOL nines> ::= { 9 [ <left paren> <length> <right paren> ] }...

20.6 <embedded SQL Fortran program> (p1025)

Specify an <embedded SQL Fortran program>.

<embedded SQL Fortran program> ::= !! See the Syntax Rules.

<Fortran variable definition> ::=
<Fortran type specification> <Fortran host identifier> [ { <comma> <Fortran host identifier> }... ]

<Fortran host identifier> ::= !! See the Syntax Rules.

<Fortran type specification>    ::=
         CHARACTER [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
     |     CHARACTER KIND = n [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
     |     INTEGER
     |     REAL
     |     DOUBLE PRECISION
     |     LOGICAL
     |     <Fortran derived type specification>

<Fortran CLOB variable>    ::=
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<Fortran CLOB locator variable> ::= SQL TYPE IS CLOB AS LOCATOR

<Fortran BLOB locator variable> ::= SQL TYPE IS BLOB AS LOCATOR

<Fortran user-defined type locator variable> ::= SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<Fortran array locator variable> ::= SQL TYPE IS <array type> AS LOCATOR

<Fortran multiset locator variable> ::= SQL TYPE IS <multiset type> AS LOCATOR

20.7 <embedded SQL MUMPS program> (p1030)

Specify an <embedded SQL MUMPS program>.

<embedded SQL MUMPS program> ::= !! See the Syntax Rules.

<MUMPS character variable>    ::=
         VARCHAR <MUMPS host identifier> <MUMPS length specification>
         [ { <comma> <MUMPS host identifier> <MUMPS length specification> }... ]

<MUMPS host identifier> ::= !! See the Syntax Rules.

<MUMPS numeric variable> ::= <MUMPS type specification> <MUMPS host identifier> [ { <comma> <MUMPS host identifier> }... ]

<MUMPS type specification>    ::=
         INT
     |     DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
     |     REAL

<MUMPS CLOB variable>    ::=
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<MUMPS CLOB locator variable> ::= SQL TYPE IS CLOB AS LOCATOR

<MUMPS BLOB locator variable> ::= SQL TYPE IS BLOB AS LOCATOR

<MUMPS user-defined type locator variable> ::= SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<MUMPS array locator variable> ::= SQL TYPE IS <array type> AS LOCATOR

<MUMPS multiset locator variable> ::= SQL TYPE IS <multiset type> AS LOCATOR

20.8 <embedded SQL Pascal program> (p1035)

Specify an <embedded SQL Pascal program>.

<embedded SQL Pascal program> ::= !! See the Syntax Rules.

<Pascal host identifier> ::= !! See the Syntax Rules.

<Pascal type specification>    ::=
         PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket> OF CHAR
         [ CHARACTER SET [ IS ] <character set specification> ]
     |     INTEGER
     |     REAL
     |     CHAR [ CHARACTER SET [ IS ] <character set specification> ]
     |     BOOLEAN
     |     <Pascal derived type specification>

<Pascal CLOB variable>    ::=
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<Pascal CLOB locator variable> ::= SQL TYPE IS CLOB AS LOCATOR

<Pascal BLOB locator variable> ::= SQL TYPE IS BLOB AS LOCATOR

<Pascal user-defined type locator variable> ::= SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<Pascal array locator variable> ::= SQL TYPE IS <array type> AS LOCATOR

<Pascal multiset locator variable> ::= SQL TYPE IS <multiset type> AS LOCATOR

20.9 <embedded SQL PL/I program> (p1040)

Specify an <embedded SQL PL/I program>.

<embedded SQL PL/I program> ::= !! See the Syntax Rules.

<PL/I variable definition>    ::=
         { DCL | DECLARE } { <PL/I host identifier>
     |     <left paren> <PL/I host identifier> [ { <comma> <PL/I host identifier> }... ] <right paren> }
         <PL/I type specification> [ <character representation> ... ] <semicolon>

<PL/I host identifier> ::= !! See the Syntax Rules.

<PL/I type specification>    ::=
         { CHAR | CHARACTER } [ VARYING ] <left paren> <length> <right paren> [ CHARACTER SET [ IS ] <character set specification> ]
     |     <PL/I type fixed decimal> <left paren> <precision> [ <comma> <scale> ] <right paren>
     |     <PL/I type fixed binary> [ <left paren> <precision> <right paren> ]
     |     <PL/I type float binary> <left paren> <precision> <right paren>
     |     <PL/I derived type specification>

<PL/I CLOB variable>    ::=
         SQL TYPE IS CLOB <left paren> <large object length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]

<PL/I CLOB locator variable> ::= SQL TYPE IS CLOB AS LOCATOR

<PL/I BLOB locator variable> ::= SQL TYPE IS BLOB AS LOCATOR

<PL/I user-defined type locator variable> ::= SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

<PL/I array locator variable> ::= SQL TYPE IS <array type> AS LOCATOR

<PL/I multiset locator variable> ::= SQL TYPE IS <multiset type> AS LOCATOR

<PL/I type fixed decimal>    ::=
         { DEC | DECIMAL } FIXED
     |     FIXED { DEC | DECIMAL }

<PL/I type fixed binary>    ::=
         { BIN | BINARY } FIXED
     |     FIXED { BIN | BINARY }

<PL/I type float binary>    ::=
         { BIN | BINARY } FLOAT
     |     FLOAT { BIN | BINARY }

Top

21 Direct invocation of SQL

21.1 <direct SQL statement> (p1047)

Specify direct execution of SQL.

<direct implementation-defined statement> ::= !! See the Syntax Rules.

21.2 <direct select statement: multiple rows> (p1051)

Specify a statement to retrieve multiple rows from a specified table.

Top

22 Diagnostics management

22.1 <get diagnostics statement> (p1053)

Get exception or completion condition information from a diagnostics area.

<get diagnostics statement> ::= GET DIAGNOSTICS <SQL diagnostics information>

<statement information> ::= <statement information item> [ { <comma> <statement information item> }... ]

<condition information> ::=
{ EXCEPTION | CONDITION } <condition number> <condition information item> [ { <comma> <condition information item> }... ]

22.2 Pushing and popping the diagnostics area stack (p1068)

Top

23 Status codes

23.1 SQLSTATE (p1069)

The character string value returned in an SQLSTATE parameter comprises a 2-character class value followed by a 3-character subclass value, each with an implementation-defined character set that has a one-octet character encoding form and is restricted to <digit>s and <simple Latin upper case letter>s. Table 31, 'SQLSTATE class and subclass values', specifies the class value for each condition and the subclass value or values for each class value.

Class values that begin with one of the <digit>s '0', '1', '2', '3', or '4' or one of the <simple Latin upper case letter>s 'A', 'B', 'C', 'D', 'E', 'F', 'G', or 'H' are returned only for conditions defined in ISO/IEC 9075 or in any other International Standard. The range of such class values are called standard-defined classes. Some such class codes are reserved for use by specific International Standards, as specified elsewhere in this Clause. Subclass values associated with such classes that also begin with one of those 13 characters are returned only for conditions defined in ISO/IEC 9075 or some other International Standard. The range of such class values are called standard-defined classes. Subclass values associated with such classes that begin with one of the <digit>s '5', '6', '7', '8', or '9' or one of the <simple Latin upper case letter>s 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z' are reserved for implementation-specified conditions and are called implementation-defined subclasses.

Class values that begin with one of the <digit>s '5', '6', '7', '8', or '9' or one of the <simple Latin upper case letter>s 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z' are reserved for implementation-specified exception conditions and are called implementation-defined classes. All subclass values except '000', which means no subclass, associated with such classes are reserved for implementation-specified conditions and are called implementation-defined subclasses. An implementation-defined completion condition shall be indicated by returning an implementation-defined subclass in conjunction with one of the classes successful completion, warning, or no data.

The 'Category' column has the following meanings: 'S' means that the class value given corresponds to successful completion and is a completion condition; 'W' means that the class value given corresponds to a successful completion but with a warning and is a completion condition; 'N' means that the class value given corresponds to a no-data situation and is a completion condition; 'X' means that the class value given corresponds to an exception condition.

Table 31 - SQLSTATE class and subclass values

Category	Condition	Class	Subcondition	Subclass
X	ambiguous cursor name	3C	(no subclass)	000
X	attempt to assign to non-updatable column	0U	(no subclass)	000
X	attempt to assign to ordering column	0V	(no subclass)	000
X	cardinality violation	21	(no subclass)	000
X	connection exception	08	(no subclass)	000
			connection does not exist	003
			connection failure	006
			connection name in use	002
			SQL-client unable to establish SQL-connection	001
			SQL-server rejected establishment of SQL-connection	004
			transaction resolution unknown	007
X	cursor sensitivity exception	36	(no subclass)	000
			request failed	002
			request rejected	001
X	data exception	22	(no subclass)	000
			array data, right truncation	02F
			array element error	02E
			character not in repertoire	021
			datetime field overflow	008
			division by zero	012
			error in assignment	005
			escape character conflict	00B
			indicator overflow	022
			interval field overflow	015
			invalid argument for natural logarithm	01E
			invalid argument for power function	01F
			invalid argument for width bucket function	01G
			invalid character value for cast	018
			invalid datetime format	007
			invalid escape character	019
			invalid escape octet	00D
			invalid escape sequence	025
			invalid indicator parameter value	010
			invalid interval format	006
			invalid parameter value	023
			invalid preceding or following size in window function	013
			invalid regular expression	01B
			invalid repeat argument in a sample clause	02G
			invalid sample size	02H
			invalid time zone displacement value	009
			invalid use of escape character	00C
			most specific type mismatch	00G
			noncharacter in UCS string	029
			null value substituted for mutator subject parameter	02D
			null row not permitted in table	01C
			null value in array target	00E
			null value, no indicator parameter	002
			null value not allowed	004
			numeric value out of range	003
			sequence generator limit exceeded	00H
			string data, length mismatch	026
			string data, right truncation	001
			substring error	011
			trim error	027
			unterminated C string	024
			zero-length character string	00F
X	dependent privilege descriptors still exist	2B	(no subclass)	000
X	diagnostics exception	0Z	(no subclass)	000
			maximum number of stacked diagnostics areas exceeded	001
X	dynamic SQL error	07	(no subclass)	000
			cursor specification cannot be executed	003
			data type transform function violation	00B
			invalid DATA target	00D
			invalid DATETIME_INTERVAL_CODE	00F
			invalid descriptor count	008
			invalid descriptor index	009
			invalid LEVEL value	00E
			prepared statement not a cursor specification	005
			restricted data type attribute violation	006
			undefined DATA value	00C
			using clause does not match dynamic parameter specifications	001
			using clause does not match target specifications	002
			using clause required for dynamic parameters	004
			using clause required for result fields	007
X	external routine exception	38	(no subclass)	000
			containing SQL not permitted	001
			modifying SQL-data not permitted	002
			prohibited SQL-statement attempted	003
			reading SQL-data not permitted	004
X	external routine invocation exception	39	(no subclass)	000
			invalid SQLSTATE returned	001
			null value not allowed	004
X	feature not supported	0A	(no subclass)	000
			multiple server transactions	001
X	integrity constraint violation	23	(no subclass)	000
			restrict violation	001
X	invalid authorization specification	28	(no subclass)	000
X	invalid catalog name	3D	(no subclass)	000
X	invalid character set name	2C	(no subclass)	000
X	invalid condition number	35	(no subclass)	000
X	invalid connection name	2E	(no subclass)	000
X	invalid cursor name	34	(no subclass)	000
X	invalid cursor state	24	(no subclass)	000
X	invalid grantor	0L	(no subclass)	000
X	invalid role specification	0P	(no subclass)	000
X	invalid schema name	3F	(no subclass)	000
X	invalid schema name list specification	0E	(no subclass)	000
X	invalid session collation specification	2H	(no subclass)	000
X	invalid SQL descriptor name	33	(no subclass)	000
X	invalid SQL-invoked procedure reference	0M	(no subclass)	000
X	invalid SQL statement name	26	(no subclass)	000
X	invalid SQL statement identifier	30	(no subclass)	000
X	invalid target type specification	0D	(no subclass)	000
X	invalid transaction initiation	0B	(no subclass)	000
X	invalid transaction state	25	(no subclass)	000
			active SQL-transaction	001
			branch transaction already active	002
			held cursor requires same isolation level	008
			inappropriate access mode for branch transaction	003
			inappropriate isolation level for branch transaction	004
			no active SQL-transaction for branch transaction	005
			read-only SQL-transaction	006
			schema and data statement mixing not supported	007
X	invalid transaction termination	2D	(no subclass)	000
X	invalid transform group name specification	0S	(no subclass)	000
X	locator exception	0F	(no subclass)	000
			invalid specification	001
N	no data	02	(no subclass)	000
			no additional dynamic result sets returned	001
X	prohibited statement encountered during trigger execution	0W	(no subclass)	000
X	Remote Database Access	HZ	(See Table 32, 'SQLSTATE class codes for RDA', for the definition of protocol subconditions and subclass code values)
X	savepoint exception	3B	(no subclass)	000
			invalid specification	001
			too many	002
X	SQL routine exception	2F	(no subclass)	000
			function executed no return statement	005
			modifying SQL-data not permitted	002
			prohibited SQL-statement attempted	003
			reading SQL-data not permitted	004
S	successful completion	00	(no subclass)	000
X	syntax error or access rule violation	42	(no subclass)	000
X	target table disagrees with cursor specification	0T	(no subclass)	000
X	transaction rollback	40	(no subclass)	000
			integrity constraint violation	002
			serialization failure	001
			statement completion unknown	003
			triggered action exception	004
X	triggered action exception	09	(no subclass)	000
X	triggered data change violation	27	(no subclass)	000
W	warning	01	(no subclass)	000
			additional result sets returned	00D
			array data, right truncation	02F
			attempt to return too many result sets	00E
			cursor operation conflict	001
			default value too long for information schema	00B
			disconnect error	002
			dynamic result sets returned	00C
			external routine warning (the value of xx to be chosen by the author of the external routine)	Hxx
			insufficient item descriptor areas	005
			null value eliminated in set function	003
			privilege not granted	007
			privilege not revoked	006
			query expression too long for information schema	00A
			search condition too long for information schema	009
			statement too long for information schema	008
			string data, right truncation	004
X	with check option violation	44	(no subclass)	000

Top

24 Conformance

24.1 General Conformance Requirements (p1079)

Table 33 - Implied feature relationships

Feature ID	Feature Description	Implied Feature	ID Implied Feature Description
B032	Extended dynamic SQL	B031	Basic dynamic SQL
B034	Dynamic specification of cursor attributes	B031	Basic dynamic SQL
F381	Extended schema manipulation	F491	Constraint management
F451	Character set definition	F461	Named character sets
F711	ALTER domain	F251	Domain support
F801	Full set function	F441	Extended set function support
S024	Enhanced structured types	S023	Basic structured types
S041	Basic reference types	S023	Basic structured types
S041	Basic reference types	S051	Create table of type
S043	Enhanced reference types	S041	Basic reference types
S051	Create table of type	S023	Basic structured types
S081	Subtables	S023	Basic structured types
S081	Subtables	S051	Create table of type
S092	Arrays of user-defined types	S091	Basic array support
S094	Arrays of reference types	S041	Basic reference types
S094	Arrays of reference types	S091	Basic array support
S095	Array constructors by query	S091	Basic array support
S096	Optional array bounds	S091	Basic array support
S111	ONLY in query expressions	S023	Basic structured types
S111	ONLY in query expressions	S051	Create table of type
S201	SQL-invoked routines on arrays	S091	Basic array support
S202	SQL-invoked routines on multisets	S271	Basic multiset support
S231	Structured type locators	S023	Basic structured types
S232	Array locators	S091	Basic array support
S233	Multiset locators	S271	Basic multiset support
S242	Alter transform statement	S241	Transform functions
S272	Multisets of user-defined types	S271	Basic multiset support
S274	Multisets of reference types	S041	Basic reference types
S274	Multisets of reference types	S271	Basic multiset support
S275	Advanced multiset support	S271	Basic multiset support
T042	Extended LOB data type support	T041	Basic LOB data type support
T061	UCS Support	F461	Named character sets
T071	BIGINT data type	E001-01	INTEGER and SMALLINT data types (including all spellings)
T131	Recursive query	T121	WITH (excluding RECURSIVE) in query expression
T173	Extended LIKE clause in table definition	T171	LIKE clause in table definition
T212	Enhanced trigger capability	T211	Basic trigger capability
T332	Extended roles	T331	Basic roles
T511	Transaction counts	F121	Basic diagnostics management
T571	Array-returning external SQL-invoked functions	S091	Basic array support
T571	Array-returning external SQL-invoked functions	S201	SQL-invoked routines on arrays
T572	Multiset-returning external SQLinvoked functions	S202	SQL-invoked routines on multisets
T572	Multiset-returning external SQLinvoked functions	S271	Basic multiset support
T612	Advanced OLAP operations	T611	Elementary OLAP operations

Top

END OF SQL-2003 Part 2 (SQL/Foundation) GRAMMAR

Notes on Automatically Converting the SQL Grammar to a YACC Grammar

Automatic translation of this grammar is non-trivial for a number of reasons. One is that the grammar has a number of actions '!! See the Syntax Rules' which cannot be translated automatically. Another is that the grammar contains rules that are usually better handled by the lexical analyzer than the grammar proper. Then there are incomplete rules such as those which reference parts 6 to 10 (they are not defined; indeed, part 7, which was going to be SQL/Temporal, is in complete abeyance), and the packages (almost completely undefined in the grammar). It is not clear whether these can be ignored, or annotated out of the way.

Another complication is automatically generating rules to deal with optional components and repetitive components in the grammar. Square brackets do not contain alternative non-terminals; all those expressions are contained within curly brackets within the square brackets. However, some square brackets do contain alternative terminals. Curly brackets contain and group mandatory elements. However, they are usually used in conjunction with the 'one or more times' repeater ellipsis '...' mark.

Top

END OF SQL 2003-2 (SQL/FOUNDATION) GRAMMAR

Cross-Reference Table: Rules

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Rule (non-terminal)	Rules using it
absolute value expression	<numeric value function>
action	<object privileges>
actual identifier	<identifier>
Ada array locator variable	<Ada derived type specification>
Ada assignment operator	<Ada initial value>
Ada BLOB locator variable	<Ada derived type specification>
Ada BLOB variable	<Ada derived type specification>
Ada CLOB locator variable	<Ada derived type specification>
Ada CLOB variable	<Ada derived type specification>
Ada derived type specification	<Ada type specification>
Ada host identifier	<Ada variable definition> <host identifier>
Ada initial value	<Ada variable definition>
Ada multiset locator variable	<Ada derived type specification>
Ada qualified type specification	<Ada type specification>
Ada REF variable	<Ada derived type specification>
Ada type specification	<Ada variable definition>
Ada unqualified type specification	<Ada type specification>
Ada user-defined type locator variable	<Ada derived type specification>
Ada user-defined type variable	<Ada derived type specification>
Ada variable definition	<host variable definition>
add attribute definition	<alter type action>
add column definition	<alter table action>
add column scope clause	<alter column action>
add domain constraint definition	<alter domain action>
add original method specification	<alter type action>
add overriding method specification	<alter type action>
add table constraint definition	<alter table action>
add transform element list	<alter transform action>
aggregate function	<set function specification> <window function type>
all	<quantifier>
all fields column name list	<all fields reference>
all fields reference	<qualified asterisk>
allocate cursor statement	<SQL dynamic data statement>
allocate descriptor statement	<system descriptor statement>
alter column action	<alter column definition>
alter column definition	<alter table action>
alter domain action	<alter domain statement>
alter domain statement	<SQL schema manipulation statement>
alter group	<alter transform statement>
alter identity column option	<alter identity column specification>
alter identity column specification	<alter column action>
alter routine behavior	<alter routine statement>
alter routine characteristic	<alter routine characteristics>
alter routine characteristics	<alter routine statement>
alter routine statement	<SQL schema manipulation statement>
alter sequence generator option	<alter sequence generator options>
alter sequence generator options	<alter sequence generator statement>
alter sequence generator restart option	<alter identity column option> <alter sequence generator option>
alter sequence generator statement	<SQL schema manipulation statement>
alter table action	<alter table statement>
alter table statement	<SQL schema manipulation statement>
alter transform action	<alter transform action list>
alter transform action list	<alter group>
alter transform statement	<SQL schema manipulation statement>
alter type statement	<SQL schema manipulation statement>
ampersand	<SQL prefix> <SQL special character> <Unicode character string literal> <Unicode delimited identifier>
approximate numeric literal	<unsigned numeric literal>
approximate numeric type	<numeric type>
array concatenation	<array value expression>
array element	<array element list>
array element list	<array value constructor by enumeration>
array element reference	<nonparenthesized value expression primary>
array factor	<array concatenation> <array value expression>
array type	<Ada array locator variable> <C array locator variable> <COBOL array locator variable> <collection type> <Fortran array locator variable> <MUMPS array locator variable> <Pascal array locator variable> <PL/I array locator variable>
array value constructor	<collection value constructor>
array value constructor by enumeration	<array value constructor>
array value constructor by query	<array value constructor>
array value expression	<array element reference> <array value expression 1> <collection value expression>
array value expression 1	<array concatenation>
as clause	<derived column>
as subquery clause	<table contents source>
assertion definition	<schema element> <SQL schema definition statement>
assigned row	<multiple column assignment>
asterisk	<aggregate function> <all fields reference> <bracketed comment introducer> <bracketed comment terminator> <Fortran type specification> <interval term> <qualified asterisk> <regular factor> <select list> <SQL special character> <term>
asterisked identifier	<asterisked identifier chain>
asterisked identifier chain	<qualified asterisk>
attribute default	<attribute definition>
attribute definition	<add attribute definition> <member>
attribute name	<attribute definition> <dereference operation> <drop attribute definition> <list of attributes>
attribute or method reference	<nonparenthesized value expression primary>
attributes specification	<prepare statement>
attributes variable	<attributes specification>
authorization identifier	<grantee> <module authorization identifier> <schema authorization identifier>
basic identifier chain	<column reference> <SQL parameter reference>
basic sequence generator option	<alter identity column option> <alter sequence generator option> <common sequence generator option>
between predicate	<predicate>
between predicate part 2	<between predicate> <when operand>
binary large object string type	<predefined type>
binary set function	<aggregate function>
binary set function type	<binary set function>
binary string literal	<general literal>
bit string literal	<nondelimiter token>
blob concatenation	<blob value expression>
blob factor	<blob concatenation> <blob value expression>
blob overlay function	<blob value function>
blob position expression	<position expression>
blob primary	<blob factor>
blob substring function	<blob value function>
blob trim function	<blob value function>
blob trim operands	<blob trim function>
blob trim source	<blob trim operands>
blob value expression	<blob concatenation> <blob overlay function> <blob position expression> <blob substring function> <blob trim source> <escape octet> <octet pattern> <string value expression> <trim octet>
blob value function	<string value function>
boolean factor	<boolean term>
boolean literal	<general literal>
boolean predicand	<boolean primary> <row value constructor predicand>
boolean primary	<boolean test>
boolean term	<boolean term> <boolean value expression>
boolean test	<boolean factor>
boolean type	<predefined type>
boolean value expression	<boolean value expression> <contextually typed row value constructor> <parenthesized boolean value expression> <row value constructor> <search condition> <value expression>
bracketed comment	<comment>
bracketed comment contents	<bracketed comment>
bracketed comment introducer	<bracketed comment>
bracketed comment terminator	<bracketed comment>
C array locator variable	<C derived variable>
C array specification	<C character variable> <C NCHAR variable> <C NCHAR VARYING variable> <C VARCHAR variable>
C BLOB locator variable	<C derived variable>
C BLOB variable	<C derived variable>
C character type	<C character variable>
C character variable	<C variable specification>
C class modifier	<C variable definition>
C CLOB locator variable	<C derived variable>
C CLOB variable	<C derived variable>
C derived variable	<C variable specification>
C host identifier	<C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable> <host identifier>
C initial value	<C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable>
C multiset locator variable	<C derived variable>
C NCHAR variable	<C derived variable>
C NCHAR VARYING variable	<C derived variable>
C NCLOB variable	<C derived variable>
C numeric variable	<C variable specification>
C REF variable	<C derived variable>
C storage class	<C variable definition>
C user-defined type locator variable	<C derived variable>
C user-defined type variable	<C derived variable>
C VARCHAR variable	<C derived variable>
C variable definition	<host variable definition>
C variable specification	<C variable definition>
call statement	<SQL control statement>
cardinality expression	<numeric value function>
case abbreviation	<case expression>
case expression	<nonparenthesized value expression primary>
case operand	<simple case>
case specification	<case expression>
cast function	<user-defined cast definition>
cast operand	<cast specification>
cast option	<user-defined type option>
cast specification	<nonparenthesized value expression primary>
cast target	<cast specification>
cast to distinct	<cast option>
cast to distinct identifier	<cast to distinct>
cast to ref	<ref cast option>
cast to ref identifier	<cast to ref>
cast to source	<cast option>
cast to source identifier	<cast to source>
cast to type	<ref cast option>
cast to type identifier	<cast to type>
catalog name	<schema name>
catalog name characteristic	<set catalog statement>
ceiling function	<numeric value function>
char length expression	<length expression>
char length units	<char length expression> <character overlay function> <character substring function> <large object length> <string position expression>
character enumeration	<character enumeration exclude> <character enumeration include> <regular character set>
character enumeration exclude	<regular character set>
character enumeration include	<regular character set>
character factor	<character value expression> <concatenation>
character like predicate	<like predicate>
character like predicate part 2	<character like predicate> <when operand>
character overlay function	<character value function>
character pattern	<character like predicate part 2>
character primary	<character factor>
character representation	<Ada initial value> <C initial value> <character string literal> <COBOL variable definition> <national character string literal> <PL/I variable definition> <Unicode representation>
character set definition	<schema element> <SQL schema definition statement>
character set name	<character set definition> <drop character set statement> <implementation-defined character set name> <object name> <standard character set name> <user-defined character set name>
character set name characteristic	<set names statement>
character set source	<character set definition>
character set specification	<Ada CLOB variable> <Ada qualified type specification> <C character variable> <C CLOB variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C VARCHAR variable> <character set source> <character set specification list> <character string literal> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <collation definition> <embedded character set declaration> <Fortran CLOB variable> <Fortran type specification> <module character set specification> <MUMPS CLOB variable> <Pascal CLOB variable> <Pascal type specification> <PL/I CLOB variable> <PL/I type specification> <predefined type> <schema character set specification> <source character set specification> <target character set specification> <Unicode character string literal>
character set specification list	<module collation specification> <set session collation statement>
character specifier	<character enumeration> <regular primary>
character string literal	<delimiter token> <external routine name> <general literal>
character string type	<predefined type>
character substring function	<character value function>
character transliteration	<character value function>
character value expression	<character overlay function> <character pattern> <character substring function> <character transliteration> <concatenation> <escape character> <fold> <normalize function> <regular expression substring function> <similar pattern> <string value expression> <transcoding> <trim character> <trim source>
character value function	<string value function>
check constraint definition	<column constraint> <domain constraint> <table constraint>
circumflex	<regular character set> <SQL special character>
close statement	<SQL data statement>
COBOL array locator variable	<COBOL derived type specification>
COBOL binary integer	<COBOL integer type>
COBOL BLOB locator variable	<COBOL derived type specification>
COBOL BLOB variable	<COBOL derived type specification>
COBOL character type	<COBOL type specification>
COBOL CLOB locator variable	<COBOL derived type specification>
COBOL CLOB variable	<COBOL derived type specification>
COBOL derived type specification	<COBOL type specification>
COBOL host identifier	<COBOL variable definition> <host identifier>
COBOL integer type	<COBOL type specification>
COBOL multiset locator variable	<COBOL derived type specification>
COBOL national character type	<COBOL type specification>
COBOL NCLOB variable	<COBOL derived type specification>
COBOL nines	<COBOL binary integer> <COBOL nines specification>
COBOL nines specification	<COBOL numeric type>
COBOL numeric type	<COBOL type specification>
COBOL REF variable	<COBOL derived type specification>
COBOL type specification	<COBOL variable definition>
COBOL user-defined type locator variable	<COBOL derived type specification>
COBOL user-defined type variable	<COBOL derived type specification>
COBOL variable definition	<host variable definition>
collate clause	<attribute definition> <character factor> <character set definition> <column definition> <domain definition> <grouping column reference> <predefined type> <window partition column reference>
collation definition	<schema element> <SQL schema definition statement>
collation name	<collate clause> <collation definition> <drop collation statement> <existing collation name> <module collation specification> <object name>
collation specification	<set session collation statement>
collection derived table	<table primary>
collection type	<data type>
collection value constructor	<nonparenthesized value expression primary>
collection value expression	<cardinality expression> <collection derived table> <common value expression> <table function derived table>
colon	<Ada assignment operator> <Ada variable definition> <character enumeration> <day-time interval> <double colon> <embedded variable name> <host parameter name> <Pascal variable definition> <SQL special character> <time interval> <time value> <time zone interval>
column constraint	<column constraint definition>
column constraint definition	<column definition> <column option list>
column default option	<like options>
column definition	<add column definition> <table element>
column name	<alter column definition> <as clause> <column definition> <column name list> <column options> <column reference> <cycle column> <cycle mark column> <drop column definition> <object column> <path column> <self-referencing column name> <sequence column> <table function column list element> <view column option>
column name list	<all fields column name list> <as subquery clause> <corresponding column list> <derived column list> <insert column list> <join column list> <privilege column list> <reference column list> <trigger column list> <unique column list> <updatability clause> <view column list> <with column list>
column option list	<column options>
column options	<table element>
column reference	<grouping column reference> <grouping operation> <nonparenthesized value expression primary> <simple target specification> <target array reference> <target specification> <window partition column reference>
comma	<Ada variable definition> <alter transform action list> <array element list> <binary set function> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable> <case abbreviation> <character set specification list> <column name list> <condition information> <constraint name list> <contextually typed row value constructor> <contextually typed row value constructor element list> <contextually typed row value expression list> <cycle column list> <data type list> <drop transform element list> <exact numeric type> <explicit row value constructor> <fetch target list> <Fortran variable definition> <free locator statement> <get descriptor information> <grant privilege statement> <grant role statement> <grouping column reference list> <grouping element list> <grouping operation> <grouping set list> <hold locator statement> <host parameter declaration list> <hypothetical set function value expression list> <in value list> <into arguments> <list of attributes> <member list> <merge insert value list> <method specification list> <modulus expression> <multiple group specification> <multiset element list> <MUMPS character variable> <MUMPS numeric variable> <MUMPS type specification> <object privileges> <ordinary grouping set list> <Pascal variable definition> <PL/I type specification> <PL/I variable definition> <power function> <privilege method list> <revoke privilege statement> <revoke role statement> <row type body> <row value constructor element list> <row value expression list> <schema name list> <select list> <select target list> <session characteristic list> <set clause list> <set descriptor information> <set target list> <single datetime field> <sort specification list> <SQL argument list> <SQL parameter declaration list> <SQL special character> <start transaction statement> <statement information> <table element list> <table function column list> <table reference list> <transaction characteristics> <transform element list> <type list> <upper limit> <using arguments> <view element list> <width bucket function> <window definition list> <window partition column reference list> <with list>
comment	<separator>
comment character	<bracketed comment contents> <simple comment>
commit statement	<SQL transaction statement>
common sequence generator option	<common sequence generator options>
common sequence generator options	<identity column specification> <sequence generator option>
common value expression	<contextually typed row value constructor> <row value constructor> <row value constructor predicand> <value expression>
comp op	<comparison predicate part 2> <quantified comparison predicate part 2>
comparison predicate	<predicate>
comparison predicate part 2	<comparison predicate> <when operand>
computational operation	<set function type>
concatenation	<character value expression>
concatenation operator	<array concatenation> <blob concatenation> <concatenation> <delimiter token>
condition	<embedded exception declaration>
condition action	<embedded exception declaration>
condition information	<SQL diagnostics information>
condition information item	<condition information>
condition information item name	<condition information item>
condition number	<condition information>
connect statement	<SQL connection statement>
connection name	<connection object> <connection target>
connection object	<disconnect object> <set connection statement>
connection target	<connect statement>
connection user name	<connection target>
constraint characteristics	<assertion definition> <column constraint definition> <domain constraint> <table constraint definition>
constraint check time	<constraint characteristics>
constraint name	<assertion definition> <constraint name definition> <constraint name list> <drop assertion statement> <drop domain constraint definition> <drop table constraint definition> <SQL condition>
constraint name definition	<column constraint definition> <domain constraint> <table constraint definition>
constraint name list	<set constraints mode statement>
contextually typed row value constructor	<contextually typed row value expression>
contextually typed row value constructor element	<contextually typed row value constructor> <contextually typed row value constructor element list>
contextually typed row value constructor element list	<contextually typed row value constructor>
contextually typed row value expression	<assigned row> <contextually typed row value expression list>
contextually typed row value expression list	<contextually typed table value constructor>
contextually typed table value constructor	<from constructor>
contextually typed value specification	<contextually typed row value constructor> <contextually typed row value constructor element> <merge insert value element> <update source>
correlation name	<merge correlation name> <new values correlation name> <old values correlation name> <table primary>
corresponding column list	<corresponding spec>
corresponding spec	<non-join query expression> <non-join query term>
cross join	<joined table>
cube list	<grouping element> <grouping set>
current collation specification	<general value specification>
current date value function	<datetime value function>
current local time value function	<datetime value function>
current local timestamp value function	<datetime value function>
current time value function	<datetime value function>
current timestamp value function	<datetime value function>
cursor attribute	<cursor attributes>
cursor holdability	<cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
cursor intent	<allocate cursor statement>
cursor name	<close statement> <declare cursor> <delete statement: positioned> <dynamic cursor name> <dynamic declare cursor> <fetch statement> <open statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned>
cursor returnability	<cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
cursor scrollability	<cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
cursor sensitivity	<cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
cursor specification	<declare cursor> <direct select statement: multiple rows> <dynamic select statement>
cycle clause	<search or cycle clause>
cycle column	<cycle column list>
cycle column list	<cycle clause>
cycle mark column	<cycle clause>
cycle mark value	<cycle clause>
data type	<array type> <attribute definition> <cast target> <column definition> <data type list> <domain definition> <field definition> <generalized invocation> <host parameter data type> <multiset type> <parameter type> <result cast from type> <returns data type> <sequence generator data type option> <source data type> <table function column list element> <target data type>
data type list	<member name> <specific method specification designator>
date literal	<datetime literal>
date string	<date literal> <delimiter token>
date value	<unquoted date string>
datetime factor	<datetime term>
datetime literal	<general literal>
datetime primary	<datetime factor>
datetime term	<datetime value expression> <interval value expression>
datetime type	<predefined type>
datetime value	<days value> <hours value> <minutes value> <months value> <years value>
datetime value expression	<common value expression> <datetime value expression> <extract source> <interval value expression>
datetime value function	<datetime primary> <default option>
day-time interval	<day-time literal>
day-time literal	<unquoted interval string>
days value	<date value> <day-time interval>
deallocate descriptor statement	<system descriptor statement>
deallocate prepared statement	<SQL dynamic statement>
declare cursor	<module contents> <statement or declaration>
default clause	<attribute default> <column definition> <column option list> <domain definition> <set column default clause> <set domain default clause>
default option	<default clause>
default specification	<contextually typed value specification>
delete rule	<referential triggered action>
delete statement: positioned	<SQL data change statement>
delete statement: searched	<direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
delimited identifier	<actual identifier> <delimiter token>
delimited identifier body	<delimited identifier>
delimited identifier part	<delimited identifier body> <Unicode identifier part>
delimiter token	<token>
dependent variable expression	<binary set function>
dereference operator	<attribute or method reference> <dereference operation> <method reference>
derived column	<select sublist>
derived column list	<table primary>
derived representation	<reference type specification>
derived table	<table primary>
describe input statement	<describe statement>
describe output statement	<describe statement>
describe statement	<SQL dynamic statement>
described object	<describe output statement>
descriptor item name	<get item information> <set item information>
descriptor name	<allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <into descriptor> <set descriptor statement> <using descriptor>
deterministic characteristic	<method characteristic> <routine characteristic>
diagnostics size	<transaction mode>
digit	<hexit> <large object length token> <SQL language character> <SQL language identifier part> <SQLSTATE char> <unsigned integer>
direct implementation-defined statement	<directly executable statement>
direct invocation	<method invocation>
direct select statement: multiple rows	<direct SQL data statement>
direct SQL data statement	<directly executable statement>
directly executable statement	<direct SQL statement>
disconnect object	<disconnect statement>
disconnect statement	<SQL connection statement>
dispatch clause	<function specification>
distinct predicate	<predicate>
distinct predicate part 2	<distinct predicate> <when operand>
domain constraint	<add domain constraint definition> <domain definition>
domain definition	<schema element> <SQL schema definition statement>
domain name	<alter domain statement> <cast target> <column definition> <domain definition> <drop domain statement> <object name>
double colon	<delimiter token> <static method invocation>
double period	<Ada qualified type specification> <Ada unqualified type specification> <delimiter token> <Pascal type specification>
double quote	<delimited identifier> <doublequote symbol> <SQL special character> <Unicode delimited identifier>
doublequote symbol	<delimited identifier part>
drop assertion statement	<SQL schema manipulation statement>
drop attribute definition	<alter type action>
drop behavior	<drop collation statement> <drop column definition> <drop column scope clause> <drop data type statement> <drop domain statement> <drop routine statement> <drop schema statement> <drop sequence generator statement> <drop table constraint definition> <drop table statement> <drop transform element list> <drop transform statement> <drop user-defined cast statement> <drop user-defined ordering statement> <drop view statement> <revoke privilege statement> <revoke role statement>
drop character set statement	<SQL schema manipulation statement>
drop collation statement	<SQL schema manipulation statement>
drop column default clause	<alter column action>
drop column definition	<alter table action>
drop column scope clause	<alter column action>
drop data type statement	<SQL schema manipulation statement>
drop domain constraint definition	<alter domain action>
drop domain default clause	<alter domain action>
drop domain statement	<SQL schema manipulation statement>
drop method specification	<alter type action>
drop role statement	<SQL schema manipulation statement>
drop routine statement	<SQL schema manipulation statement>
drop schema statement	<SQL schema manipulation statement>
drop sequence generator statement	<SQL schema manipulation statement>
drop table constraint definition	<alter table action>
drop table statement	<SQL schema manipulation statement>
drop transform element list	<alter transform action>
drop transform statement	<SQL schema manipulation statement>
drop transliteration statement	<SQL schema manipulation statement>
drop trigger statement	<SQL schema manipulation statement>
drop user-defined cast statement	<SQL schema manipulation statement>
drop user-defined ordering statement	<SQL schema manipulation statement>
drop view statement	<SQL schema manipulation statement>
dynamic close statement	<SQL dynamic data statement>
dynamic cursor name	<dynamic close statement> <dynamic delete statement: positioned> <dynamic fetch statement> <dynamic open statement> <dynamic update statement: positioned>
dynamic declare cursor	<module contents> <statement or declaration>
dynamic delete statement: positioned	<SQL dynamic data statement>
dynamic fetch statement	<SQL dynamic data statement>
dynamic open statement	<SQL dynamic data statement>
dynamic parameter specification	<general value specification> <target specification>
dynamic result sets characteristic	<alter routine characteristic> <routine characteristic>
dynamic select statement	<preparable SQL data statement>
dynamic single row select statement	<preparable SQL data statement>
dynamic update statement: positioned	<SQL dynamic data statement>
else clause	<searched case> <simple case>
embedded authorization clause	<embedded authorization declaration>
embedded authorization declaration	<statement or declaration>
embedded authorization identifier	<embedded authorization clause>
embedded character set declaration	<embedded SQL declare section> <embedded SQL MUMPS declare>
embedded collation specification	<statement or declaration>
embedded exception declaration	<statement or declaration>
embedded path specification	<statement or declaration>
embedded SQL Ada program	<embedded SQL host program>
embedded SQL begin declare	<embedded SQL declare section>
embedded SQL C program	<embedded SQL host program>
embedded SQL COBOL program	<embedded SQL host program>
embedded SQL end declare	<embedded SQL declare section>
embedded SQL Fortran program	<embedded SQL host program>
embedded SQL MUMPS declare	<embedded SQL declare section>
embedded SQL MUMPS program	<embedded SQL host program>
embedded SQL Pascal program	<embedded SQL host program>
embedded SQL PL/I program	<embedded SQL host program>
embedded transform group specification	<statement or declaration>
embedded variable name	<embedded variable specification> <indicator variable> <locator reference> <simple target specification> <simple value specification>
embedded variable specification	<general value specification> <target specification>
empty grouping set	<grouping element> <grouping set>
empty specification	<implicitly typed value specification>
end field	<interval qualifier>
equals operator	<Ada assignment operator> <C initial value> <comp op> <condition information item> <get header information> <get item information> <greater than or equals operator> <less than or equals operator> <multiple column assignment> <set clause> <set header information> <set item information> <SQL special character> <statement information item>
equals ordering form	<ordering form>
escape character	<binary string literal> <character like predicate part 2> <regular expression substring function> <similar predicate part 2> <Unicode character string literal>
escape octet	<octet like predicate part 2>
escaped character	<character specifier>
exact numeric literal	<mantissa> <unsigned numeric literal>
exact numeric type	<numeric type>
exclusive user-defined type specification	<user-defined type specification>
execute immediate statement	<SQL dynamic statement>
execute statement	<SQL dynamic statement>
existing collation name	<collation definition>
existing transliteration name	<transliteration source>
existing window name	<window specification details>
exists predicate	<predicate>
explicit row value constructor	<row value constructor> <row value constructor predicand> <row value expression>
explicit table	<simple table>
exponent	<approximate numeric literal>
exponential function	<numeric value function>
extended cursor name	<allocate cursor statement> <described object> <dynamic cursor name>
extended statement name	<SQL statement name> <statement cursor>
external body reference	<routine body>
external routine name	<alter routine characteristic> <external body reference>
external security clause	<external body reference>
externally-invoked procedure	<module contents>
extract expression	<numeric value function>
extract field	<extract expression>
extract source	<extract expression>
factor	<interval term> <term>
fetch orientation	<dynamic fetch statement> <fetch statement>
fetch statement	<SQL data statement>
fetch target list	<fetch statement>
field definition	<row type body>
field name	<field definition> <field reference>
field reference	<nonparenthesized value expression primary>
filter clause	<aggregate function>
finality	<user-defined type option>
floor function	<numeric value function>
fold	<character value function>
Fortran array locator variable	<Fortran derived type specification>
Fortran BLOB locator variable	<Fortran derived type specification>
Fortran BLOB variable	<Fortran derived type specification>
Fortran CLOB locator variable	<Fortran derived type specification>
Fortran CLOB variable	<Fortran derived type specification>
Fortran derived type specification	<Fortran type specification>
Fortran host identifier	<Fortran variable definition> <host identifier>
Fortran multiset locator variable	<Fortran derived type specification>
Fortran REF variable	<Fortran derived type specification>
Fortran type specification	<Fortran variable definition>
Fortran user-defined type locator variable	<Fortran derived type specification>
Fortran user-defined type variable	<Fortran derived type specification>
Fortran variable definition	<host variable definition>
free locator statement	<SQL data statement>
from clause	<table expression>
from constructor	<insert columns and source>
from default	<insert columns and source>
from sql	<transform element>
from sql function	<from sql>
from subquery	<insert columns and source>
full ordering form	<ordering form>
function specification	<SQL-invoked function>
general literal	<literal> <unsigned literal>
general set function	<aggregate function>
general value specification	<unsigned value specification> <using argument> <value specification>
generalized expression	<SQL argument>
generalized invocation	<method invocation>
generation clause	<column definition>
generation expression	<generation clause>
generation rule	<generation clause>
get descriptor information	<get descriptor statement>
get descriptor statement	<system descriptor statement>
get diagnostics statement	<SQL diagnostics statement>
get header information	<get descriptor information>
get item information	<get descriptor information>
global or local	<table scope>
go to	<condition action>
goto target	<go to>
grant privilege statement	<grant statement>
grant role statement	<grant statement>
grant statement	<schema element> <SQL schema definition statement>
grantee	<grant privilege statement> <grant role statement> <revoke privilege statement> <revoke role statement>
grantor	<grant privilege statement> <grant role statement> <revoke privilege statement> <revoke role statement> <role definition>
greater than operator	<comp op> <greater than or equals operator> <not equals operator> <right arrow> <SQL special character>
greater than or equals operator	<comp op> <delimiter token>
group by clause	<table expression>
group name	<alter group> <group specification> <single group specification> <transform group> <transform group element>
group specification	<multiple group specification>
grouping column reference	<grouping column reference list> <ordinary grouping set>
grouping column reference list	<ordinary grouping set>
grouping element	<grouping element list>
grouping element list	<group by clause>
grouping operation	<set function specification>
grouping set	<grouping set list>
grouping set list	<grouping sets specification>
grouping sets specification	<grouping element> <grouping set>
handler declaration	<statement or declaration>
having clause	<table expression>
header item name	<get header information> <set header information>
hex string literal	<nondelimiter token>
hexit	<binary string literal> <Unicode 4 digit escape value> <Unicode 6 digit escape value>
high value	<upper limit>
hold locator statement	<SQL data statement>
host identifier	<embedded variable name>
host label identifier	<goto target>
host parameter data type	<host parameter declaration>
host parameter declaration	<host parameter declaration list>
host parameter declaration list	<externally-invoked procedure>
host parameter name	<host parameter declaration> <host parameter specification> <indicator parameter> <locator reference> <simple value specification>
host parameter specification	<general value specification> <simple target specification> <target specification>
host PL/I label variable	<goto target>
host variable definition	<embedded SQL declare section> <embedded SQL MUMPS declare>
hours value	<day-time interval> <time interval> <time value> <time zone interval>
hypothetical set function	<ordered set function>
hypothetical set function value expression list	<hypothetical set function>
identifier	<asterisked identifier> <attribute name> <cast to distinct identifier> <cast to ref identifier> <cast to source identifier> <cast to type identifier> <catalog name> <column name> <correlation name> <external routine name> <field name> <group name> <host parameter name> <identifier chain> <method name> <new values table alias> <old values table alias> <procedure name> <qualified identifier> <query name> <regular character set identifier> <role name> <savepoint name> <SQL parameter name> <SQL-client module name> <statement name> <user identifier> <window name>
identifier body	<regular identifier>
identifier chain	<basic identifier chain>
identifier extend	<identifier part>
identifier part	<identifier body>
identifier start	<identifier body> <identifier part>
identity column specification	<column definition>
identity option	<like options>
implementation-defined character set name	<character set specification>
implicitly typed value specification	<cast operand> <contextually typed value specification> <default option>
in predicate	<predicate>
in predicate part 2	<in predicate> <when operand>
in predicate value	<in predicate part 2>
in value list	<in predicate value>
in-line window specification	<window name or specification>
inclusive user-defined type specification	<user-defined type specification>
independent variable expression	<binary set function>
indicator parameter	<host parameter specification>
indicator variable	<embedded variable specification>
input using clause	<dynamic open statement> <parameter using clause>
insert column list	<from constructor> <from subquery> <merge insert specification>
insert columns and source	<insert statement>
insert statement	<direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
insertion target	<insert statement>
instantiable clause	<user-defined type option>
interval absolute value function	<interval value function>
interval factor	<interval term>
interval fractional seconds precision	<end field> <single datetime field>
interval leading field precision	<single datetime field> <start field>
interval literal	<general literal>
interval primary	<interval factor> <time zone specifier>
interval qualifier	<interval literal> <interval primary> <interval type> <interval value expression>
interval string	<delimiter token> <interval literal>
interval term	<datetime value expression> <interval term 1> <interval term 2> <interval value expression>
interval term 1	<interval value expression>
interval term 2	<interval term>
interval type	<predefined type>
interval value expression	<common value expression> <datetime value expression> <extract source> <interval absolute value function> <interval value expression 1> <set time zone value>
interval value expression 1	<interval value expression>
interval value function	<interval primary>
into argument	<into arguments>
into arguments	<output using clause>
into descriptor	<output using clause>
introducer	<character string literal> <Unicode character string literal>
inverse distribution function	<ordered set function>
inverse distribution function argument	<inverse distribution function>
inverse distribution function type	<inverse distribution function>
isolation level	<transaction mode>
item number	<get descriptor information> <set descriptor information>
join column list	<named columns join>
join condition	<join specification>
join specification	<qualified join>
join type	<natural join> <qualified join>
joined table	<query expression body> <query primary> <query term> <table primary> <table primary or joined table>
key word	<nondelimiter token>
language clause	<alter routine characteristic> <method characteristic> <routine characteristic> <SQL-client module definition>
language name	<language clause>
large object length	<Ada BLOB variable> <Ada CLOB variable> <binary large object string type> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <character string type> <COBOL BLOB variable> <COBOL CLOB variable> <COBOL NCLOB variable> <Fortran BLOB variable> <Fortran CLOB variable> <MUMPS BLOB variable> <MUMPS CLOB variable> <national character string type> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable>
large object length token	<large object length> <nondelimiter token>
lateral derived table	<table primary>
left brace	<repeat factor> <SQL special character>
left bracket	<C array specification> <character enumeration> <left bracket or trigraph> <Pascal type specification> <regular character set> <SQL special character>
left bracket or trigraph	<array element reference> <array type> <array value constructor by enumeration> <empty specification> <multiset value constructor by enumeration> <target array element specification> <update target>
left bracket trigraph	<delimiter token> <left bracket or trigraph>
left paren	<absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <add transform element list> <aggregate function> <all fields reference> <alter group> <approximate numeric type> <array value constructor by query> <as subquery clause> <assertion definition> <binary large object string type> <binary set function> <blob overlay function> <blob position expression> <blob substring function> <blob trim function> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <cardinality expression> <case abbreviation> <cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <ceiling function> <char length expression> <character overlay function> <character string type> <character substring function> <character transliteration> <check constraint definition> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <COBOL nines> <collection derived table> <contextually typed row value constructor> <corresponding spec> <cube list> <current collation specification> <current local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop transform element list> <drop user-defined cast statement> <empty grouping set> <end field> <exact numeric type> <explicit row value constructor> <exponential function> <extract expression> <filter clause> <floor function> <fold> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <generation expression> <grouping operation> <grouping sets specification> <host parameter declaration list> <hypothetical set function> <identity column specification> <in predicate value> <interval absolute value function> <interval value expression> <inverse distribution function> <list of attributes> <member list> <merge insert specification> <merge insert value list> <modulus expression> <multiset element reference> <multiset set function> <multiset value constructor by query> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <named columns join> <national character string type> <natural logarithm> <non-join query primary> <normalize function> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <power function> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <repeatable clause> <rollup list> <row type body> <sample clause> <set target list> <single datetime field> <SQL argument list> <SQL parameter declaration list> <SQL prefix> <SQL special character> <square root> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table function column list> <table function derived table> <table primary> <table value constructor by query> <target table> <transcoding> <transform group> <triggered action> <trim function> <type predicate part 2> <unique constraint definition> <user-defined cast definition> <view element list> <width bucket function> <window function type> <window specification> <with list element> <within group specification>
length	<Ada qualified type specification> <Ada unqualified type specification> <C array specification> <character string type> <COBOL character type> <COBOL national character type> <COBOL nines> <Fortran type specification> <MUMPS length specification> <national character string type> <Pascal type specification> <PL/I type specification>
length expression	<numeric value function>
less than operator	<comp op> <less than or equals operator> <not equals operator> <SQL special character>
less than or equals operator	<comp op> <delimiter token>
level of isolation	<isolation level>
levels clause	<view definition>
like clause	<table element>
like options	<like clause>
like predicate	<predicate>
list of attributes	<derived representation>
literal	<default option> <simple value specification> <value specification>
local or schema qualified name	<table name>
local or schema qualifier	<local or schema qualified name>
local qualified name	<cursor name>
local qualifier	<local qualified name>
locator indication	<host parameter data type> <parameter type> <result cast from type> <returns data type>
locator reference	<free locator statement> <hold locator statement>
low value	<repeat factor>
major category	<SQL condition>
mantissa	<approximate numeric literal>
map category	<ordering category>
map function specification	<map category>
match predicate	<predicate>
match predicate part 2	<match predicate> <when operand>
match type	<references specification>
maximum dynamic result sets	<dynamic result sets characteristic>
member	<member list>
member list	<representation>
member name	<specific routine designator>
member name alternatives	<member name>
member predicate	<predicate>
member predicate part 2	<member predicate> <when operand>
merge correlation name	<merge statement>
merge insert specification	<merge when not matched clause>
merge insert value element	<merge insert value list>
merge insert value list	<merge insert specification>
merge operation specification	<merge statement>
merge statement	<direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
merge update specification	<merge when matched clause>
merge when clause	<merge operation specification>
merge when matched clause	<merge when clause>
merge when not matched clause	<merge when clause>
method characteristic	<method characteristics>
method characteristics	<original method specification>
method invocation	<new invocation> <nonparenthesized value expression primary>
method name	<direct invocation> <generalized invocation> <member name alternatives> <method reference> <method specification designator> <mutated set clause> <partial method specification> <specific method specification designator> <static method invocation>
method specification	<method specification list>
method specification designator	<SQL-invoked function>
method specification list	<user-defined type body>
minus sign	<character enumeration> <date value> <datetime value expression> <interval value expression> <numeric value expression> <right arrow> <sign> <simple comment introducer> <SQL special character> <year-month literal>
minutes value	<day-time interval> <time interval> <time value> <time zone interval>
module authorization clause	<SQL-client module definition>
module authorization identifier	<embedded authorization identifier> <module authorization clause>
module character set specification	<module name clause>
module collation	<SQL-client module definition>
module collation specification	<module collation>
module collation	<embedded collation specification>
module contents	<SQL-client module definition>
module name clause	<SQL-client module definition>
module path specification	<SQL-client module definition>
module transform group specification	<SQL-client module definition>
modulus expression	<numeric value function>
months value	<date value> <year-month literal>
multiple column assignment	<set clause>
multiple group specification	<transform group specification>
multiplier	<large object length> <large object length token> <nondelimiter token>
multiset element	<multiset element list>
multiset element list	<multiset value constructor by enumeration>
multiset element reference	<nonparenthesized value expression primary>
multiset primary	<multiset term>
multiset set function	<multiset value function>
multiset term	<multiset term> <multiset value expression>
multiset type	<Ada multiset locator variable> <C multiset locator variable> <COBOL multiset locator variable> <collection type> <Fortran multiset locator variable> <MUMPS multiset locator variable> <Pascal multiset locator variable> <PL/I multiset locator variable>
multiset value constructor	<collection value constructor>
multiset value constructor by enumeration	<multiset value constructor>
multiset value constructor by query	<multiset value constructor>
multiset value expression	<collection value expression> <member predicate part 2> <multiset set function> <multiset value expression> <submultiset predicate part 2>
multiset value function	<multiset primary>
multiset value expression	<multiset element reference>
MUMPS array locator variable	<MUMPS derived type specification>
MUMPS BLOB locator variable	<MUMPS derived type specification>
MUMPS BLOB variable	<MUMPS derived type specification>
MUMPS character variable	<MUMPS variable definition>
MUMPS CLOB locator variable	<MUMPS derived type specification>
MUMPS CLOB variable	<MUMPS derived type specification>
MUMPS derived type specification	<MUMPS variable definition>
MUMPS host identifier	<host identifier> <MUMPS character variable> <MUMPS numeric variable>
MUMPS length specification	<MUMPS character variable>
MUMPS multiset locator variable	<MUMPS derived type specification>
MUMPS numeric variable	<MUMPS variable definition>
MUMPS REF variable	<MUMPS derived type specification>
MUMPS type specification	<MUMPS numeric variable>
MUMPS user-defined type locator variable	<MUMPS derived type specification>
MUMPS user-defined type variable	<MUMPS derived type specification>
MUMPS variable definition	<host variable definition>
mutated set clause	<mutated target> <set target>
mutated target	<mutated set clause>
named columns join	<join specification>
national character string literal	<general literal> <nondelimiter token>
national character string type	<predefined type>
natural join	<joined table>
natural logarithm	<numeric value function>
nesting option	<describe input statement> <describe output statement>
new specification	<nonparenthesized value expression primary>
new values correlation name	<old or new values alias>
new values table alias	<old or new values alias>
new window name	<window definition>
newline	<simple comment>
next value expression	<nonparenthesized value expression primary>
non-cycle mark value	<cycle clause>
non-escaped character	<character specifier>
non-join query expression	<non-join query primary> <query expression body>
non-join query primary	<non-join query term> <query primary>
non-join query term	<non-join query expression> <query term>
non-reserved word	<key word>
non-second primary datetime field	<end field> <primary datetime field> <single datetime field> <start field>
nondelimiter token	<token>
nondoublequote character	<delimited identifier part>
nonparenthesized value expression primary	<boolean predicand> <row value special case> <value expression primary>
nonquote character	<character representation> <comment character>
normalize function	<character value function>
normalized predicate	<predicate>
not equals operator	<comp op> <delimiter token>
null ordering	<sort specification>
null predicate	<predicate>
null predicate part 2	<null predicate> <when operand>
null specification	<implicitly typed value specification>
null-call clause	<alter routine characteristic> <method characteristic> <routine characteristic>
number of conditions	<diagnostics size>
numeric primary	<factor>
numeric type	<predefined type>
numeric value expression	<absolute value expression> <array element reference> <ceiling function> <common value expression> <dependent variable expression> <exponential function> <floor function> <independent variable expression> <inverse distribution function argument> <natural logarithm> <numeric value expression> <numeric value expression base> <numeric value expression exponent> <repeat argument> <sample percentage> <square root> <start position> <string length> <width bucket bound 1> <width bucket bound 2> <width bucket count> <width bucket operand>
numeric value expression base	<power function>
numeric value expression dividend	<modulus expression>
numeric value expression divisor	<modulus expression>
numeric value expression exponent	<power function>
numeric value function	<numeric primary>
object column	<mutated target> <update target>
object name	<privileges>
object privileges	<privileges>
occurrences	<allocate descriptor statement>
octet length expression	<length expression>
octet like predicate	<like predicate>
octet like predicate part 2	<octet like predicate> <when operand>
octet pattern	<octet like predicate part 2>
old or new values alias	<old or new values alias list>
old or new values alias list	<trigger definition>
old values correlation name	<old or new values alias>
old values table alias	<old or new values alias>
only spec	<table primary>
open statement	<SQL data statement>
order by clause	<array value constructor by query> <cursor specification>
ordered set function	<aggregate function>
ordering category	<equals ordering form> <full ordering form>
ordering form	<user-defined ordering definition>
ordering specification	<sort specification>
ordinary grouping set	<grouping element> <grouping set> <ordinary grouping set list>
ordinary grouping set list	<cube list> <rollup list>
original method specification	<add original method specification> <method specification>
outer join type	<join type>
output using clause	<dynamic fetch statement> <result using clause>
overlaps predicate	<predicate> <case operand>
overlaps predicate part 1	<overlaps predicate>
overlaps predicate part 2	<overlaps predicate> <when operand>
override clause	<from constructor> <from subquery> <merge insert specification>
overriding method specification	<add overriding method specification> <method specification>
pad characteristic	<collation definition>
parameter mode	<SQL parameter declaration>
parameter style	<parameter style clause>
parameter style clause	<alter routine characteristic> <external body reference> <method characteristic> <routine characteristic>
parameter type	<SQL parameter declaration>
parameter using clause	<execute statement>
parenthesized boolean value expression	<boolean predicand>
parenthesized value expression	<value expression primary>
partial method specification	<original method specification> <overriding method specification>
Pascal array locator variable	<Pascal derived type specification>
Pascal BLOB locator variable	<Pascal derived type specification>
Pascal BLOB variable	<Pascal derived type specification>
Pascal CLOB locator variable	<Pascal derived type specification>
Pascal CLOB variable	<Pascal derived type specification>
Pascal derived type specification	<Pascal type specification>
Pascal host identifier	<host identifier> <Pascal variable definition>
Pascal multiset locator variable	<Pascal derived type specification>
Pascal REF variable	<Pascal derived type specification>
Pascal type specification	<Pascal variable definition>
Pascal user-defined type locator variable	<Pascal derived type specification>
Pascal user-defined type variable	<Pascal derived type specification>
Pascal variable definition	<host variable definition>
path column	<cycle clause>
path specification	<embedded path specification> <module path specification> <schema path specification>
path-resolved user-defined type name	<Ada user-defined type locator variable> <Ada user-defined type variable> <C user-defined type locator variable> <C user-defined type variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <data type> <exclusive user-defined type specification> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <general value specification> <generalized expression> <group specification> <inclusive user-defined type specification> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <referenceable view specification> <referenced type> <static method invocation> <supertype name> <table contents source> <target subtype> <transform group characteristic>
percent	<regular primary> <SQL special character>
period	<Ada qualified type specification> <all fields reference> <asterisked identifier chain> <character set name> <COBOL variable definition> <column reference> <direct invocation> <double period> <exact numeric literal> <field reference> <generalized invocation> <identifier chain> <local or schema qualified name> <local qualified name> <mutated set clause> <qualified asterisk> <routine name> <schema name> <schema qualified name> <schema qualified type name> <seconds value> <specific method name> <specific type method> <SQL special character>
PL/I array locator variable	<PL/I derived type specification>
PL/I BLOB locator variable	<PL/I derived type specification>
PL/I BLOB variable	<PL/I derived type specification>
PL/I CLOB locator variable	<PL/I derived type specification>
PL/I CLOB variable	<PL/I derived type specification>
PL/I derived type specification	<PL/I type specification>
PL/I host identifier	<host identifier> <PL/I variable definition>
PL/I multiset locator variable	<PL/I derived type specification>
PL/I REF variable	<PL/I derived type specification>
PL/I type fixed binary	<PL/I type specification>
PL/I type fixed decimal	<PL/I type specification>
PL/I type float binary	<PL/I type specification>
PL/I type specification	<PL/I variable definition>
PL/I user-defined type locator variable	<PL/I derived type specification>
PL/I user-defined type variable	<PL/I derived type specification>
PL/I variable definition	<host variable definition>
plus sign	<datetime value expression> <interval value expression> <numeric value expression> <regular factor> <sign> <SQL special character> <Unicode 6 digit escape value>
position expression	<numeric value function>
power function	<numeric value function>
precision	<approximate numeric type> <exact numeric type> <MUMPS type specification> <PL/I type specification>
predefined type	<Ada user-defined type variable> <C user-defined type variable> <COBOL user-defined type variable> <data type> <Fortran user-defined type variable> <MUMPS user-defined type variable> <Pascal user-defined type variable> <PL/I user-defined type variable> <representation> <user-defined representation>
predicate	<boolean primary>
preparable dynamic delete statement: positioned	<preparable SQL data statement>
preparable dynamic update statement: positioned	<preparable SQL data statement>
preparable implementation-defined statement	<preparable statement>
preparable SQL control statement	<preparable statement>
preparable SQL data statement	<preparable statement>
preparable SQL schema statement	<preparable statement>
preparable SQL session statement	<preparable statement>
preparable SQL transaction statement	<preparable statement>
prepare statement	<SQL dynamic statement>
primary datetime field	<extract field>
privilege column list	<action>
privilege method list	<action>
privileges	<grant privilege statement> <revoke privilege statement>
procedure name	<externally-invoked procedure>
qualified asterisk	<select sublist>
qualified identifier	<attribute or method reference> <column reference> <local or schema qualified name> <local qualified name> <routine name> <schema qualified name> <schema qualified type name> <specific method name>
qualified join	<joined table>
quantified comparison predicate	<predicate>
quantified comparison predicate part 2	<quantified comparison predicate> <when operand>
quantifier	<quantified comparison predicate part 2>
query expression	<array value constructor by query> <cursor specification> <from subquery> <multiset value constructor by query> <subquery> <table value constructor by query> <view definition> <with list element>
query expression body	<non-join query expression> <query expression>
query name	<table or query name> <with list element>
query primary	<non-join query term>
query specification	<dynamic single row select statement> <simple table>
query term	<non-join query expression> <non-join query term>
question mark	<dynamic parameter specification> <regular factor> <SQL special character>
quote	<binary string literal> <character string literal> <comment character> <date string> <interval string> <national character string literal> <quote symbol> <SQL special character> <time string> <timestamp string> <Unicode character string literal> <Unicode escape specifier>
quote symbol	<character representation>
rank function type	<hypothetical set function> <window function type>
recursive search order	<search clause>
ref cast option	<user-defined type option>
reference column list	<referenced table and columns> <referencing columns>
reference generation	<self-referencing column specification>
reference resolution	<nonparenthesized value expression primary>
reference scope check	<attribute definition> <column definition> <field definition>
reference scope check action	<reference scope check>
reference type	<Ada REF variable> <C REF variable> <COBOL REF variable> <data type> <Fortran REF variable> <MUMPS REF variable> <Pascal REF variable> <PL/I REF variable> <target subtype>
reference type specification	<user-defined type option>
reference value expression	<common value expression> <dereference operation> <reference resolution>
referenceable view specification	<view specification>
referenced table and columns	<references specification>
referenced type	<reference type>
references specification	<column constraint> <referential constraint definition>
referencing columns	<referential constraint definition>
referential action	<delete rule> <reference scope check action> <update rule>
referential constraint definition	<table constraint>
referential triggered action	<references specification>
regular character set	<regular primary>
regular character set identifier	<character enumeration>
regular expression	<regular expression> <regular primary>
regular expression substring function	<character value function>
regular factor	<regular term>
regular identifier	<actual identifier> <nondelimiter token>
regular primary	<regular factor>
regular term	<regular expression> <regular term>
regular view specification	<view specification>
relative category	<ordering category>
relative function specification	<relative category>
release savepoint statement	<SQL transaction statement>
repeat argument	<repeatable clause>
repeat factor	<regular factor>
repeatable clause	<sample clause>
representation	<user-defined type body>
reserved word	<key word>
result	<else clause> <searched when clause> <simple when clause>
result cast	<returns type>
result cast from type	<result cast>
result expression	<result>
result set cursor	<cursor intent>
result using clause	<execute statement>
return statement	<SQL control statement>
return value	<return statement>
returns clause	<function specification> <method specification designator> <partial method specification>
returns data type	<returns type>
returns table type	<returns type>
returns type	<returns clause>
revoke option extension	<revoke privilege statement>
revoke privilege statement	<revoke statement>
revoke role statement	<revoke statement>
revoke statement	<SQL schema manipulation statement>
right arrow	<delimiter token> <dereference operator>
right brace	<repeat factor> <SQL special character>
right bracket	<C array specification> <character enumeration> <Pascal type specification> <regular character set> <right bracket or trigraph> <SQL special character>
right bracket or trigraph	<array element reference> <array type> <array value constructor by enumeration> <empty specification> <multiset value constructor by enumeration> <target array element specification> <update target>
right bracket trigraph	<delimiter token> <right bracket or trigraph>
right paren	<absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <add transform element list> <aggregate function> <all fields reference> <alter group> <approximate numeric type> <array value constructor by query> <as subquery clause> <assertion definition> <binary large object string type> <binary set function> <blob overlay function> <blob position expression> <blob substring function> <blob trim function> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <cardinality expression> <case abbreviation> <cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <ceiling function> <char length expression> <character overlay function> <character string type> <character substring function> <character transliteration> <check constraint definition> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <COBOL nines> <collection derived table> <contextually typed row value constructor> <corresponding spec> <cube list> <current collation specification> <current local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop transform element list> <drop user-defined cast statement> <empty grouping set> <end field> <exact numeric type> <explicit row value constructor> <exponential function> <extract expression> <filter clause> <floor function> <fold> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <generation expression> <grouping operation> <grouping sets specification> <host parameter declaration list> <hypothetical set function> <identity column specification> <in predicate value> <interval absolute value function> <interval value expression> <inverse distribution function> <list of attributes> <member list> <merge insert specification> <merge insert value list> <modulus expression> <multiset element reference> <multiset set function> <multiset value constructor by query> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <named columns join> <national character string type> <natural logarithm> <non-join query primary> <normalize function> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <power function> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <repeatable clause> <rollup list> <row type body> <sample clause> <set target list> <single datetime field> <SQL argument list> <SQL parameter declaration list> <SQL special character> <SQL terminator> <square root> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table function column list> <table function derived table> <table primary> <table value constructor by query> <target table> <transcoding> <transform group> <triggered action> <trim function> <type predicate part 2> <unique constraint definition> <user-defined cast definition> <view element list> <width bucket function> <window function type> <window specification> <with list element> <within group specification>
rights clause	<SQL routine spec>
role definition	<schema element> <SQL schema definition statement>
role granted	<grant role statement>
role name	<authorization identifier> <drop role statement> <role definition> <role granted> <role revoked>
role revoked	<revoke role statement>
role specification	<set role statement>
rollback statement	<SQL transaction statement>
rollup list	<grouping element> <grouping set>
routine body	<SQL-invoked function> <SQL-invoked procedure>
routine characteristic	<routine characteristics>
routine characteristics	<function specification> <SQL-invoked procedure>
routine invocation	<call statement> <constructor method selection> <method selection> <new invocation> <new specification> <nonparenthesized value expression primary> <static method selection>
routine name	<routine invocation>
routine type	<specific routine designator>
row subquery	<explicit row value constructor>
row type	<data type>
row type body	<row type>
row value constructor	<table row value expression>
row value constructor element	<explicit row value constructor> <row value constructor element list>
row value constructor element list	<explicit row value constructor>
row value constructor predicand	<row value predicand>
row value expression	<in value list> <value expression>
row value expression list	<table value constructor>
row value predicand	<between predicate> <between predicate part 2> <case operand> <character like predicate> <comparison predicate> <comparison predicate part 2> <in predicate> <match predicate> <member predicate> <null predicate> <octet like predicate> <quantified comparison predicate> <row value predicand 1> <row value predicand 2> <row value predicand 3> <row value predicand 4> <set predicate> <similar predicate> <submultiset predicate> <type predicate> <when operand>
row value predicand 1	<overlaps predicate part 1>
row value predicand 2	<overlaps predicate part 2>
row value predicand 3	<distinct predicate>
row value predicand 4	<distinct predicate part 2>
row value special case	<contextually typed row value expression> <row value expression> <row value predicand> <table row value expression>
sample clause	<table reference>
sample method	<sample clause>
sample percentage	<sample clause>
savepoint clause	<rollback statement>
savepoint level indication	<routine characteristic>
savepoint name	<savepoint specifier>
savepoint specifier	<release savepoint statement> <savepoint clause> <savepoint statement>
savepoint statement	<SQL transaction statement>
scalar subquery	<nonparenthesized value expression primary>
scale	<exact numeric type> <MUMPS type specification> <PL/I type specification>
schema authorization identifier	<schema name clause>
schema character set or path	<schema definition>
schema character set specification	<schema character set or path>
schema definition	<SQL schema definition statement>
schema element	<schema definition>
schema function	<schema routine>
schema name	<character set name> <drop schema statement> <embedded authorization clause> <local or schema qualifier> <module authorization clause> <routine name> <schema name clause> <schema name list> <schema qualified name> <schema qualified type name> <specific method name>
schema name characteristic	<set schema statement>
schema name clause	<schema definition>
schema name list	<path specification>
schema path specification	<schema character set or path>
schema procedure	<schema routine>
schema qualified name	<collation name> <constraint name> <domain name> <schema qualified routine name> <sequence generator name> <specific name> <transcoding name> <transliteration name> <trigger name>
schema qualified routine name	<function specification> <member name alternatives> <SQL-invoked procedure>
schema qualified type name	<user-defined type name>
schema routine	<schema element> <SQL-invoked routine>
schema-resolved user-defined type name	<alter transform statement> <drop data type statement> <drop transform statement> <drop user-defined ordering statement> <method specification designator> <object name> <specific routine designator> <transform definition> <user-defined ordering definition> <user-defined type body>
scope clause	<add column scope clause> <column option list> <reference type> <view column option>
scope option	<descriptor name> <extended cursor name> <extended statement name> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned>
search clause	<search or cycle clause>
search condition	<assertion definition> <check constraint definition> <delete statement: searched> <filter clause> <having clause> <join condition> <merge statement> <searched when clause> <triggered action> <update statement: searched> <where clause>
search or cycle clause	<with list element>
searched case	<case specification>
searched when clause	<searched case>
seconds fraction	<seconds value>
seconds integer value	<seconds value>
seconds value	<day-time interval> <time interval> <time value>
select list	<query specification> <select statement: single row>
select statement: single row	<SQL data statement>
select sublist	<select list>
select target list	<select statement: single row>
self-referencing column name	<self-referencing column specification>
self-referencing column specification	<table element> <view element>
semicolon	<C variable definition> <direct SQL statement> <externally-invoked procedure> <MUMPS variable definition> <Pascal variable definition> <PL/I variable definition> <SQL special character> <SQL terminator> <triggered SQL statement>
separator	<binary string literal> <bracketed comment contents> <character string literal> <national character string literal> <Unicode character string literal>
sequence column	<search clause>
sequence generator cycle option	<basic sequence generator option>
sequence generator data type option	<sequence generator option>
sequence generator definition	<schema element> <SQL schema definition statement>
sequence generator increment	<sequence generator increment by option>
sequence generator increment by option	<basic sequence generator option>
sequence generator max value	<sequence generator maxvalue option>
sequence generator maxvalue option	<basic sequence generator option>
sequence generator min value	<sequence generator minvalue option>
sequence generator minvalue option	<basic sequence generator option>
sequence generator name	<alter sequence generator statement> <drop sequence generator statement> <next value expression> <object name> <sequence generator definition>
sequence generator option	<sequence generator options>
sequence generator options	<sequence generator definition>
sequence generator restart value	<alter sequence generator restart option>
sequence generator start value	<sequence generator start with option>
sequence generator start with option	<common sequence generator option>
session characteristic	<session characteristic list>
session characteristic list	<set session characteristics statement>
set catalog statement	<SQL session statement>
set clause	<set clause list>
set clause list	<dynamic update statement: positioned> <merge update specification> <preparable dynamic update statement: positioned> <update statement: positioned> <update statement: searched>
set column default clause	<alter column action>
set connection statement	<SQL connection statement>
set constraints mode statement	<SQL transaction statement>
set descriptor information	<set descriptor statement>
set descriptor statement	<system descriptor statement>
set domain default clause	<alter domain action>
set function specification	<nonparenthesized value expression primary>
set function type	<general set function>
set header information	<set descriptor information>
set item information	<set descriptor information>
set local time zone statement	<SQL session statement>
set names statement	<SQL session statement>
set path statement	<SQL session statement>
set predicate	<predicate>
set predicate part 2	<set predicate> <when operand>
set quantifier	<general set function> <group by clause> <query specification> <select statement: single row>
set role statement	<SQL session statement>
set schema statement	<SQL session statement>
set session characteristics statement	<SQL session statement>
set session collation statement	<SQL session statement>
set session user identifier statement	<SQL session statement>
set target	<set clause> <set target list>
set target list	<multiple column assignment>
set time zone value	<set local time zone statement>
set transaction statement	<SQL transaction statement>
set transform group statement	<SQL session statement>
sign	<factor> <interval factor> <interval literal> <signed integer> <signed numeric literal> <time zone interval> <unquoted interval string>
signed integer	<exponent>
signed numeric literal	<literal> <sequence generator increment> <sequence generator max value> <sequence generator min value> <sequence generator restart value> <sequence generator start value>
similar pattern	<similar predicate part 2>
similar predicate	<predicate>
similar predicate part 2	<similar predicate> <when operand>
simple case	<case specification>
simple comment	<comment>
simple comment introducer	<simple comment>
simple Latin letter	<SQL language character> <SQL language identifier part> <SQL language identifier start>
simple Latin lower case letter	<simple Latin letter>
simple Latin upper case letter	<simple Latin letter> <SQLSTATE char>
simple table	<non-join query primary>
simple target specification	<condition information item> <simple target specification 1> <simple target specification 2> <statement information item>
simple target specification 1	<get header information>
simple target specification 2	<get item information>
simple value specification	<attributes variable> <condition number> <connection name> <connection user name> <descriptor name> <extended cursor name> <extended statement name> <fetch orientation> <item number> <number of conditions> <occurrences> <simple value specification 1> <simple value specification 2> <SQL statement variable> <SQL-server name> <target array element specification> <update target>
simple value specification 1	<set header information>
simple value specification 2	<set item information>
simple when clause	<simple case>
single datetime field	<interval qualifier>
single group specification	<transform group specification>
slash	<bracketed comment introducer> <bracketed comment terminator>
solidus	<interval term> <SQL special character> <term>
some	<quantifier>
sort key	<sort specification>
sort specification	<sort specification list>
sort specification list	<order by clause> <recursive search order> <window order clause> <within group specification>
source character set specification	<transliteration definition>
source data type	<drop user-defined cast statement> <user-defined cast definition>
space	<day-time interval> <SQL special character> <unquoted timestamp string>
specific method name	<method specification designator> <partial method specification>
specific method specification designator	<drop method specification>
specific name	<routine characteristic> <specific routine designator> <state category>
specific routine designator	<alter routine statement> <cast function> <drop routine statement> <from sql function> <map function specification> <object name> <privilege method list> <relative function specification> <result set cursor> <to sql function> <transliteration routine>
specific type method	<character value function>
SQL argument	<SQL argument list>
SQL argument list	<attribute or method reference> <direct invocation> <generalized invocation> <method reference> <routine invocation> <static method invocation>
SQL condition	<condition>
SQL connection statement	<directly executable statement> <SQL executable statement>
SQL control statement	<preparable SQL control statement> <SQL executable statement>
SQL data change statement	<SQL data statement>
SQL data statement	<SQL executable statement>
SQL diagnostics information	<get diagnostics statement>
SQL diagnostics statement	<SQL executable statement>
SQL dynamic data statement	<SQL dynamic statement>
SQL dynamic statement	<SQL executable statement>
SQL executable statement	<SQL procedure statement>
SQL language character	<SQL terminal character>
SQL language identifier	<character set name>
SQL language identifier part	<SQL language identifier>
SQL language identifier start	<SQL language identifier>
SQL parameter declaration	<SQL parameter declaration list>
SQL parameter declaration list	<function specification> <method specification designator> <partial method specification> <SQL-invoked procedure>
SQL parameter name	<SQL parameter declaration>
SQL parameter reference	<general value specification> <simple target specification> <simple value specification> <target array reference> <target specification>
SQL prefix	<embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
SQL procedure statement	<externally-invoked procedure> <SQL routine body> <statement or declaration> <triggered SQL statement>
SQL routine body	<SQL routine spec>
SQL routine spec	<routine body>
SQL schema definition statement	<SQL schema statement>
SQL schema manipulation statement	<SQL schema statement>
SQL schema statement	<directly executable statement> <preparable SQL schema statement> <SQL executable statement>
SQL session statement	<directly executable statement> <preparable SQL session statement> <SQL executable statement>
SQL special character	<delimiter token> <SQL language character>
SQL statement name	<deallocate prepared statement> <describe input statement> <described object> <execute statement> <prepare statement>
SQL statement variable	<execute immediate statement> <prepare statement>
SQL terminator	<embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
SQL transaction statement	<directly executable statement> <preparable SQL transaction statement> <SQL executable statement>
SQL-client module name	<module name clause>
SQL-data access indication	<alter routine characteristic> <method characteristic> <routine characteristic>
SQL-invoked function	<schema function>
SQL-invoked procedure	<schema procedure>
SQL-invoked routine	<SQL schema definition statement>
SQL-path characteristic	<set path statement>
SQL-server name	<connection target>
SQLSTATE char	<SQLSTATE class value> <SQLSTATE subclass value>
SQLSTATE class value	<SQL condition>
SQLSTATE subclass value	<SQL condition>
square root	<numeric value function>
standard character set name	<character set specification>
start field	<interval qualifier>
start position	<blob overlay function> <blob substring function> <character overlay function> <character substring function>
start transaction statement	<SQL transaction statement>
state category	<ordering category>
statement cursor	<cursor intent>
statement information	<SQL diagnostics information>
statement information item	<statement information>
statement information item name	<statement information item>
statement name	<dynamic declare cursor> <SQL statement name>
statement or declaration	<embedded SQL statement>
static method invocation	<nonparenthesized value expression primary>
status parameter	<host parameter declaration>
string length	<blob overlay function> <blob substring function> <character overlay function> <character substring function>
string position expression	<position expression>
string value expression	<char length expression> <common value expression> <current collation specification> <normalized predicate> <octet length expression> <string position expression>
string value function	<blob primary> <character primary>
submultiset predicate	<predicate>
submultiset predicate part 2	<submultiset predicate> <when operand>
subquery	<as subquery clause> <row subquery> <scalar subquery> <table subquery>
subtable clause	<table contents source>
subtype clause	<user-defined type body>
subtype operand	<subtype treatment>
subtype treatment	<nonparenthesized value expression primary>
subview clause	<referenceable view specification>
supertable clause	<subtable clause>
supertable name	<supertable clause>
supertype name	<subtype clause>
system descriptor statement	<SQL dynamic statement>
system-generated representation	<reference type specification>
table commit action	<table definition> <temporary table declaration>
table constraint	<table constraint definition>
table constraint definition	<add table constraint definition> <table element>
table contents source	<table definition>
table definition	<schema element> <SQL schema definition statement>
table element	<table element list>
table element list	<table contents source> <temporary table declaration>
table expression	<query specification> <select statement: single row>
table function column list	<returns table type>
table function column list element	<table function column list>
table function derived table	<table primary>
table name	<alter table statement> <drop table statement> <drop view statement> <insertion target> <like clause> <object name> <referenced table and columns> <scope clause> <subview clause> <supertable name> <table definition> <table or query name> <target table> <temporary table declaration> <trigger definition> <view definition>
table or query name	<explicit table> <only spec> <table primary>
table primary	<cross join> <natural join> <table primary or joined table> <union join>
table primary or joined table	<table reference>
table reference	<cross join> <merge statement> <natural join> <qualified join> <table reference list> <union join>
table reference list	<from clause>
table row value expression	<row value expression list>
table scope	<table definition>
table subquery	<derived table> <exists predicate> <in predicate value> <lateral derived table> <match predicate part 2> <quantified comparison predicate part 2> <unique predicate>
table value constructor	<simple table>
table value constructor by query	<multiset value constructor>
target array element specification	<target specification>
target array reference	<target array element specification>
target character set specification	<transliteration definition>
target data type	<drop user-defined cast statement> <user-defined cast definition>
target specification	<fetch target list> <into argument> <select target list> <SQL argument>
target subtype	<subtype treatment>
target table	<delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <dynamic update statement: positioned> <merge statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned> <update statement: searched>
temporary table declaration	<direct SQL data statement> <SQL-client module definition> <statement or declaration>
term	<interval term> <numeric value expression> <term>
time fractional seconds precision	<time precision> <timestamp precision>
time interval	<day-time literal>
time literal	<datetime literal>
time precision	<current local time value function> <current time value function> <datetime type>
time string	<delimiter token> <time literal>
time value	<unquoted time string>
time zone	<datetime factor>
time zone field	<extract field>
time zone interval	<unquoted time string>
time zone specifier	<time zone>
timestamp literal	<datetime literal>
timestamp precision	<current local timestamp value function> <current timestamp value function> <datetime type>
timestamp string	<delimiter token> <timestamp literal>
to sql	<transform element>
to sql function	<to sql>
transaction access mode	<transaction mode>
transaction characteristics	<session characteristic> <set transaction statement>
transaction mode	<start transaction statement> <transaction characteristics>
transcoding	<character value function>
transcoding name	<transcoding>
transform definition	<schema element> <SQL schema definition statement>
transform element	<transform element list>
transform element list	<add transform element list> <transform group>
transform group	<transform definition>
transform group characteristic	<set transform group statement>
transform group element	<transforms to be dropped>
transform group specification	<embedded transform group specification> <external body reference> <module transform group specification>
transform kind	<drop transform element list>
transforms to be dropped	<drop transform statement>
transliteration definition	<schema element> <SQL schema definition statement>
transliteration name	<character transliteration> <drop transliteration statement> <existing transliteration name> <object name> <transliteration definition>
transliteration routine	<transliteration source>
transliteration source	<transliteration definition>
trigger action time	<trigger definition>
trigger column list	<trigger event>
trigger definition	<schema element> <SQL schema definition statement>
trigger event	<trigger definition>
trigger name	<drop trigger statement> <trigger definition>
triggered action	<trigger definition>
triggered SQL statement	<triggered action>
trim character	<trim operands>
trim function	<character value function>
trim octet	<blob trim operands>
trim operands	<trim function>
trim source	<trim operands>
trim specification	<blob trim operands> <trim operands>
truth value	<boolean test>
type list	<type predicate part 2>
type predicate	<predicate>
type predicate part 2	<type predicate> <when operand>
underscore	<introducer> <regular character set> <SQL language identifier> <SQL special character>
Unicode 4 digit escape value	<Unicode escape value>
Unicode 6 digit escape value	<Unicode escape value>
Unicode character escape value	<Unicode escape value>
Unicode character string literal	<general literal>
Unicode delimited identifier	<delimiter token>
Unicode delimiter body	<Unicode delimited identifier>
Unicode escape character	<Unicode 4 digit escape value> <Unicode 6 digit escape value> <Unicode character escape value> <Unicode escape specifier>
Unicode escape specifier	<Unicode delimited identifier>
Unicode escape value	<Unicode identifier part> <Unicode representation>
Unicode identifier part	<Unicode delimiter body>
Unicode representation	<Unicode character string literal>
union join	<joined table>
unique column list	<unique constraint definition>
unique constraint definition	<table constraint>
unique predicate	<predicate>
unique specification	<column constraint> <unique constraint definition>
unqualified schema name	<schema name>
unquoted date string	<date string> <unquoted timestamp string>
unquoted interval string	<interval string>
unquoted time string	<time string> <unquoted timestamp string>
unquoted timestamp string	<timestamp string>
unsigned integer	<array type> <datetime value> <exact numeric literal> <goto target> <high value> <interval fractional seconds precision> <interval leading field precision> <large object length> <length> <low value> <maximum dynamic result sets> <precision> <scale> <seconds fraction> <seconds integer value> <signed integer> <time fractional seconds precision>
unsigned literal	<unsigned value specification>
unsigned numeric literal	<nondelimiter token> <signed numeric literal> <unsigned literal>
unsigned value specification	<nonparenthesized value expression primary> <window frame following> <window frame preceding>
updatability clause	<cursor specification>
update rule	<referential triggered action>
update source	<set clause>
update statement: positioned	<SQL data change statement>
update statement: searched	<direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
update target	<set target>
upper limit	<repeat factor>
user identifier	<authorization identifier>
user-defined cast definition	<schema element> <SQL schema definition statement>
user-defined character set name	<character set specification>
user-defined ordering definition	<schema element> <SQL schema definition statement>
user-defined representation	<reference type specification>
user-defined type body	<user-defined type definition>
user-defined type definition	<schema element> <SQL schema definition statement>
user-defined type name	<path-resolved user-defined type name> <schema-resolved user-defined type name>
user-defined type option	<user-defined type option list>
user-defined type option list	<user-defined type body>
user-defined type specification	<type list>
user-defined type value expression	<common value expression> <specific type method>
using argument	<using arguments>
using arguments	<input using clause>
using descriptor	<describe input statement> <describe output statement> <using input descriptor>
using input descriptor	<input using clause>
value expression	<array element> <case abbreviation> <cast operand> <contextually typed row value constructor element> <cycle mark value> <derived column> <general set function> <generalized expression> <generation expression> <hypothetical set function value expression list> <merge insert value element> <multiset element> <non-cycle mark value> <parenthesized value expression> <result expression> <return value> <row value constructor element> <sort key> <SQL argument> <subtype operand> <update source>
value expression primary	<all fields reference> <array factor> <attribute or method reference> <blob primary> <character primary> <datetime primary> <direct invocation> <field reference> <generalized invocation> <interval primary> <method reference> <multiset primary> <numeric primary> <reference value expression> <user-defined type value expression>
value specification	<catalog name characteristic> <character set name characteristic> <collation specification> <role specification> <schema name characteristic> <set session user identifier statement> <SQL-path characteristic> <transform group characteristic>
vertical bar	<concatenation operator> <regular expression> <SQL special character>
view column list	<regular view specification>
view column option	<view element>
view definition	<schema element> <SQL schema definition statement>
view element	<view element list>
view element list	<referenceable view specification>
view specification	<view definition>
when operand	<simple when clause>
where clause	<table expression>
white space	<separator>
width bucket bound 1	<width bucket function>
width bucket bound 2	<width bucket function>
width bucket count	<width bucket function>
width bucket function	<numeric value function>
width bucket operand	<width bucket function>
window clause	<table expression>
window definition	<window definition list>
window definition list	<window clause>
window frame between	<window frame extent>
window frame bound	<window frame bound 1> <window frame bound 2>
window frame bound 1	<window frame between>
window frame bound 2	<window frame between>
window frame clause	<window specification details>
window frame exclusion	<window frame clause>
window frame extent	<window frame clause>
window frame following	<window frame bound>
window frame preceding	<window frame start>
window frame start	<window frame bound> <window frame extent>
window frame units	<window frame clause>
window function	<nonparenthesized value expression primary>
window function type	<window function>
window name	<existing window name> <new window name> <window name or specification>
window name or specification	<window function>
window order clause	<window specification details>
window partition clause	<window specification details>
window partition column reference	<window partition column reference list>
window partition column reference list	<window partition clause>
window specification	<in-line window specification> <window definition>
window specification details	<window specification>
with clause	<query expression>
with column list	<with list element>
with list	<with clause>
with list element	<with list>
with or without data	<as subquery clause>
with or without time zone	<datetime type>
within group specification	<hypothetical set function> <inverse distribution function>
year-month literal	<unquoted interval string>
years value	<date value> <year-month literal>

Top

Cross-Reference Table: Keywords

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Keyword	Rules using it
ABS	<absolute value expression> <interval absolute value function> <non-reserved word>
ABSOLUTE	<fetch orientation> <non-reserved word>
ACTION	<non-reserved word> <referential action>
ADA	<language name> <non-reserved word>
ADD	<add attribute definition> <add column definition> <add column scope clause> <add domain constraint definition> <add original method specification> <add overriding method specification> <add table constraint definition> <add transform element list> <reserved word>
ADMIN	<grant role statement> <non-reserved word> <revoke role statement> <role definition>
AFTER	<non-reserved word> <trigger action time>
ALL	<all> <constraint name list> <disconnect object> <multiset term> <multiset value expression> <non-join query expression> <non-join query term> <object privileges> <reserved word> <set quantifier> <transforms to be dropped>
ALLOCATE	<allocate cursor statement> <allocate descriptor statement> <reserved word>
ALTER	<alter column definition> <alter domain statement> <alter routine statement> <alter sequence generator statement> <alter table statement> <alter transform statement> <reserved word>
ALWAYS	<generation rule> <identity column specification> <non-reserved word>
AND	<between predicate part 2> <boolean term> <commit statement> <embedded authorization clause> <module authorization clause> <reserved word> <rollback statement> <window frame between>
ANY	<computational operation> <reserved word> <some>
ARE	<embedded character set declaration> <module character set specification> <reference scope check> <reserved word>
ARRAY	<array type> <array value constructor by enumeration> <array value constructor by query> <empty specification> <Pascal type specification> <reserved word>
AS	<Ada array locator variable> <Ada BLOB locator variable> <Ada CLOB locator variable> <Ada multiset locator variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <all fields reference> <as clause> <as subquery clause> <C array locator variable> <C BLOB locator variable> <C CLOB locator variable> <C multiset locator variable> <C user-defined type locator variable> <C user-defined type variable> <cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <character set definition> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL CLOB locator variable> <COBOL multiset locator variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <connection target> <domain definition> <drop user-defined cast statement> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran CLOB locator variable> <Fortran multiset locator variable> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <generalized expression> <generalized invocation> <generation clause> <identity column specification> <locator indication> <merge statement> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS CLOB locator variable> <MUMPS multiset locator variable> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <old or new values alias> <original method specification> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal CLOB locator variable> <Pascal multiset locator variable> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I array locator variable> <PL/I BLOB locator variable> <PL/I CLOB locator variable> <PL/I multiset locator variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <reserved word> <sequence generator data type option> <set session characteristics statement> <subtype treatment> <table primary> <user-defined cast definition> <user-defined type body> <view definition> <window definition> <with list element>
ASC	<non-reserved word> <ordering specification>
ASENSITIVE	<cursor sensitivity> <reserved word>
ASSERTION	<assertion definition> <drop assertion statement> <non-reserved word>
ASSIGNMENT	<non-reserved word> <user-defined cast definition>
ASYMMETRIC	<between predicate part 2> <reserved word>
AT	<reserved word> <time zone>
ATOMIC	<reserved word> <triggered SQL statement>
ATTRIBUTE	<add attribute definition> <drop attribute definition> <non-reserved word>
ATTRIBUTES	<attributes specification> <non-reserved word>
AUTHORIZATION	<embedded authorization clause> <module authorization clause> <reserved word> <schema name clause> <set session user identifier statement>
auto	<C storage class>
AVG	<computational operation> <non-reserved word>
BEFORE	<non-reserved word> <trigger action time>
BEGIN	<embedded SQL begin declare> <embedded SQL MUMPS declare> <reserved word> <triggered SQL statement>
BERNOULLI	<non-reserved word> <sample method>
BETWEEN	<between predicate part 2> <reserved word> <window frame between>
BIGINT	<Ada qualified type specification> <Ada unqualified type specification> <exact numeric type> <reserved word>
BIN	<PL/I type fixed binary> <PL/I type float binary>
BINARY	<binary large object string type> <COBOL binary integer> <PL/I type fixed binary> <PL/I type float binary> <reserved word>
BLOB	<Ada BLOB locator variable> <Ada BLOB variable> <binary large object string type> <C BLOB locator variable> <C BLOB variable> <COBOL BLOB locator variable> <COBOL BLOB variable> <Fortran BLOB locator variable> <Fortran BLOB variable> <MUMPS BLOB locator variable> <MUMPS BLOB variable> <Pascal BLOB locator variable> <Pascal BLOB variable> <PL/I BLOB locator variable> <PL/I BLOB variable> <reserved word>
BOOLEAN	<Ada qualified type specification> <Ada unqualified type specification> <boolean type> <Pascal type specification> <reserved word>
BOTH	<reserved word> <trim specification>
BREADTH	<non-reserved word> <recursive search order>
BY	<corresponding spec> <equals ordering form> <full ordering form> <grant privilege statement> <grant role statement> <group by clause> <identity column specification> <order by clause> <recursive search order> <reserved word> <revoke privilege statement> <revoke role statement> <sequence generator increment by option> <window order clause> <window partition clause> <within group specification>
C	<hexit> <language name> <non-reserved word> <simple Latin upper case letter>
CALL	<call statement> <reserved word>
CALLED	<null-call clause> <reserved word>
CARDINALITY	<cardinality expression> <descriptor item name> <non-reserved word>
CASCADE	<drop behavior> <non-reserved word> <referential action>
CASCADED	<levels clause> <reserved word>
CASE	<reserved word> <searched case> <simple case>
CAST	<cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <drop user-defined cast statement> <reserved word> <result cast> <user-defined cast definition>
CATALOG	<catalog name characteristic> <non-reserved word>
CATALOG_NAME	<condition information item name> <non-reserved word>
CEIL	<ceiling function> <non-reserved word>
CEILING	<ceiling function> <non-reserved word>
CHAIN	<commit statement> <non-reserved word> <rollback statement>
char	<C character type>
CHAR	<Ada qualified type specification> <Ada unqualified type specification> <character string type> <national character string type> <Pascal type specification> <PL/I type specification> <reserved word>
CHARACTER	<Ada CLOB variable> <Ada qualified type specification> <C character variable> <C CLOB variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C VARCHAR variable> <character set definition> <character string type> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <drop character set statement> <Fortran CLOB variable> <Fortran type specification> <MUMPS CLOB variable> <national character string type> <object name> <Pascal CLOB variable> <Pascal type specification> <PL/I CLOB variable> <PL/I type specification> <predefined type> <reserved word> <schema character set specification>
CHARACTERISTICS	<non-reserved word> <set session characteristics statement>
CHARACTERS	<char length units> <non-reserved word>
CHARACTER_LENGTH	<char length expression> <non-reserved word>
CHARACTER_SET_CATALOG	<descriptor item name> <non-reserved word>
CHARACTER_SET_NAME	<descriptor item name> <non-reserved word>
CHARACTER_SET_SCHEMA	<descriptor item name> <non-reserved word>
CHAR_LENGTH	<char length expression> <non-reserved word>
CHECK	<assertion definition> <check constraint definition> <reserved word> <view definition>
CHECKED	<non-reserved word> <reference scope check>
CLASS_ORIGIN	<condition information item name> <non-reserved word>
CLOB	<Ada CLOB locator variable> <Ada CLOB variable> <C CLOB locator variable> <C CLOB variable> <character string type> <COBOL CLOB locator variable> <COBOL CLOB variable> <Fortran CLOB locator variable> <Fortran CLOB variable> <MUMPS CLOB locator variable> <MUMPS CLOB variable> <Pascal CLOB locator variable> <Pascal CLOB variable> <PL/I CLOB locator variable> <PL/I CLOB variable> <reserved word>
CLOSE	<close statement> <dynamic close statement> <reserved word>
COALESCE	<case abbreviation> <non-reserved word>
COBOL	<language name> <non-reserved word>
CODE_UNITS	<char length units> <non-reserved word>
COLLATE	<collate clause> <reserved word>
COLLATION	<collation definition> <drop collation statement> <module collation specification> <non-reserved word> <object name> <set session collation statement>
COLLATION_CATALOG	<descriptor item name> <non-reserved word>
COLLATION_NAME	<descriptor item name> <non-reserved word>
COLLATION_SCHEMA	<descriptor item name> <non-reserved word>
COLLECT	<computational operation> <non-reserved word>
COLUMN	<add column definition> <alter column definition> <drop column definition> <reserved word>
COLUMN_NAME	<condition information item name> <non-reserved word>
COMMAND_FUNCTION	<non-reserved word> <statement information item name>
COMMAND_FUNCTION_CODE	<non-reserved word> <statement information item name>
COMMIT	<commit statement> <reserved word> <table definition> <temporary table declaration>
COMMITTED	<level of isolation> <non-reserved word>
CONDITION	<condition information> <non-reserved word>
CONDITION_NUMBER	<condition information item name> <non-reserved word>
CONNECT	<connect statement> <reserved word>
CONNECTION	<set connection statement>
CONNECTION_NAME	<condition information item name> <non-reserved word>
const	<C class modifier>
CONSTRAINT	<constraint name definition> <drop domain constraint definition> <drop table constraint definition> <reserved word> <SQL condition>
CONSTRAINTS	<non-reserved word> <set constraints mode statement>
CONSTRAINT_CATALOG	<condition information item name> <non-reserved word>
CONSTRAINT_NAME	<condition information item name> <non-reserved word>
CONSTRAINT_SCHEMA	<condition information item name> <non-reserved word>
CONSTRUCTOR	<method specification designator> <partial method specification> <routine type> <specific method specification designator>
CONSTRUCTORS	<non-reserved word>
CONTAINS	<non-reserved word> <SQL-data access indication>
CONTINUE	<condition action> <reserved word>
CONVERT	<non-reserved word> <transcoding>
CORR	<binary set function type> <non-reserved word>
CORRESPONDING	<corresponding spec> <reserved word>
COUNT	<aggregate function> <computational operation> <header item name> <non-reserved word>
COVAR_POP	<binary set function type> <non-reserved word>
COVAR_SAMP	<binary set function type> <non-reserved word>
CREATE	<assertion definition> <character set definition> <collation definition> <domain definition> <reserved word> <role definition> <schema definition> <schema function> <schema procedure> <sequence generator definition> <table definition> <transform definition> <transliteration definition> <trigger definition> <user-defined cast definition> <user-defined ordering definition> <user-defined type definition> <view definition>
CROSS	<cross join> <reserved word>
CUBE	<cube list> <reserved word>
CUME_DIST	<non-reserved word> <rank function type>
CURRENT	<delete statement: positioned> <disconnect object> <dynamic delete statement: positioned> <dynamic update statement: positioned> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <update statement: positioned> <window frame exclusion> <window frame start>
CURRENT_COLLATION	<current collation specification> <non-reserved word>
CURRENT_DATE	<current date value function> <reserved word>
CURRENT_DEFAULT_TRANSFORM_GROUP	<general value specification> <reserved word>
CURRENT_PATH	<default option> <general value specification> <reserved word>
CURRENT_ROLE	<default option> <general value specification> <grantor> <reserved word>
CURRENT_TIME	<current time value function> <reserved word>
CURRENT_TIMESTAMP	<current timestamp value function> <reserved word>
CURRENT_TRANSFORM_GROUP_FOR_TYPE	<general value specification> <reserved word>
CURRENT_USER	<default option> <general value specification> <grantor> <reserved word>
CURSOR	<declare cursor> <described object> <dynamic declare cursor> <reserved word> <statement cursor>
CURSOR_NAME	<condition information item name> <non-reserved word>
CYCLE	<cycle clause> <reserved word> <sequence generator cycle option>
DATA	<descriptor item name> <non-reserved word> <SQL-data access indication> <with or without data>
DATE	<date literal> <datetime type> <reserved word>
DATETIME_INTERVAL_CODE	<descriptor item name> <non-reserved word>
DATETIME_INTERVAL_PRECISION	<descriptor item name> <non-reserved word>
DAY	<non-second primary datetime field> <reserved word>
DCL	<PL/I variable definition>
DEALLOCATE	<deallocate descriptor statement> <deallocate prepared statement> <reserved word>
DEC	<exact numeric type> <MUMPS type specification> <PL/I type fixed decimal> <reserved word>
DECIMAL	<exact numeric type> <PL/I type fixed decimal> <reserved word>
DECLARE	<declare cursor> <dynamic declare cursor> <embedded authorization declaration> <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <PL/I variable definition> <reserved word> <temporary table declaration>
DEFAULT	<connection object> <connection target> <cycle clause> <default clause> <default specification> <drop column default clause> <drop domain default clause> <from default> <identity column specification> <referential action> <reserved word> <schema character set specification> <transform group characteristic>
DEFAULTS	<column default option> <non-reserved word>
DEFERRABLE	<constraint characteristics> <non-reserved word>
DEFERRED	<constraint check time> <non-reserved word> <set constraints mode statement>
DEFINED	<external security clause> <non-reserved word>
DEFINER	<external security clause> <non-reserved word> <rights clause>
DEGREE	<descriptor item name> <non-reserved word>
DELETE	<action> <delete rule> <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <preparable dynamic delete statement: positioned> <reference scope check> <reserved word> <table commit action> <trigger event>
DENSE_RANK	<non-reserved word> <rank function type>
DEPTH	<non-reserved word> <recursive search order>
DEREF	<reference resolution> <reserved word>
DERIVED	<non-reserved word> <reference generation>
DESC	<non-reserved word> <ordering specification>
DESCRIBE	<describe input statement> <describe output statement> <reserved word>
DESCRIPTOR	<allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <into descriptor> <non-reserved word> <set descriptor statement> <using descriptor>
DETERMINISTIC	<deterministic characteristic> <reserved word>
DIAGNOSTICS	<diagnostics size> <get diagnostics statement> <non-reserved word>
DISCONNECT	<disconnect statement> <reserved word>
DISPATCH	<dispatch clause> <non-reserved word>
DISPLAY	<COBOL numeric type>
DISTINCT	<cast to distinct> <cast to source> <distinct predicate part 2> <multiset term> <multiset value expression> <non-join query expression> <non-join query term> <reserved word> <set quantifier>
DOMAIN	<alter domain statement> <domain definition> <drop domain statement> <non-reserved word> <object name>
double	<C numeric variable>
DOUBLE	<approximate numeric type> <Fortran type specification> <reserved word>
DOUBLE_PRECISION	<Ada qualified type specification> <Ada unqualified type specification>
DROP	<drop assertion statement> <drop attribute definition> <drop character set statement> <drop collation statement> <drop column default clause> <drop column definition> <drop column scope clause> <drop data type statement> <drop domain constraint definition> <drop domain default clause> <drop domain statement> <drop method specification> <drop role statement> <drop routine statement> <drop schema statement> <drop sequence generator statement> <drop table constraint definition> <drop table statement> <drop transform element list> <drop transform statement> <drop transliteration statement> <drop trigger statement> <drop user-defined cast statement> <drop user-defined ordering statement> <drop view statement> <reserved word>
DYNAMIC	<dynamic result sets characteristic> <embedded authorization clause> <module authorization clause> <reserved word>
DYNAMIC_FUNCTION	<header item name> <non-reserved word> <statement information item name>
DYNAMIC_FUNCTION_CODE	<header item name> <non-reserved word> <statement information item name>
EACH	<reserved word> <triggered action>
ELEMENT	<multiset element reference> <reserved word>
ELSE	<else clause> <reserved word>
END	<embedded SQL end declare> <embedded SQL MUMPS declare> <reserved word> <searched case> <simple case> <triggered SQL statement>
END-EXEC	<reserved word> <SQL terminator>
EQUALS	<equals ordering form> <non-reserved word>
ESCAPE	<binary string literal> <character like predicate part 2> <octet like predicate part 2> <regular expression substring function> <reserved word> <similar predicate part 2> <Unicode character string literal>
EVERY	<computational operation> <non-reserved word>
EXCEPT	<multiset value expression> <non-join query expression> <reserved word>
EXCEPTION	<condition information> <non-reserved word>
EXCLUDE	<non-reserved word> <window frame exclusion>
EXCLUDING	<column default option> <identity option> <non-reserved word>
EXEC	<reserved word> <SQL prefix>
EXECUTE	<action> <execute immediate statement> <execute statement> <reserved word>
EXISTS	<exists predicate> <reserved word>
EXP	<exponential function> <non-reserved word>
extern	<C storage class>
EXTERNAL	<external body reference> <external security clause> <reserved word>
EXTRACT	<extract expression> <non-reserved word>
FALSE	<boolean literal> <reserved word> <truth value>
FETCH	<dynamic fetch statement> <fetch statement> <reserved word>
FILTER	<filter clause> <reserved word>
FINAL	<finality> <non-reserved word>
FIRST	<fetch orientation> <non-reserved word> <null ordering> <recursive search order>
FIXED	<PL/I type fixed binary> <PL/I type fixed decimal>
FLOAT	<approximate numeric type> <PL/I type float binary> <reserved word>
float	<C numeric variable>
FLOOR	<floor function> <non-reserved word>
FOLLOWING	<non-reserved word> <window frame bound> <window frame following>
FOR	<alter transform statement> <blob overlay function> <blob substring function> <character overlay function> <character substring function> <collation definition> <declare cursor> <drop transform statement> <drop user-defined ordering statement> <dynamic declare cursor> <embedded authorization clause> <group specification> <method specification designator> <module authorization clause> <module collation specification> <next value expression> <reserved word> <result set cursor> <revoke option extension> <revoke role statement> <set session collation statement> <specific routine designator> <statement cursor> <transform definition> <transform group characteristic> <transliteration definition> <triggered action> <updatability clause> <user-defined ordering definition>
FOREIGN	<referential constraint definition> <reserved word>
FORTRAN	<language name> <non-reserved word>
FOUND	<major category> <non-reserved word>
FREE	<free locator statement> <reserved word>
FROM	<blob overlay function> <blob substring function> <blob trim operands> <character overlay function> <character substring function> <collation definition> <delete statement: positioned> <delete statement: searched> <derived representation> <distinct predicate part 2> <dynamic delete statement: positioned> <dynamic fetch statement> <extract expression> <fetch statement> <from clause> <from sql> <preparable dynamic delete statement: positioned> <prepare statement> <reserved word> <result cast> <revoke privilege statement> <revoke role statement> <transform kind> <transliteration definition> <trim operands>
FULL	<full ordering form> <match predicate part 2> <match type> <outer join type> <reserved word>
FUNCTION	<function specification> <reserved word> <routine type>
FUSION	<computational operation> <non-reserved word>
GENERAL	<non-reserved word> <parameter style>
GENERATED	<generation rule> <identity column specification> <reference generation> <system-generated representation>
GET	<character set source> <get descriptor statement> <get diagnostics statement> <reserved word>
GLOBAL	<global or local> <reserved word> <scope option>
GO	<go to> <non-reserved word>
GOTO	<go to> <non-reserved word>
GRANT	<grant privilege statement> <grant role statement> <reserved word> <revoke option extension>
GRANTED	<grant privilege statement> <grant role statement> <non-reserved word> <revoke privilege statement> <revoke role statement>
GROUP	<group by clause> <reserved word> <transform group characteristic> <transform group specification> <window frame exclusion> <within group specification>
GROUPING	<grouping operation> <grouping sets specification> <reserved word>
HAVING	<having clause> <reserved word>
HIERARCHY	<grant privilege statement> <non-reserved word> <revoke option extension>
HOLD	<cursor holdability> <hold locator statement> <reserved word>
HOUR	<non-second primary datetime field> <reserved word>
IDENTITY	<identity column specification> <identity option> <reserved word>
IMMEDIATE	<constraint check time> <execute immediate statement> <reserved word> <set constraints mode statement>
IMPLEMENTATION	<external security clause> <non-reserved word>
IN	<blob position expression> <in predicate part 2> <parameter mode> <reserved word> <string position expression>
INCLUDING	<column default option> <identity option> <non-reserved word>
INCREMENT	<non-reserved word> <sequence generator increment by option>
INDICATOR	<descriptor item name> <indicator parameter> <indicator variable> <reserved word>
INDICATOR_TYPE	<Ada qualified type specification> <Ada unqualified type specification>
INITIALLY	<constraint check time> <non-reserved word>
INNER	<join type> <reserved word>
INOUT	<parameter mode> <reserved word>
INPUT	<describe input statement> <null-call clause> <reserved word>
INSENSITIVE	<cursor sensitivity> <reserved word>
INSERT	<action> <insert statement> <merge insert specification> <reserved word> <trigger event>
INSTANCE	<method specification designator> <non-reserved word> <partial method specification> <routine type> <specific method specification designator>
INSTANTIABLE	<instantiable clause> <non-reserved word>
INT	<Ada qualified type specification> <Ada unqualified type specification> <exact numeric type> <MUMPS type specification> <reserved word>
INTEGER	<exact numeric type> <Fortran type specification> <Pascal type specification> <reserved word>
Interfaces	<Ada qualified type specification>
INTERSECT	<multiset term> <non-join query term> <reserved word>
INTERSECTION	<computational operation> <non-reserved word>
INTERVAL	<interval literal> <interval type> <reserved word>
INTO	<fetch statement> <insert statement> <into arguments> <into descriptor> <merge statement> <reserved word> <select statement: single row>
INVOKER	<external security clause> <non-reserved word> <rights clause>
IS	<Ada array locator variable> <Ada BLOB locator variable> <Ada BLOB variable> <Ada CLOB locator variable> <Ada CLOB variable> <Ada multiset locator variable> <Ada qualified type specification> <Ada REF variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <boolean test> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C REF variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable> <COBOL array locator variable> <COBOL binary integer> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB locator variable> <COBOL CLOB variable> <COBOL multiset locator variable> <COBOL national character type> <COBOL NCLOB variable> <COBOL numeric type> <COBOL REF variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <distinct predicate part 2> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran BLOB variable> <Fortran CLOB locator variable> <Fortran CLOB variable> <Fortran multiset locator variable> <Fortran REF variable> <Fortran type specification> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS BLOB variable> <MUMPS CLOB locator variable> <MUMPS CLOB variable> <MUMPS multiset locator variable> <MUMPS REF variable> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <normalized predicate> <null predicate part 2> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal BLOB variable> <Pascal CLOB locator variable> <Pascal CLOB variable> <Pascal multiset locator variable> <Pascal REF variable> <Pascal type specification> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I array locator variable> <PL/I BLOB locator variable> <PL/I BLOB variable> <PL/I CLOB locator variable> <PL/I CLOB variable> <PL/I multiset locator variable> <PL/I REF variable> <PL/I type specification> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <reserved word> <self-referencing column specification> <set predicate part 2> <system-generated representation> <type predicate part 2>
ISOLATION	<isolation level> <non-reserved word> <reserved word>
JOIN	<cross join> <natural join> <qualified join> <reserved word> <union join>
KEY	<non-reserved word> <referential constraint definition> <unique specification>
KEY_MEMBER	<descriptor item name> <non-reserved word>
KEY_TYPE	<header item name> <non-reserved word>
KIND	<Fortran type specification>
LANGUAGE	<language clause> <reserved word>
LARGE	<binary large object string type> <character string type> <national character string type> <reserved word>
LAST	<fetch orientation> <non-reserved word> <null ordering>
LATERAL	<lateral derived table> <reserved word>
LEADING	<COBOL numeric type> <reserved word> <trim specification>
LEFT	<outer join type> <reserved word>
LENGTH	<descriptor item name> <non-reserved word>
LEVEL	<descriptor item name> <isolation level> <non-reserved word> <savepoint level indication>
LIKE	<character like predicate part 2> <like clause> <octet like predicate part 2> <reserved word>
LN	<natural logarithm> <non-reserved word>
LOCAL	<global or local> <levels clause> <reserved word> <scope option> <set time zone value> <set transaction statement> <temporary table declaration> <time zone specifier>
LOCALTIME	<current local time value function> <reserved word>
LOCALTIMESTAMP	<current local timestamp value function> <reserved word>
LOCATOR	<Ada array locator variable> <Ada BLOB locator variable> <Ada CLOB locator variable> <Ada multiset locator variable> <Ada user-defined type locator variable> <C array locator variable> <C BLOB locator variable> <C CLOB locator variable> <C multiset locator variable> <C user-defined type locator variable> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL CLOB locator variable> <COBOL multiset locator variable> <COBOL user-defined type locator variable> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran CLOB locator variable> <Fortran multiset locator variable> <Fortran user-defined type locator variable> <free locator statement> <hold locator statement> <locator indication> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS CLOB locator variable> <MUMPS multiset locator variable> <MUMPS user-defined type locator variable> <non-reserved word> <original method specification> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal CLOB locator variable> <Pascal multiset locator variable> <Pascal user-defined type locator variable> <PL/I array locator variable> <PL/I BLOB locator variable> <PL/I CLOB locator variable> <PL/I multiset locator variable> <PL/I user-defined type locator variable>
LOGICAL	<Fortran type specification>
long	<C numeric variable>
LOWER	<fold> <non-reserved word>
MAP	<map category> <non-reserved word>
MATCH	<match predicate part 2> <references specification> <reserved word>
MATCHED	<merge when matched clause> <merge when not matched clause> <non-reserved word>
MAX	<allocate descriptor statement> <computational operation> <non-reserved word>
MAXVALUE	<non-reserved word> <sequence generator maxvalue option>
MEMBER	<member predicate part 2> <reserved word>
MERGE	<merge statement> <reserved word>
MESSAGE_LENGTH	<condition information item name> <non-reserved word>
MESSAGE_OCTET_LENGTH	<condition information item name> <non-reserved word>
MESSAGE_TEXT	<condition information item name> <non-reserved word>
METHOD	<method specification designator> <partial method specification> <reserved word> <routine type> <specific method specification designator>
MIN	<computational operation> <non-reserved word>
MINUTE	<non-second primary datetime field> <reserved word>
MINVALUE	<non-reserved word> <sequence generator minvalue option>
MOD	<modulus expression> <non-reserved word>
MODIFIES	<reserved word> <SQL-data access indication>
MODULE	<column reference> <local or schema qualifier> <local qualifier> <module name clause> <reserved word>
MONTH	<non-second primary datetime field> <reserved word>
MORE	<non-reserved word> <statement information item name>
MULTISET	<empty specification> <multiset term> <multiset type> <multiset value constructor by enumeration> <multiset value constructor by query> <multiset value expression> <reserved word>
MUMPS	<language name> <non-reserved word>
NAME	<alter routine characteristic> <descriptor item name> <external body reference> <non-reserved word>
NAMES	<character set name characteristic> <embedded character set declaration> <module character set specification> <non-reserved word>
NATIONAL	<national character string type> <reserved word>
NATURAL	<natural join> <reserved word>
NCHAR	<C NCHAR variable> <C NCHAR VARYING variable> <national character string type> <reserved word>
NCLOB	<C NCLOB variable> <COBOL NCLOB variable> <national character string type> <reserved word>
NESTING	<nesting option> <non-reserved word>
NEW	<new specification> <old or new values alias> <reserved word> <savepoint level indication>
NEXT	<fetch orientation> <next value expression> <non-reserved word>
NO	<commit statement> <cursor scrollability> <pad characteristic> <referential action> <reserved word> <rollback statement> <sequence generator cycle option> <sequence generator maxvalue option> <sequence generator minvalue option> <set session collation statement> <SQL-data access indication> <window frame exclusion> <with or without data>
NONE	<reserved word> <role specification>
NORMALIZE	<non-reserved word> <normalize function>
NORMALIZED	<non-reserved word> <normalized predicate>
NOT	<between predicate part 2> <boolean factor> <boolean test> <character like predicate part 2> <column constraint> <constraint characteristics> <deterministic characteristic> <finality> <in predicate part 2> <instantiable clause> <major category> <member predicate part 2> <merge when not matched clause> <normalized predicate> <null predicate part 2> <octet like predicate part 2> <reference scope check> <reserved word> <set predicate part 2> <similar predicate part 2> <submultiset predicate part 2> <type predicate part 2>
NULL	<column constraint> <null predicate part 2> <null specification> <null-call clause> <referential action> <reserved word> <result> <return value>
NULLABLE	<descriptor item name> <non-reserved word>
NULLIF	<case abbreviation> <non-reserved word>
NULLS	<non-reserved word> <null ordering>
NUMBER	<non-reserved word> <statement information item name>
NUMERIC	<exact numeric type> <reserved word>
OBJECT	<binary large object string type> <character string type> <national character string type> <non-reserved word>
OCTETS	<char length units> <non-reserved word>
OCTET_LENGTH	<descriptor item name> <non-reserved word> <octet length expression>
OF	<delete statement: positioned> <dynamic delete statement: positioned> <dynamic update statement: positioned> <member predicate part 2> <Pascal type specification> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <referenceable view specification> <reserved word> <submultiset predicate part 2> <table contents source> <trigger event> <type predicate part 2> <updatability clause> <update statement: positioned>
OLD	<old or new values alias> <reserved word> <savepoint level indication>
ON	<delete rule> <join condition> <merge statement> <null-call clause> <privileges> <reference scope check> <reserved word> <table definition> <temporary table declaration> <trigger definition> <update rule>
ONLY	<embedded authorization clause> <equals ordering form> <exclusive user-defined type specification> <module authorization clause> <only spec> <reserved word> <target table> <transaction access mode> <updatability clause>
OPEN	<dynamic open statement> <open statement> <reserved word>
OPTION	<grant privilege statement> <grant role statement> <non-reserved word> <revoke option extension> <revoke role statement> <view definition>
OPTIONS	<column options> <non-reserved word> <view column option>
OR	<boolean value expression> <reserved word>
ORDER	<full ordering form> <order by clause> <reserved word> <window order clause> <within group specification>
ORDERING	<drop user-defined ordering statement> <non-reserved word> <user-defined ordering definition>
ORDINALITY	<collection derived table> <non-reserved word>
OTHERS	<non-reserved word> <window frame exclusion>
OUT	<parameter mode> <reserved word>
OUTER	<join type> <reserved word>
OUTPUT	<describe output statement> <reserved word>
OVER	<reserved word> <window function>
OVERLAPS	<overlaps predicate part 2> <reserved word>
OVERLAY	<blob overlay function> <character overlay function> <non-reserved word>
OVERRIDING	<non-reserved word> <override clause> <overriding method specification>
PACKED	<Pascal type specification>
PAD	<non-reserved word> <pad characteristic>
PARAMETER	<parameter style clause> <reserved word>
PARAMETER_MODE	<condition information item name> <descriptor item name> <non-reserved word>
PARAMETER_NAME	<condition information item name> <non-reserved word>
PARAMETER_ORDINAL_POSITION	<condition information item name> <descriptor item name> <non-reserved word>
PARAMETER_SPECIFIC_CATALOG	<descriptor item name> <non-reserved word>
PARAMETER_SPECIFIC_NAME	<descriptor item name> <non-reserved word>
PARAMETER_SPECIFIC_SCHEMA	<descriptor item name> <non-reserved word>
PARTIAL	<match predicate part 2> <match type> <non-reserved word>
PARTITION	<reserved word> <window partition clause>
PASCAL	<language name> <non-reserved word>
PATH	<non-reserved word> <path specification> <SQL-path characteristic>
PERCENTILE_CONT	<inverse distribution function type> <non-reserved word>
PERCENTILE_DISC	<inverse distribution function type> <non-reserved word>
PERCENT_RANK	<non-reserved word> <rank function type>
PIC	<COBOL binary integer> <COBOL character type> <COBOL national character type> <COBOL numeric type>
PICTURE	<COBOL binary integer> <COBOL character type> <COBOL national character type> <COBOL numeric type>
PLACING	<blob overlay function> <character overlay function> <non-reserved word>
PLI	<language name> <non-reserved word>
POSITION	<blob position expression> <non-reserved word> <string position expression>
POWER	<non-reserved word> <power function>
PRECEDING	<non-reserved word> <window frame preceding> <window frame start>
PRECISION	<approximate numeric type> <descriptor item name> <Fortran type specification> <reserved word>
PREPARE	<deallocate prepared statement> <prepare statement> <reserved word>
PRESERVE	<non-reserved word> <table commit action>
PRIMARY	<reserved word> <unique specification>
PRIOR	<fetch orientation> <non-reserved word>
PRIVILEGES	<non-reserved word> <object privileges>
PROCEDURE	<externally-invoked procedure> <reserved word> <result set cursor> <routine type> <SQL-invoked procedure>
PUBLIC	<grantee> <non-reserved word>
RANGE	<reserved word> <window frame units>
RANK	<non-reserved word> <rank function type>
READ	<level of isolation> <non-reserved word> <transaction access mode> <updatability clause>
READS	<reserved word> <SQL-data access indication>
REAL	<Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <Fortran type specification> <MUMPS type specification> <Pascal type specification> <reserved word>
RECURSIVE	<reserved word> <view definition> <with clause>
REF	<cast to ref> <cast to type> <derived representation> <reference type> <reserved word> <self-referencing column specification> <system-generated representation> <user-defined representation>
REFERENCES	<action> <reference scope check> <references specification> <reserved word>
REFERENCING	<reserved word> <trigger definition>
REGR_AVGX	<binary set function type> <reserved word>
REGR_AVGY	<binary set function type> <reserved word>
REGR_COUNT	<binary set function type> <reserved word>
REGR_INTERCEPT	<binary set function type> <reserved word>
REGR_R2	<binary set function type> <reserved word>
REGR_SLOPE	<binary set function type> <reserved word>
REGR_SXX	<binary set function type> <reserved word>
REGR_SXY	<binary set function type> <reserved word>
REGR_SYY	<binary set function type> <reserved word>
RELATIVE	<fetch orientation> <non-reserved word> <relative category>
RELEASE	<release savepoint statement> <reserved word>
REPEATABLE	<level of isolation> <non-reserved word> <repeatable clause>
RESTART	<alter sequence generator restart option> <non-reserved word>
RESTRICT	<alter routine behavior> <drop attribute definition> <drop behavior> <drop method specification> <referential action>
RESULT	<dynamic result sets characteristic> <original method specification> <reserved word> <SQL parameter declaration>
RETURN	<cursor returnability> <reserved word> <return statement>
RETURNED_CARDINALITY	<descriptor item name> <non-reserved word>
RETURNED_LENGTH	<descriptor item name> <non-reserved word>
RETURNED_OCTET_LENGTH	<descriptor item name> <non-reserved word>
RETURNED_SQLSTATE	<condition information item name> <non-reserved word>
RETURNS	<null-call clause> <reserved word> <returns clause>
REVOKE	<reserved word> <revoke privilege statement> <revoke role statement>
RIGHT	<outer join type> <reserved word>
ROLE	<drop role statement> <non-reserved word> <role definition> <set role statement>
ROLLBACK	<reserved word> <rollback statement>
ROLLUP	<reserved word> <rollup list>
ROUTINE	<non-reserved word> <routine type>
ROUTINE_CATALOG	<condition information item name> <non-reserved word>
ROUTINE_NAME	<condition information item name> <non-reserved word>
ROUTINE_SCHEMA	<condition information item name> <non-reserved word>
ROW	<contextually typed row value constructor> <explicit row value constructor> <old or new values alias> <reserved word> <row type> <triggered action> <window frame exclusion> <window frame start>
ROWS	<reserved word> <table definition> <temporary table declaration> <window frame units>
ROW_COUNT	<non-reserved word> <statement information item name>
ROW_NUMBER	<non-reserved word> <window function type>
Rules	<SQLSTATE class value> <SQLSTATE subclass value>
SAVEPOINT	<release savepoint statement> <reserved word> <savepoint clause> <savepoint level indication> <savepoint statement>
SCALE	<descriptor item name> <non-reserved word>
SCHEMA	<drop schema statement> <embedded authorization clause> <module authorization clause> <non-reserved word> <schema definition> <schema name characteristic>
SCHEMA_NAME	<condition information item name> <non-reserved word>
SCOPE	<drop column scope clause> <scope clause>
SCOPE_CATALOG	<descriptor item name> <non-reserved word>
SCOPE_NAME	<descriptor item name> <non-reserved word>
SCOPE_SCHEMA	<descriptor item name> <non-reserved word>
SCROLL	<cursor scrollability> <reserved word>
SEARCH	<reserved word> <search clause>
SECOND	<end field> <primary datetime field> <reserved word> <single datetime field>
SECTION	<embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <non-reserved word>
SECURITY	<external security clause> <non-reserved word> <rights clause>
See	<SQLSTATE class value> <SQLSTATE subclass value>
SELECT	<action> <query specification> <reserved word> <select statement: single row>
SELF	<non-reserved word> <original method specification>
SENSITIVE	<cursor sensitivity> <reserved word>
SEPARATE	<COBOL numeric type>
SEQUENCE	<alter sequence generator statement> <drop sequence generator statement> <non-reserved word> <object name> <sequence generator definition>
SERIALIZABLE	<level of isolation> <non-reserved word>
SERVER_NAME	<condition information item name> <non-reserved word>
SESSION	<non-reserved word> <set session characteristics statement> <set session user identifier statement>
SESSION_USER	<default option> <general value specification> <reserved word>
SET	<Ada CLOB variable> <Ada qualified type specification> <alter identity column option> <C character variable> <C CLOB variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C VARCHAR variable> <character set definition> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <cycle clause> <drop character set statement> <dynamic update statement: positioned> <Fortran CLOB variable> <Fortran type specification> <merge update specification> <multiset set function> <MUMPS CLOB variable> <object name> <Pascal CLOB variable> <Pascal type specification> <PL/I CLOB variable> <PL/I type specification> <predefined type> <preparable dynamic update statement: positioned> <referential action> <reserved word> <schema character set specification> <search clause> <set catalog statement> <set column default clause> <set connection statement> <set constraints mode statement> <set descriptor statement> <set domain default clause> <set local time zone statement> <set names statement> <set path statement> <set predicate part 2> <set role statement> <set schema statement> <set session characteristics statement> <set session collation statement> <set session user identifier statement> <set transaction statement> <set transform group statement> <update statement: positioned> <update statement: searched>
SETS	<dynamic result sets characteristic> <grouping sets specification> <non-reserved word>
short	<C character type> <C numeric variable>
SIGN	<COBOL numeric type>
SIMILAR	<regular expression substring function> <reserved word> <similar predicate part 2>
SIMPLE	<match predicate part 2> <match type> <non-reserved word>
SIZE	<diagnostics size> <non-reserved word>
SMALLINT	<Ada qualified type specification> <Ada unqualified type specification> <exact numeric type> <reserved word>
SOME	<computational operation> <reserved word> <some>
SOURCE	<cast to distinct> <cast to ref> <cast to source> <cast to type> <non-reserved word>
SPACE	<non-reserved word> <pad characteristic>
SPECIFIC	<method specification designator> <partial method specification> <reserved word> <routine characteristic> <specific routine designator>
SPECIFICTYPE	<reserved word> <specific type method>
SPECIFIC_NAME	<condition information item name> <non-reserved word>
SQL	<Ada array locator variable> <Ada BLOB locator variable> <Ada BLOB variable> <Ada CLOB locator variable> <Ada CLOB variable> <Ada multiset locator variable> <Ada qualified type specification> <Ada REF variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <allocate descriptor statement> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCLOB variable> <C REF variable> <C user-defined type locator variable> <C user-defined type variable> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL CLOB locator variable> <COBOL CLOB variable> <COBOL multiset locator variable> <COBOL NCLOB variable> <COBOL REF variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <deallocate descriptor statement> <embedded character set declaration> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran BLOB variable> <Fortran CLOB locator variable> <Fortran CLOB variable> <Fortran multiset locator variable> <Fortran REF variable> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <from sql> <get descriptor statement> <into descriptor> <language name> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS BLOB variable> <MUMPS CLOB locator variable> <MUMPS CLOB variable> <MUMPS multiset locator variable> <MUMPS REF variable> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <parameter style> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal BLOB variable> <Pascal CLOB locator variable> <Pascal CLOB variable> <Pascal multiset locator variable> <Pascal REF variable> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I array locator variable> <PL/I BLOB locator variable> <PL/I BLOB variable> <PL/I CLOB locator variable> <PL/I CLOB variable> <PL/I multiset locator variable> <PL/I REF variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <reserved word> <rights clause> <set descriptor statement> <SQL prefix> <SQL-data access indication> <to sql> <transform kind> <using descriptor>
SQLEXCEPTION	<major category> <reserved word>
SQLSTATE	<reserved word> <SQL condition> <status parameter>
SQLSTATE_TYPE	<Ada qualified type specification> <Ada unqualified type specification>
SQLWARNING	<major category> <reserved word>
SQRT	<non-reserved word> <square root>
START	<reserved word> <sequence generator start with option> <start transaction statement>
STATE	<non-reserved word> <state category>
STATEMENT	<non-reserved word> <triggered action>
STATIC	<dispatch clause> <embedded authorization clause> <method specification designator> <module authorization clause> <partial method specification> <reserved word> <routine type> <specific method specification designator>
static	<C storage class>
STDDEV_POP	<computational operation> <non-reserved word>
STDDEV_SAMP	<computational operation> <non-reserved word>
STRUCTURE	<described object> <non-reserved word>
STYLE	<non-reserved word> <parameter style clause>
SUBCLASS_ORIGIN	<condition information item name> <non-reserved word>
SUBMULTISET	<reserved word> <submultiset predicate part 2>
SUBSTRING	<blob substring function> <character substring function> <non-reserved word> <regular expression substring function>
SUM	<computational operation> <non-reserved word>
SYMMETRIC	<between predicate part 2> <reserved word>
Syntax	<SQLSTATE class value> <SQLSTATE subclass value>
SYSTEM	<override clause> <reference generation> <reserved word> <sample method> <system-generated representation>
SYSTEM_USER	<default option> <general value specification> <reserved word>
TABLE	<alter table statement> <drop table statement> <explicit table> <object name> <old or new values alias> <reserved word> <returns table type> <table definition> <table function derived table> <table value constructor by query> <temporary table declaration>
TABLESAMPLE	<non-reserved word> <sample clause>
TABLE_NAME	<condition information item name> <non-reserved word>
TEMPORARY	<non-reserved word> <table scope> <temporary table declaration>
the	<SQLSTATE class value> <SQLSTATE subclass value>
THEN	<merge when matched clause> <merge when not matched clause> <reserved word> <searched when clause> <simple when clause>
TIES	<non-reserved word> <window frame exclusion>
TIME	<datetime type> <reserved word> <set local time zone statement> <time literal> <time zone specifier> <with or without time zone>
TIMESTAMP	<datetime type> <reserved word> <timestamp literal>
TIMEZONE_HOUR	<reserved word> <time zone field>
TIMEZONE_MINUTE	<reserved word> <time zone field>
TO	<connect statement> <cycle clause> <go to> <grant privilege statement> <grant role statement> <interval qualifier> <reserved word> <savepoint clause> <similar predicate part 2> <to sql> <transform kind> <transliteration definition>
TOP_LEVEL_COUNT	<header item name> <non-reserved word>
TRAILING	<reserved word> <trim specification>
TRANSACTION	<non-reserved word> <start transaction statement> <transaction characteristics>
TRANSACTIONS_COMMITTED	<non-reserved word> <statement information item name>
TRANSACTIONS_ROLLED_BACK	<non-reserved word> <statement information item name>
TRANSACTION_ACTIVE	<non-reserved word> <statement information item name>
TRANSFORM	<alter transform statement> <drop transform statement> <non-reserved word> <transform definition> <transform group characteristic> <transform group specification>
TRANSFORMS	<alter transform statement> <drop transform statement> <non-reserved word> <transform definition>
TRANSLATE	<character transliteration> <non-reserved word>
TRANSLATION	<drop transliteration statement> <object name> <reserved word> <transliteration definition>
TREAT	<reserved word> <subtype treatment>
TRIGGER	<action> <drop trigger statement> <reserved word> <trigger definition>
TRIGGER_CATALOG	<condition information item name> <non-reserved word>
TRIGGER_NAME	<condition information item name> <non-reserved word>
TRIGGER_SCHEMA	<condition information item name> <non-reserved word>
TRIM	<blob trim function> <non-reserved word> <trim function>
TRUE	<boolean literal> <reserved word> <truth value>
TYPE	<Ada array locator variable> <Ada BLOB locator variable> <Ada BLOB variable> <Ada CLOB locator variable> <Ada CLOB variable> <Ada multiset locator variable> <Ada REF variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCLOB variable> <C REF variable> <C user-defined type locator variable> <C user-defined type variable> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL CLOB locator variable> <COBOL CLOB variable> <COBOL multiset locator variable> <COBOL NCLOB variable> <COBOL REF variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <descriptor item name> <drop data type statement> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran BLOB variable> <Fortran CLOB locator variable> <Fortran CLOB variable> <Fortran multiset locator variable> <Fortran REF variable> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <group specification> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS BLOB variable> <MUMPS CLOB locator variable> <MUMPS CLOB variable> <MUMPS multiset locator variable> <MUMPS REF variable> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <non-reserved word> <object name> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal BLOB variable> <Pascal CLOB locator variable> <Pascal CLOB variable> <Pascal multiset locator variable> <Pascal REF variable> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I array locator variable> <PL/I BLOB locator variable> <PL/I BLOB variable> <PL/I CLOB locator variable> <PL/I CLOB variable> <PL/I multiset locator variable> <PL/I REF variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <transform group characteristic> <user-defined type definition>
UESCAPE	<reserved word> <Unicode escape specifier>
UNBOUNDED	<non-reserved word> <window frame bound> <window frame start>
UNCOMMITTED	<level of isolation> <non-reserved word>
UNDER	<action> <non-reserved word> <subtable clause> <subtype clause> <subview clause>
UNION	<multiset value expression> <non-join query expression> <reserved word> <union join>
UNIQUE	<match predicate part 2> <reserved word> <unique constraint definition> <unique predicate> <unique specification>
UNKNOWN	<boolean literal> <reserved word> <truth value>
UNNAMED	<descriptor item name> <non-reserved word>
UNNEST	<collection derived table> <reserved word>
unsigned	<C character type>
UPDATE	<action> <dynamic update statement: positioned> <merge update specification> <preparable dynamic update statement: positioned> <reserved word> <trigger event> <updatability clause> <update rule> <update statement: positioned> <update statement: searched>
UPPER	<fold> <reserved word>
USAGE	<action> <COBOL array locator variable> <COBOL binary integer> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL CLOB locator variable> <COBOL CLOB variable> <COBOL multiset locator variable> <COBOL NCLOB variable> <COBOL numeric type> <COBOL REF variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <non-reserved word>
USER	<connection target> <default option> <general value specification> <override clause> <reference generation> <reserved word>
USER_DEFINED_TYPE_CATALOG	<descriptor item name> <non-reserved word>
USER_DEFINED_TYPE_CODE	<descriptor item name> <non-reserved word>
USER_DEFINED_TYPE_NAME	<descriptor item name> <non-reserved word>
USER_DEFINED_TYPE_SCHEMA	<descriptor item name> <non-reserved word>
USING	<char length expression> <character overlay function> <character substring function> <character transliteration> <cycle clause> <merge statement> <named columns join> <reserved word> <string position expression> <transcoding> <user-defined representation> <using arguments> <using descriptor>
VALUE	<general value specification> <get descriptor information> <next value expression> <override clause> <reserved word> <set descriptor information> <unique constraint definition>
VALUES	<contextually typed table value constructor> <from default> <merge insert specification> <reserved word> <table value constructor>
VARCHAR	<C VARCHAR variable> <character string type> <MUMPS character variable> <reserved word>
VARYING	<C NCHAR VARYING variable> <character string type> <national character string type> <PL/I type specification> <reserved word>
VAR_POP	<computational operation> <reserved word>
VAR_SAMP	<computational operation> <reserved word>
VIEW	<drop view statement> <non-reserved word> <view definition>
volatile	<C class modifier>
WHEN	<merge when matched clause> <merge when not matched clause> <reserved word> <searched when clause> <simple when clause> <triggered action>
WHENEVER	<embedded exception declaration> <reserved word>
WHERE	<delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <dynamic update statement: positioned> <filter clause> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <update statement: positioned> <update statement: searched> <where clause>
WIDTH_BUCKET	<reserved word> <width bucket function>
WINDOW	<reserved word> <window clause>
WITH	<allocate descriptor statement> <alter sequence generator restart option> <cast to distinct> <cast to ref> <cast to source> <cast to type> <collection derived table> <column options> <cursor holdability> <cursor returnability> <from sql> <grant privilege statement> <grant role statement> <map category> <nesting option> <relative category> <reserved word> <role definition> <sequence generator start with option> <to sql> <user-defined cast definition> <view column option> <view definition> <with clause> <with or without data> <with or without time zone>
WITHIN	<reserved word> <within group specification>
WITHOUT	<cursor holdability> <cursor returnability> <nesting option> <reserved word> <with or without time zone>
WORK	<commit statement> <non-reserved word> <rollback statement>
WRITE	<non-reserved word> <transaction access mode>
YEAR	<non-second primary datetime field> <reserved word>
ZONE	<non-reserved word> <set local time zone statement> <time zone specifier> <with or without time zone>

Top

Please send feedback to Jonathan Leffler: jonathan.leffler@gmail.com .