BNF Grammar for ISO/IEC 9075:1999 - Database Language SQL (SQL-99)

Cross-Reference: rules
Cross-Reference: keywords

Derived from file sql-99.bnf version 2.10 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

Using Appendix G of "SQL:1999 Understanding Relational Language Components" by J Melton and A R Simon (Morgan Kaufmann, May 2001, ISBN 0-55860-456-1) as the primary source of the syntax, here is the BNF syntax for SQL-99. The Word 97 version of this document is available from: http://www.mkp.com/books_catalog/catalog.asp?ISBN=1-55860-456-1 .

Note that this version of this file includes the corrections from ISO 9075:1999/Cor.1:2000.

The plain text version of this grammar is sql-99.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>

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

Identifying the version of SQL in use

This material (starting with <SQL object identifier>) is defined in section 6.3 "Object Identifier for Database Language SQL" of ISO/IEC 9075-1:1999 (SQL Framework). It is used to express the capabilities of an implementation. The package names are identifiers such as 'PKG001', equivalent to 'Enhanced datetime facilities', as defined in the informative Annex B to SQL Framework. Each such package identifies a number of features that are provided when the SQL object identifier claims to provide the package.

<arc2> ::= standard | 0 | standard <left paren> 0 <right paren>

<arc3> ::= 9075

<1987> ::= 0 | edition1987 <left paren> 0 <right paren>

<1989> ::= <1989 base> <1989 package>

<1989 base> ::= 1 | edition1989 <left paren> 1 <right paren>

<1989 package> ::= <integrity no> | <integrity yes>

<integrity no> ::= 0 | IntegrityNo <left paren> 0 <right paren>

<integrity yes> ::= 1 | IntegrityYes <left paren> 1 <right paren>

<1992> ::= 2 | edition1992 <left paren> 2 <right paren>

<1999> ::= 3 | edition1999 <left paren> 3 <right paren>

<intermediate> ::= 1 | Intermediate <left paren> 1 <right paren>

The parenthesized (i) and (n) are italic in the SQL standard. It is not clear exactly what this should look like, despite all the information. However, it is also not important; this is not really a part of the SQL language per se. Note that the package numbers are PKG001 to PKG009, for example. We still have to devise a mechanism to persuade bnf2yacc.pl to ignore this information.

<packages> ::= <Package PKG (i)> ...

<Part (n) yes> ::= !! (as specified in ISO/IEC 9075-(n))

<Part 3 conformance> ::= 3 | sqlcli1999 <left paren> 3 <right paren>

<Part 4 conformance> ::= 4 | sqlpsm1999 <left paren> 4 <right paren>

<Part 4 module yes> ::= 1 | moduleyes <left paren> 1 <right paren>

<Part 4 module no> ::= 0 | moduleno <left paren> 0 <right paren>

The original used sqlbindings199x, but the x should clearly be a 9.

<Part 5 conformance> ::= 5 | sqlbindings1999 <left paren> 5 <right paren>

<Part 5 direct yes> ::= 1 | directyes <left paren> 1 <right paren>

<Part 5 direct no> ::= 0 | directno <left paren> 0 <right paren>

<Part 5 embedded> ::= <Part 5 embedded no> | <Part 5 embedded languages> ...

<Part 5 embedded no> ::= 0 | embeddedno <left paren> 0 <right paren>

<Part 5 embedded Ada> ::= 1 | embeddedAda <left paren> 1 <right paren>

<Part 5 embedded C> ::= 2 | embeddedC <left paren> 2 <right paren>

<Part 5 embedded COBOL> ::= 3 | embeddedCOBOL <left paren> 3 <right paren>

<Part 5 embedded Fortran> ::= 4 | embeddedFortran <left paren> 4 <right paren>

<Part 5 embedded MUMPS> ::= 5 | embeddedMUMPS <left paren> 5 <right paren>

<Part 5 embedded Pascal> ::= 6 | embeddedPascal <left paren> 6 <right paren>

<Part 5 embedded PL/I> ::= 7 | embeddedPLI <left paren> 7 <right paren>

Top

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.

<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> ::= ?

<left bracket> ::= [

<right bracket> ::= ]

<circumflex> ::= ^

<underscore> ::= _

<vertical bar> ::= |

<left brace> ::= {

<right brace> ::= }

Top

Literal Numbers, Strings, Dates and Times

<SQL-client module definition> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

<identifier body> modified per ISO 9075:1999/Cor.1:2000(E).

<identifier body> also rationalized by removing curly brackets around <identifier part> because they are unnecessary and inconsistent with other places where '...' modifies a single non-terminal.

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

<initial alphabetic character> ::= !! (See the Syntax Rules)

<ideographic character> ::= !! (See the Syntax Rules)

<alphabetic character> ::= !! (See the Syntax Rules)

<decimal digit character> ::= !! (See the Syntax Rules)

<identifier combining character> ::= !! (See the Syntax Rules)

<alternate underscore> ::= !! (See the Syntax Rules)

<extender character> ::= !! (See the Syntax Rules)

<identifier ignorable character> ::= !! (See the Syntax Rules)

<connector character> ::= !! (See the Syntax Rules)

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

<nondoublequote character> ::= !! (See the Syntax Rules)

Note that the two successive double quote characters must have no other character (such as a space) between them. The lexical analyzer would normally deal with this sort of issue.

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

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

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

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

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

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

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

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

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

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

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

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

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

Top

Data Types

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

<multiplier> ::= K | M | G

<binary large object string type>    ::=
         BINARY LARGE OBJECT [ <left paren> <large object length> <right paren> ]
     |     BLOB [ <left paren> <large object length> <right paren> ]

<bit string type>    ::=
         BIT [ <left paren> <length> <right paren> ]
     |     BIT VARYING <left paren> <length> <right paren>

<exact numeric type>    ::=
         NUMERIC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
     |     DECIMAL [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
     |     DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
     |     INTEGER
     |     INT
     |     SMALLINT

<approximate numeric type>    ::=
         FLOAT [ <left paren> <precision> <right paren> ]
     |     REAL
     |     DOUBLE PRECISION

<boolean type> ::= BOOLEAN

<datetime type>    ::=
         DATE
     |     TIME [ <left paren> <time precision> <right paren> ] [ <with or without time zone> ]
     |     TIMESTAMP [ <left paren> <timestamp precision> <right paren> ] [ <with or without time zone> ]

<with or without time zone> ::= WITH TIME ZONE | WITHOUT TIME ZONE

<interval type> ::= INTERVAL <interval qualifier>

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

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

<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> ]

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

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

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

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

<reference type> ::= REF <left paren> <referenced type> <right paren> [ <scope clause> ]

<scope clause> ::= SCOPE <table name>

<collection type constructor> ::= ARRAY

The trigraphs are strictly sequences of characters, not sequences of tokens. There may not be any spaces between the characters. Normally, the lexical analyzer would return the trigraphs as a simple symbol.

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

Top

Literals

<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.

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

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

<newline> ::= !! (See the Syntax Rules)

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> }... ]

<white space> ::= !! (See the Syntax Rules)

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

<bit string literal>    ::=
         B <quote> [ <bit> ... ] <quote>
         [ { <separator> <quote> [ <bit> ... ] <quote> }... ]

<bit> ::= 0 | 1

<hex string literal>    ::=
         X <quote> [ <hexit> ... ] <quote>
         [ { <separator> <quote> [ <hexit> ... ] <quote> }... ]

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

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

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

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

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

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

<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> ] ] ]

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

<current date value function> ::= CURRENT_DATE

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

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

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

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

<null specification> ::= NULL

<empty specification> ::= ARRAY <left bracket or trigraph> <right bracket or trigraph>

Top

Constraints

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

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

<unique specification> ::= UNIQUE | PRIMARY KEY

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

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

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

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

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

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

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

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

Top

Search Condition

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

<host parameter specification> ::= <host parameter name> [ <indicator parameter> ]

<indicator parameter> ::= [ INDICATOR ] <host parameter name>

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

<column reference>    ::=
         <basic identifier chain>
     |     MODULE <period> <qualified identifier> <period> <column name>

<set function specification>    ::=
         COUNT <left paren> <asterisk> <right paren>
     |     <general set function>
     |     <grouping operation>

<computational operation> ::= AVG | MAX | MIN | SUM | EVERY | ANY | SOME | COUNT

<set quantifier> ::= DISTINCT | ALL

<grouping operation> ::= GROUPING <left paren> <column reference> <right paren>

Top

Queries

<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> ]

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

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

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

<sort specification> modified per ISO 9075:1999/Cor.1:2000(E)

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

<ordering specification> ::= ASC | DESC

<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>

<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>

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

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

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

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

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

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

<lateral derived table> ::= LATERAL <left paren> <query expression> <right paren>

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

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

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

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

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

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

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

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

Rules from <group by clause> to <grouping set> modified per ISO 9075:1999/Cor.1:2000(E)

<group by clause> ::= GROUP BY <grouping element list>

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

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

<rollup list> ::= ROLLUP <left paren> <grouping column reference list> <right paren>

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

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

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

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

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

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

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

Top

Query expression components

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

<case abbreviation>    ::=
         NULLIF <left paren> <value expression> <comma> <value expression> <right paren>
     |     COALESCE <left paren> <value expression> { <comma> <value expression> }... <right paren>

<simple case> ::= CASE <case operand> <simple when clause> ... [ <else clause> ] END

<result> ::= <result expression> | NULL

<searched case> ::= CASE <searched when clause> ... [ <else clause> ] END

<subtype treatment> to <target subtype> modified per ISO 9075:1999/Cor.1:2000(E)

<subtype treatment> ::=
TREAT <left paren> <subtype operand> AS <target subtype> <right paren>

<attribute or method reference>    ::=
         <value expression primary> <dereference operator> <qualified identifier>
         [ <SQL argument list> ]

<reference resolution> ::= DEREF <left paren> <reference value expression> <right paren>

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

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

<concatenation operator> ::= ||

<direct invocation> ::=
<value expression primary> <period> <method name> [ <SQL argument list> ]

<generalized invocation>    ::=
         <left paren> <value expression primary>
         AS <data type> <right paren> <period> <method name>
         [ <SQL argument list> ]

It is not remotely clear why this was needed in this grammar. <constructor method selection> added per ISO 9075:1999/Cor.1:2000(E)

<static method invocation> ::=
<user-defined type> <double colon> <method name> [ <SQL argument list> ]

Note that <double colon> must be a pair of characters with no intervening space, not a pair of colon symbols separated by arbitrary white space. Normally, the lexical analyzer would return <double colon> as a symbol.

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

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

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

<regular expression substring function> modified per ISO 9075:1999/Cor.1:2000(E)

<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>

<form-of-use conversion>    ::=
         CONVERT <left paren> <character value expression>
         USING <form-of-use conversion name> <right paren>

<form-of-use conversion name> ::= <schema qualified name>

<character translation>    ::=
         TRANSLATE <left paren> <character value expression>
         USING <translation 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> ] <right paren>

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

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

<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>

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

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

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

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

<time zone field> ::= TIMEZONE_HOUR | TIMEZONE_MINUTE

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

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

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

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

<bit length expression> ::=
BIT_LENGTH <left paren> <string value expression> <right paren>

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

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

The <not equals>, <less than or equals operator> and <greater than or equals operator> should be handled by the lexical analyzer as token symbols, not by the grammar. As usual, spaces are not allowed between the two characters.

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

Previously, the expression in curly braces was not in square brackets. Consequently, every <in value list> had to have at least two items in it.

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

<character like predicate> ::=
<character match value> [ NOT ] LIKE <character pattern> [ ESCAPE <escape character> ]

<octet like predicate> ::=
<octet match value> [ NOT ] LIKE <octet pattern> [ ESCAPE <escape octet> ]

<null predicate> ::= <row value expression> IS [ NOT ] NULL

<all> ::= ALL

<some> ::= SOME | ANY

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

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

<match predicate>    ::=
         <row value expression> MATCH [ UNIQUE ] [ SIMPLE | PARTIAL | FULL ]
         <table subquery>

<overlaps predicate> ::= <row value expression 1> OVERLAPS <row value expression 2>

Top

Regular Expressions for SIMILAR TO

These regular expressions are not referenced anywhere else in the document, but define the structure that the <character value expression> used in <similar pattern> must have. Structurally, these regular expressions are similar to 'egrep' expressions, except they use underscore in place of dot, and percent is equivalent to dot star in 'egrep'. The other omission is the use of caret (aka circumflex) to mark the start of the matched text and dollar to mark the end of the matched text.

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

<escaped character> ::= !! (See the Syntax Rules)

Top

<distinct predicate> ::=
<row value expression 3> IS DISTINCT FROM <row value expression 4>

<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>

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

Top

More about constraints

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

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

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

The standard documents UNIQUE ( VALUE ) but there is no explanation of why that is different from the UNIQUE <left paren> VALUE <right paren> used here.

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

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

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

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

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

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

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

<table commit action> ::= PRESERVE | DELETE

Top

Module contents

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

<local qualifier> ::= MODULE

<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> ]

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

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

Top

SQL Procedures

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

<host parameter declaration setup> modified per ISO 9075:1999/Cor.1:2000(E)

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

<locator indication> ::= AS LOCATOR

<status parameter> ::= SQLSTATE

Top

SQL Schema Definition Statements

<SQL schema definition statement> modified per ISO 9075:1999/Cor.1:2000(E)

<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>

<schema element> modified per ISO 9075:1999/Cor.1:2000(E)

<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 contents source>    ::=
         <table element list>
     |     OF <user-defined type> [ <subtable clause> ] [ <table element list> ]

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

<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 <user-defined type> [ <subview clause> ] [ <view element list> ]

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

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

<levels clause> ::= CASCADED | LOCAL

<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> ]

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

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

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

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

<specific routine designator> modified per ISO 9075:1999/Cor.1:2000(E)

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

<specific routine designator> modified per ISO 9075:1999/Cor.1:2000(E)

<member name> ::= <schema qualified routine name> [ <data type list> ]

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

<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> ]

<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>

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

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

<user-defined type body> modified per ISO 9075:1999/Cor.1:2000(E)

<user-defined type body>    ::=
         <user-defined type name> [ <subtype clause> ] [ AS <representation> ]
         [ <instantiable clause> ] <finality> [ <reference type specification> ]
         [ <ref cast option> ] [ <cast option> ] [ <method specification list> ]

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

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

<instantiable clause> ::= INSTANTIABLE | NOT INSTANTIABLE

<finality> ::= FINAL | NOT FINAL

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

<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>

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

<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> ]

<partial method specification> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

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

<returns clause> ::= RETURNS <returns data type> [ <result cast> ]

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

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

<specific method name> added per ISO 9075:1999/Cor.1:2000(E)

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

<method characteristic> modified per ISO 9075:1999/Cor.1:2000(E)

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

<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

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

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

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

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

<routine characteristic> modified per ISO 9075:1999/Cor.1:2000(E)

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

<external body reference> modified per ISO 9075:1999/Cor.1:2000(E)

<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

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

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

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

<dispatch clause> ::= STATIC DISPATCH

<method specification designator> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

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

<grantor> ::= CURRENT_USER | CURRENT_ROLE

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

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

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

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

<user-defined ordering specification> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

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

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

<transform definition> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

Top

SQL Schema Manipulation Statements

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

<drop behavior> ::= CASCADE | RESTRICT

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

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

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

<drop column default clause> ::= DROP DEFAULT

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

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

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

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

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

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

<alter routine behaviour> ::= RESTRICT

<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>

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

<drop domain default clause> ::= DROP DEFAULT

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

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

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

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

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

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

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

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

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

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

<drop method specification> modified per ISO 9075:1999/Cor.1:2000(E)

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

<specific method specification designator> added per ISO 9075:1999/Cor.1:2000(E)

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

<drop user-defined ordering statement> modified per ISO 9075:1999/Cor.1:2000(E)

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

<drop transform statement> modified per ISO 9075:1999/Cor.1:2000(E)

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

Top

SQL Data Manipulation Statements

<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> }... ]

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

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

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

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

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

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

<target table> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

<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> }... ]

<default specification> ::= DEFAULT

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

<from default> ::= DEFAULT VALUES

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

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

<update target> modified per ISO 9075:1999/Cor.1:2000(E)

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

Top

SQL Control Statements

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

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

Top

Transaction Management

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

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

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

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

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

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

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

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

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

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

<savepoint specifier> modified per ISO 9075:1999/Cor.1:2000(E)

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

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

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

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

Top

Connection Management

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

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

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

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

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

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

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

Top

Session Attributes

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

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

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

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

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

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

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

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

<new invocation> modified per ISO 9075:1999/Cor.1:2000(E)

<reserved word> modified per ISO 9075:1999/Cor.1:2000(E)

<non-reserved word> modified per ISO 9075:1999/Cor.1:2000(E)

<CLI routine> ::= <CLI routine name> <CLI parameter list> [ <CLI returns clause> ]

<CLI by-reference prefix> ::= SQLR

<CLI by-value prefix> ::= SQL

<implementation-defined CLI generic name> ::= !! (See the Syntax Rules)

<CLI parameter name> ::= !! (See the individual CLI routine definitions)

<CLI parameter mode> ::= IN | OUT | DEFIN | DEFOUT | DEF

<CLI parameter data type>    ::=
         INTEGER
     |     SMALLINT
     |     ANY
     |     CHARACTER <left paren> <length> <right paren>

<CLI returns clause> ::= RETURNS SMALLINT

<compound statement>    ::=
         [ <beginning label> <colon> ] BEGIN [ [ NOT ] ATOMIC ]
         [ <local declaration list> ] [ <local cursor declaration list> ] [ <local handler declaration list> ]
         [ <SQL statement list> ] END [ <ending label> ]

<local declaration list> ::= <terminated local declaration> ...

<SQL variable declaration> ::=
DECLARE <SQL variable name list> <data type> [ <default clause> ]

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

<condition declaration> ::=
DECLARE <condition name> CONDITION [ FOR <sqlstate value> ]

<sqlstate value> ::= SQLSTATE [ VALUE ] <character string literal>

<local cursor declaration list> ::= <terminated local cursor declaration> ...

<local handler declaration list> ::= <terminated local handler declaration> ...

<handler declaration> ::=
DECLARE <handler type> HANDLER FOR <condition value list> <handler action>

<handler type> ::= CONTINUE | EXIT | UNDO

<condition value list> ::= <condition value> [ { <comma> <condition value> }... ]

<condition value> ::=
<sqlstate value> | <condition name> | SQLEXCEPTION | SQLWARNING | NOT FOUND

<SQL statement list> ::= <terminated SQL statement> ...

<simple case statement> ::=
CASE <simple case operand 1> <simple case statement when clause> ... [ <case statement else clause> ] END CASE

<searched case statement> ::=
CASE <searched case statement when clause> ... [ <case statement else clause> ] END CASE

<if statement>    ::=
         IF <search condition> <if statement then clause>
         [ <if statement elseif clause> ... ] [ <if statement else clause> ]
         END IF

<if statement elseif clause> ::= ELSEIF <search condition> THEN <SQL statement list>

<iterate statement> ::= ITERATE <statement label>

<leave statement> ::= LEAVE <statement label>

<loop statement> ::=
[ <beginning label> <colon> ] LOOP <SQL statement list> END LOOP [ <ending label> ]

<while statement> ::=
[ <beginning label> <colon> ] WHILE <search condition> DO <SQL statement list> END WHILE [ <ending label> ]

<repeat statement> ::=
[ <beginning label> <colon> ] REPEAT <SQL statement list> UNTIL <search condition> END REPEAT [ <ending label> ]

<for statement>    ::=
         [ <beginning label> <colon> ] FOR <for loop variable name> AS
         [ <cursor name> [ <cursor sensitivity> ] CURSOR FOR ] <cursor specification>
         DO <SQL statement list> END FOR [ <ending label> ]

<signal statement> ::= SIGNAL <signal value> [ <set signal information> ]

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

<resignal statement> ::= RESIGNAL [ <signal value> ] [ <set signal information> ]

<SQL-server module definition>    ::=
         CREATE MODULE <SQL-server module name> [ <SQL-server module character set specification> ]
         [ <SQL-server module schema clause> ] [ <SQL-server module path specification> ]
         [ <temporary table declaration> ]
         <SQL-server module contents> ...
         END MODULE

<SQL-server module name> ::= <schema qualified name>

<SQL-server module character set specification> ::= NAMES ARE <character set specification>

<SQL-server module schema clause> ::= SCHEMA <default schema name>

<SQL-server module path specification> ::= <path specification>

<SQL-server module contents> ::= <SQL-invoked routine> <semicolon>

<module procedure> ::= [ DECLARE ] <SQL-invoked procedure>

<module function> ::= [ DECLARE ] <SQL-invoked function>

<drop module statement> ::= DROP MODULE <SQL-server module name> <drop behavior>

This definition of <triggered SQL statement> is from 9075-4 (SQL/PSM) and is documented with: NOTE 13 – The preceding production defining <triggered SQL statement> completely supersedes the definition in ISO/IEC 9075-2.

Top

Dynamic SQL

Much, if not all, of the following material comes from ISO/IEC 9075-5:1999, SQL/Bindings.

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

<scope option> ::= GLOBAL | LOCAL

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

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

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

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

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

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

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

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

<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> }... ]

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

<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> }... ]

<prepare statement> ::=
PREPARE <SQL statement name> FROM <SQL statement variable>

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

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

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

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

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

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

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

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

<embedded variable specification> ::= <embedded variable name> [ <indicator variable> ]

<indicator variable> ::= [ INDICATOR ] <embedded variable name>

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

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

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

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

<statement cursor>    ::=
         [ <cursor sensitivity> ] [ SCROLL ] CURSOR [ WITH HOLD ] [ WITH RETURN ]
         FOR <extended statement name>

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

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

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

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

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

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

Note that <double period> must be a pair of period characters with no intervening space, not a pair of period symbols separated by arbitrary white space. Normally, the lexical analyzer would return <double period> as a symbol.

<direct select statement: multiple rows> ::= <query expression> [ <order by clause> ]

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

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

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

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

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

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

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

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

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

<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 <user-defined type name> AS LOCATOR

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

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

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

<C class modifier> ::= const | volatile

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

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

<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 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 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 bit variable>    ::=
         BIT <C host identifier> <C array specification> [ <C initial value> ]
         [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] }... ]

<C user-defined type variable>    ::=
         SQL TYPE IS <user-defined type> AS <predefined type>
         <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 <collection 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 <user-defined type> AS LOCATOR
         <C host identifier> [ <C initial value> ] [ { <comma> <C host identifier> [ <C initial value> ] }... ]

<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 bit type>    ::=
         { PIC | PICTURE } [ IS ] { X [ <left paren> <length> <right paren> ] }...
         USAGE [ IS ] BIT

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

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

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

<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 <user-defined type> 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 <collection type> AS LOCATOR

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

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

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

The standard documents 'CHARACTER KIND = n' but there is no explanation of the italic 'n' that is used. Presumably, it is an integer literal, hence <unsigned integer>.

<Fortran type specification>    ::=
         CHARACTER [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
     |     CHARACTER KIND <equals operator> <unsigned integer> [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
     |     BIT [ <asterisk> <length> ]
     |     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 <user-defined type name> AS LOCATOR

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

<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 character variable>    ::=
         VARCHAR <MUMPS host identifier> <MUMPS length specification>
         [ { <comma> <MUMPS host identifier> <MUMPS length specification> }... ]

<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 <user-defined type name> AS LOCATOR

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

<Pascal type specification>    ::=
         PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket>
         OF CHAR [ CHARACTER SET [ IS ] <character set specification> ]
     |     PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket> OF BIT
     |     INTEGER
     |     REAL
     |     CHAR [ CHARACTER SET [ IS ] <character set specification> ]
     |     BIT
     |     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 <user-defined type name> AS LOCATOR

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

<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 type specification>    ::=
         { CHAR | CHARACTER } [ VARYING ] <left paren> <length> <right paren>
         [ CHARACTER SET [ IS ] <character set specification> ]
     |     BIT [ VARYING ] <left paren> <length> <right paren>
     |     <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 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 }

<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 <user-defined type name> AS LOCATOR

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

<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>

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

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

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

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

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

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

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

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

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

<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 exception declaration> ::= WHENEVER <condition> <condition action>

The standard documents 'SQLSTATE ( <SQLSTATE class value> [ , <SQLSTATE subclass value> ] )', but it is not clear why the <left paren>, <comma> and <right paren> are not designated more accurately.

<SQL condition>    ::=
         <major category>
     |     SQLSTATE <left paren> <SQLSTATE class value> [ <comma> <SQLSTATE subclass value> ] <right paren>
     |     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.)

This interval primary definition from 9075-5 (SQL/Bindings) is very similar to a previous occurrence from 9075-2 (SQL/Foundation), but adds the optional interval qualifier. The earlier definition is commented out.

This module authorization clause definition from 9075-5 (SQL/Bindings) is similar to a previous occurrence from 9075-2 (SQL/Foundation) but the optional 'FOR STATIC ONLY' and 'FOR STATIC AND DYNAMIC' clauses were not present before. The earlier definition is commented out.

<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 } ]

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

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

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

Top

END OF SQL-99 GRAMMAR

Top

Notes on Automatically Converting the SQL-99 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

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
1987	<SQL edition>
1989	<SQL edition>
1989 base	<1989>
1989 package	<1989>
1992	<SQL edition>
1999	<SQL edition>
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 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>
all	<quantifier>
all fields reference	<qualified asterisk>
allocate cursor statement	<SQL dynamic data statement>
allocate descriptor statement	<system descriptor statement>
alphabetic character	<identifier part>
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 routine behaviour	<alter routine statement>
alter routine characteristic	<alter routine characteristics>
alter routine characteristics	<alter routine statement>
alter routine statement	<SQL schema manipulation statement>
alter table action	<alter table statement>
alter table statement	<SQL schema manipulation statement>
alter type action	<alter type statement>
alter type statement	<SQL schema manipulation statement>
alternate underscore	<identifier part>
ampersand	<SQL prefix> <SQL special character>
approximate numeric literal	<unsigned numeric literal>
approximate numeric type	<numeric type>
arc1	<SQL provenance>
arc2	<SQL provenance>
arc3	<SQL provenance>
array concatenation	<array value expression>
array element	<array element list>
array element list	<array value list constructor>
array specification	<collection type>
array value constructor	<array value expression>
array value expression	<array value expression 1> <array value expression 2> <collection value constructor> <element reference>
array value expression 1	<array concatenation>
array value expression 2	<array concatenation>
array value list constructor	<array value constructor>
as clause	<derived column>
assertion definition	<schema element> <SQL schema definition statement>
assignment source	<assignment statement>
assignment statement	<SQL control statement>
assignment target	<assignment statement>
asterisk	<all fields reference> <bracketed comment introducer> <bracketed comment terminator> <Fortran type specification> <interval term> <qualified asterisk> <regular factor> <select list> <set function specification> <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>
authorization identifier	<grantee> <module authorization identifier> <schema authorization identifier>
basic identifier chain	<column reference> <SQL parameter reference> <SQL variable reference>
beginning label	<compound statement> <for statement> <loop statement> <repeat statement> <while statement>
between predicate	<predicate>
binary large object string type	<predefined type>
binary string literal	<general literal>
bit	<bit string literal>
bit concatenation	<bit value expression>
bit factor	<bit concatenation> <bit value expression>
bit length expression	<length expression>
bit primary	<bit factor>
bit string literal	<general literal> <nondelimiter token>
bit string type	<predefined type>
bit substring function	<bit value function>
bit value expression	<bit concatenation> <bit substring function> <string value expression>
bit value function	<string value function>
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 match value> <octet pattern> <string value expression> <trim octet>
blob value function	<string value function>
boolean factor	<boolean term>
boolean literal	<general literal>
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> <parenthesized boolean value expression> <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 bit variable> <C character variable> <C NCHAR variable> <C NCHAR VARYING variable> <C VARCHAR variable>
C bit variable	<C derived 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 bit variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB 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 bit variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB 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 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>
case statement	<SQL control statement>
case statement else clause	<searched case statement> <simple case statement>
cast function	<user-defined cast definition>
cast operand	<cast specification>
cast option	<user-defined type body>
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>
char length expression	<length expression>
character enumeration	<regular character set>
character factor	<character value expression> <concatenation>
character like predicate	<like predicate>
character match value	<character like predicate> <similar predicate>
character overlay function	<character value function>
character pattern	<character like predicate>
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>
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 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> <SQL-server module character set specification> <target character set specification>
character specifier	<character enumeration> <regular primary>
character string literal	<delimiter token> <external routine name> <general literal> <sqlstate value>
character string type	<predefined type>
character substring function	<character value function>
character translation	<character value function>
character value expression	<character match value> <character overlay function> <character pattern> <character substring function> <character translation> <concatenation> <escape character> <fold> <form-of-use conversion> <regular expression substring function> <similar pattern> <string value expression> <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>
CLI by-reference prefix	<CLI name prefix>
CLI by-value prefix	<CLI name prefix>
CLI generic name	<CLI routine name>
CLI name prefix	<CLI routine name>
CLI parameter data type	<CLI parameter declaration>
CLI parameter declaration	<CLI parameter list>
CLI parameter list	<CLI routine>
CLI parameter mode	<CLI parameter declaration>
CLI parameter name	<CLI parameter declaration>
CLI returns clause	<CLI routine>
CLI routine name	<CLI routine>
close statement	<SQL data statement>
COBOL array locator variable	<COBOL derived type specification>
COBOL binary integer	<COBOL integer type>
COBOL bit type	<COBOL type specification>
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 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> <column option list> <domain definition> <field definition> <grouping column reference>
collation definition	<schema element> <SQL schema definition statement>
collation name	<collate clause> <collation definition> <drop collation statement> <existing collation name> <object name>
collection derived table	<table primary>
collection type	<Ada array locator variable> <C array locator variable> <COBOL array locator variable> <data type> <Fortran array locator variable> <MUMPS array locator variable> <Pascal array locator variable> <PL/I array locator variable>
collection type constructor	<array specification>
collection value constructor	<nonparenthesized value expression primary>
collection value expression	<cardinality expression> <collection derived table> <value expression>
colon	<Ada assignment operator> <Ada variable definition> <compound statement> <day-time interval> <double colon> <embedded variable name> <for statement> <host parameter name> <loop statement> <Pascal variable definition> <regular character set> <repeat statement> <SQL special character> <time interval> <time value> <time zone interval> <while statement>
column constraint	<column constraint definition>
column constraint definition	<column definition> <column option list>
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> <view column option>
column name list	<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 specification>
comma	<Ada variable definition> <array element list> <C array locator variable> <C bit variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB 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> <CLI parameter list> <column name list> <concatenated grouping> <condition information> <condition value list> <constraint name list> <contextually typed row value constructor element list> <contextually typed row value expression list> <cycle column list> <data type list> <exact numeric type> <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 set list> <hold locator statement> <host parameter declaration list> <in value list> <into arguments> <list of attributes> <member list> <method specification list> <modulus expression> <multiple group specification> <MUMPS character variable> <MUMPS numeric variable> <MUMPS type specification> <object privileges> <Pascal variable definition> <PL/I type specification> <PL/I variable definition> <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> <signal information item list> <single datetime field> <sort specification list> <SQL argument list> <SQL condition> <SQL parameter declaration list> <SQL special character> <SQL variable name list> <start transaction statement> <statement information> <table element list> <table reference list> <transaction characteristics> <transform element list> <type list> <using arguments> <view element list> <with list>
comment	<separator>
comment character	<bracketed comment contents> <simple comment>
commit statement	<SQL transaction statement>
comp op	<comparison predicate> <quantified comparison predicate>
comparison predicate	<predicate>
compound statement	<SQL control statement>
computational operation	<set function type>
concatenation	<character value expression>
concatenation operator	<array concatenation> <bit concatenation> <blob concatenation> <concatenation> <delimiter token>
condition	<embedded exception declaration>
condition action	<embedded exception declaration>
condition declaration	<local declaration>
condition information	<SQL diagnostics information>
condition information item	<condition information>
condition information item name	<condition information item> <signal information item>
condition name	<condition declaration> <condition value> <signal value>
condition number	<condition information>
condition value	<condition value list>
condition value list	<handler declaration>
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>
connector character	<identifier part>
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	<contextually typed row value expression list> <contextually typed source>
contextually typed row value expression list	<contextually typed table value constructor>
contextually typed source	<assignment source>
contextually typed table value constructor	<from constructor>
contextually typed value specification	<contextually typed row value constructor element> <update source>
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 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 holdability	<declare cursor> <dynamic declare cursor>
cursor intent	<allocate cursor statement>
cursor name	<close statement> <declare cursor> <delete statement: positioned> <dynamic cursor name> <dynamic declare cursor> <fetch statement> <for statement> <open statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned>
cursor returnability	<declare cursor> <dynamic declare cursor>
cursor scrollability	<declare cursor> <dynamic declare cursor>
cursor sensitivity	<declare cursor> <dynamic declare cursor> <for statement> <statement cursor>
cursor specification	<declare cursor> <dynamic select statement> <for 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	<attribute definition> <cast target> <collection type> <column definition> <data type list> <domain definition> <field definition> <generalized invocation> <host parameter data type> <parameter type> <result cast from type> <returns data type> <source data type> <SQL variable declaration>
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	<datetime value expression> <extract source> <interval value expression> <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>
decimal digit character	<identifier part>
declare cursor	<module contents> <statement or declaration> <terminated local cursor declaration>
default clause	<attribute default> <column definition> <column option list> <domain definition> <set column default clause> <set domain default clause> <SQL variable declaration>
default option	<default clause>
default schema name	<SQL-server module schema 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>
delimiter token	<token>
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>
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>
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 module statement> <drop routine statement> <drop schema statement> <drop table constraint definition> <drop table statement> <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 module statement	<SQL schema manipulation statement>
drop role statement	<SQL schema manipulation statement>
drop routine statement	<SQL schema manipulation statement>
drop schema statement	<SQL schema manipulation statement>
drop table constraint definition	<alter table action>
drop table statement	<SQL schema manipulation statement>
drop transform statement	<SQL schema manipulation statement>
drop translation 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>
element reference	<nonparenthesized value expression primary>
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 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 specification	<implicitly typed value specification>
end field	<interval qualifier>
ending label	<compound statement> <for statement> <loop statement> <repeat statement> <while statement>
equals operator	<Ada assignment operator> <assignment statement> <C initial value> <comp op> <condition information item> <Fortran type specification> <get header information> <get item information> <greater than or equals operator> <less than or equals operator> <set clause> <set header information> <set item information> <signal information item> <SQL special character> <statement information item>
equals ordering form	<ordering form>
escape character	<character like predicate> <regular expression substring function> <similar predicate>
escape octet	<octet like predicate>
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 translation name	<translation source>
exists predicate	<predicate>
explicit table	<simple table>
exponent	<approximate numeric literal>
extended cursor name	<allocate cursor statement> <described object> <dynamic cursor name>
extended statement name	<SQL statement name> <statement cursor>
extender character	<identifier part>
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> <modified field reference>
field reference	<nonparenthesized value expression primary>
finality	<user-defined type body>
fold	<character value function>
for loop variable name	<for statement>
for statement	<SQL control statement>
form-of-use conversion	<character value function>
form-of-use conversion name	<form-of-use conversion>
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 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	<set function specification>
general value specification	<unsigned value specification> <using argument> <value specification>
generalized expression	<SQL argument>
generalized invocation	<method invocation>
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>
grand total	<grouping element> <grouping set>
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> <SQL special character>
greater than or equals operator	<comp op> <delimiter token>
group by clause	<table expression>
group name	<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	<cube list> <ordinary grouping set> <rollup list>
grouping element	<grouping element list>
grouping element list	<group by clause>
grouping operation	<set function specification>
grouping set	<concatenated grouping> <grouping set list>
grouping set list	<concatenated grouping> <grouping sets specification>
grouping sets specification	<grouping element> <grouping set>
handler action	<handler declaration>
handler declaration	<statement or declaration> <terminated local handler declaration>
handler type	<handler declaration>
having clause	<table expression>
header item name	<get header information> <set header information>
hex string literal	<general literal> <nondelimiter token>
hexit	<binary string literal> <hex string literal>
high	<level>
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	<host parameter declaration setup>
host parameter declaration setup	<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>
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> <condition name> <correlation name> <external routine name> <field name> <for loop variable 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 variable name> <SQL-client module name> <statement label> <statement name> <unqualified schema name> <user identifier>
identifier body	<regular identifier>
identifier chain	<basic identifier chain>
identifier combining character	<identifier part>
identifier ignorable character	<identifier part>
identifier part	<identifier body>
identifier start	<identifier body>
ideographic character	<identifier part> <identifier start>
if statement	<SQL control statement>
if statement else clause	<if statement>
if statement elseif clause	<if statement>
if statement then clause	<if statement>
implementation-defined character set name	<character set specification>
implementation-defined CLI generic name	<CLI generic name>
implicitly typed value specification	<cast operand> <contextually typed source> <contextually typed value specification> <default option>
in predicate	<predicate>
in predicate value	<in predicate>
in value list	<in predicate value>
inclusive user-defined type specification	<user-defined type specification>
indicator parameter	<host parameter specification>
indicator variable	<embedded variable specification>
initial alphabetic character	<identifier start>
input using clause	<dynamic open statement> <parameter using clause>
insert column list	<from constructor> <from subquery>
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 body>
integrity no	<1989 package>
integrity yes	<1989 package>
intermediate	<level>
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	<datetime value expression> <extract source> <interval absolute value function> <interval value expression 1> <set time zone value> <value expression>
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>
isolation level	<transaction mode>
item number	<get descriptor information> <set descriptor information>
iterate statement	<SQL control statement>
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 reference>
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>
leave statement	<SQL control statement>
left brace	<SQL special character>
left bracket	<C array specification> <left bracket or trigraph> <Pascal type specification> <regular character set> <SQL special character>
left bracket or trigraph	<array specification> <array value list constructor> <element reference> <empty specification> <update target>
left bracket trigraph	<delimiter token> <left bracket or trigraph>
left paren	<1987> <1989 base> <1992> <1999> <absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <arc1> <arc2> <assertion definition> <binary large object string type> <bit length expression> <bit string type> <bit substring 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> <char length expression> <character overlay function> <character string type> <character substring function> <character translation> <check constraint definition> <CLI parameter data type> <CLI parameter list> <COBOL bit type> <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 local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop user-defined cast statement> <end field> <exact numeric type> <extract expression> <fold> <form-of-use conversion> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <grand total> <grouping operation> <grouping sets specification> <high> <host parameter declaration list> <in predicate value> <integrity no> <integrity yes> <intermediate> <interval absolute value function> <interval value expression> <lateral derived table> <left bracket trigraph> <list of attributes> <low> <member list> <modified field target> <modulus expression> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <mutated target specification> <named columns join> <national character string type> <non-join query primary> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Part (n) no> <Part 3 conformance> <Part 4 conformance> <Part 4 module no> <Part 4 module yes> <Part 5 conformance> <Part 5 direct no> <Part 5 direct yes> <Part 5 embedded Ada> <Part 5 embedded C> <Part 5 embedded COBOL> <Part 5 embedded Fortran> <Part 5 embedded MUMPS> <Part 5 embedded no> <Part 5 embedded Pascal> <Part 5 embedded PL/I> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <rollup list> <row type body> <row value constructor> <set function specification> <single datetime field> <SQL argument list> <SQL condition> <SQL parameter declaration list> <SQL prefix> <SQL special character> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table primary> <target table> <transform group> <triggered action> <trim function> <type predicate> <unique constraint definition> <user-defined cast definition> <view element list> <with list element>
length	<Ada qualified type specification> <Ada unqualified type specification> <bit string type> <C array specification> <character string type> <CLI parameter data type> <COBOL bit 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	<SQL conformance>
level of isolation	<isolation level>
levels clause	<view definition>
like clause	<table element>
like predicate	<predicate>
list of attributes	<derived representation>
literal	<default option> <simple value specification> <value specification>
local cursor declaration list	<compound statement>
local declaration	<terminated local declaration>
local declaration list	<compound statement>
local handler declaration list	<compound statement>
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>
loop statement	<SQL control statement>
low	<level>
major category	<SQL condition>
mantissa	<approximate numeric literal>
map category	<ordering category>
map function specification	<map category>
match predicate	<predicate>
match type	<references specification>
maximum dynamic result sets	<dynamic result sets characteristic>
member	<member list>
member list	<representation>
member name	<specific routine designator>
method characteristic	<method characteristics>
method characteristics	<original method specification>
method invocation	<new invocation> <nonparenthesized value expression primary>
method name	<direct invocation> <generalized invocation> <method reference> <method specification designator> <mutated set clause> <mutator reference> <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> <sign> <simple comment introducer> <SQL special character> <year-month literal>
minutes value	<day-time interval> <time interval> <time value> <time zone interval>
modified field reference	<assignment target> <modified field target>
modified field target	<modified field reference>
module authorization clause	<SQL-client module definition>
module authorization identifier	<embedded authorization identifier> <module authorization clause>
module character set specification	<module name clause>
module contents	<SQL-client module definition>
module function	<module routine>
module name	<object name>
module name clause	<SQL-client module definition>
module path specification	<SQL-client module definition>
module procedure	<module routine>
module routine	<SQL-invoked routine>
module transform group specification	<SQL-client module definition>
modulus expression	<numeric value function>
months value	<date value> <year-month literal>
multiple group specification	<transform group specification>
multiplier	<large object length> <large object length token> <nondelimiter token>
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 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 clause>
mutated target	<mutated set clause>
mutated target specification	<mutator reference>
mutator reference	<assignment target> <mutated target specification>
named columns join	<join specification>
national character string literal	<general literal> <nondelimiter token>
national character string type	<predefined type>
natural join	<joined table>
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>
newline	<simple comment>
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 primary> <value expression primary>
nonquote character	<character representation> <comment character>
not equals operator	<comp op> <delimiter token>
null predicate	<predicate>
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> <element reference> <numeric value expression> <numeric value expression dividend> <numeric value expression divisor> <start position> <string length> <value expression>
numeric value expression dividend	<modulus expression>
numeric value expression divisor	<modulus expression>
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 match value	<octet like predicate>
octet pattern	<octet like predicate>
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	<cursor specification> <direct select statement: multiple rows>
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>
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>
override clause	<from constructor> <from subquery>
overriding method specification	<add overriding method specification> <method specification>
packages	<SQL conformance>
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 primary>
parenthesized value expression	<value expression primary>
Part 10	<parts>
Part 3	<parts>
Part 3 conformance	<Part 3 yes>
Part 4	<parts>
Part 4 conformance	<Part 4 yes>
Part 4 module	<Part 4 yes>
Part 4 module no	<Part 4 module>
Part 4 module yes	<Part 4 module>
Part 5	<parts>
Part 5 conformance	<Part 5 yes>
Part 5 direct	<Part 5 yes>
Part 5 direct no	<Part 5 direct>
Part 5 direct yes	<Part 5 direct>
Part 5 embedded	<Part 5 yes>
Part 5 embedded Ada	<Part 5 embedded languages>
Part 5 embedded C	<Part 5 embedded languages>
Part 5 embedded COBOL	<Part 5 embedded languages>
Part 5 embedded Fortran	<Part 5 embedded languages>
Part 5 embedded languages	<Part 5 embedded>
Part 5 embedded MUMPS	<Part 5 embedded languages>
Part 5 embedded no	<Part 5 embedded>
Part 5 embedded Pascal	<Part 5 embedded languages>
Part 5 embedded PL/I	<Part 5 embedded languages>
Part 6	<parts>
Part 7	<parts>
Part 8	<parts>
Part 9	<parts>
partial method specification	<original method specification> <overriding method specification>
parts	<SQL conformance>
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 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> <SQL-server module path specification>
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> <modified field reference> <mutated set clause> <mutator reference> <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 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>
position expression	<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>
quantifier	<quantified comparison predicate>
query expression	<cursor specification> <direct select statement: multiple rows> <from subquery> <lateral derived table> <subquery> <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> <left bracket trigraph> <right bracket trigraph> <SQL special character>
quote	<binary string literal> <bit string literal> <character string literal> <comment character> <date string> <hex string literal> <interval string> <national character string literal> <quote symbol> <SQL special character> <time string> <timestamp string>
quote symbol	<character representation>
recursive search order	<search clause>
ref cast option	<user-defined type body>
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>
reference type specification	<user-defined type body>
reference value expression	<dereference operation> <reference resolution> <value expression>
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	<regular character set>
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 statement	<SQL control statement>
representation	<user-defined type body>
reserved word	<key word>
resignal statement	<SQL diagnostics statement>
result	<else clause> <searched when clause> <simple when clause>
result cast	<returns clause>
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 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	<SQL special character>
right bracket	<C array specification> <Pascal type specification> <regular character set> <right bracket or trigraph> <SQL special character>
right bracket or trigraph	<array specification> <array value list constructor> <element reference> <empty specification> <update target>
right bracket trigraph	<delimiter token> <right bracket or trigraph>
right paren	<1987> <1989 base> <1992> <1999> <absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <arc1> <arc2> <assertion definition> <binary large object string type> <bit length expression> <bit string type> <bit substring 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> <char length expression> <character overlay function> <character string type> <character substring function> <character translation> <check constraint definition> <CLI parameter data type> <CLI parameter list> <COBOL bit type> <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 local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop user-defined cast statement> <end field> <exact numeric type> <extract expression> <fold> <form-of-use conversion> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <grand total> <grouping operation> <grouping sets specification> <high> <host parameter declaration list> <in predicate value> <integrity no> <integrity yes> <intermediate> <interval absolute value function> <interval value expression> <lateral derived table> <list of attributes> <low> <member list> <modified field target> <modulus expression> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <mutated target specification> <named columns join> <national character string type> <non-join query primary> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Part (n) no> <Part 3 conformance> <Part 4 conformance> <Part 4 module no> <Part 4 module yes> <Part 5 conformance> <Part 5 direct no> <Part 5 direct yes> <Part 5 embedded Ada> <Part 5 embedded C> <Part 5 embedded COBOL> <Part 5 embedded Fortran> <Part 5 embedded MUMPS> <Part 5 embedded no> <Part 5 embedded Pascal> <Part 5 embedded PL/I> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <right bracket trigraph> <rollup list> <row type body> <row value constructor> <set function specification> <single datetime field> <SQL argument list> <SQL condition> <SQL parameter declaration list> <SQL special character> <SQL terminator> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table primary> <target table> <transform group> <triggered action> <trim function> <type predicate> <unique constraint definition> <user-defined cast definition> <view element list> <with list element>
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	<row value constructor>
row type	<data type>
row type body	<row type>
row value constructor	<row value expression>
row value constructor element	<row value constructor> <row value constructor element list>
row value constructor element list	<row value constructor>
row value expression	<between predicate> <comparison predicate> <in predicate> <in value list> <match predicate> <null predicate> <quantified comparison predicate> <row value expression 1> <row value expression 2> <row value expression 3> <row value expression 4> <row value expression list> <value expression>
row value expression 1	<overlaps predicate>
row value expression 2	<overlaps predicate>
row value expression 3	<distinct predicate>
row value expression 4	<distinct predicate>
row value expression list	<table value constructor>
row value special case	<contextually typed row value expression> <row value expression>
savepoint clause	<rollback statement>
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> <default schema 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> <form-of-use conversion name> <schema qualified routine name> <specific name> <SQL-server module name> <translation name> <trigger name>
schema qualified routine name	<function specification> <member name> <SQL-invoked procedure>
schema qualified type name	<user-defined type name>
schema routine	<schema element> <SQL-invoked routine>
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> <having clause> <if statement> <if statement elseif clause> <join condition> <repeat statement> <searched case statement when clause> <searched when clause> <triggered action> <update statement: searched> <where clause> <while statement>
search or cycle clause	<with list element>
searched case	<case specification>
searched case statement	<case statement>
searched case statement when clause	<searched case statement>
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 list>
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> <SQL-server module contents> <terminated local cursor declaration> <terminated local declaration> <terminated local handler declaration> <terminated SQL statement>
separator	<binary string literal> <bit string literal> <bracketed comment contents> <character string literal> <hex string literal> <national character string literal>
sequence column	<search clause>
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> <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 quantifier	<general set function> <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 user identifier statement	<SQL session statement>
set signal information	<resignal statement> <signal statement>
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>
signal information item	<signal information item list>
signal information item list	<set signal information>
signal statement	<SQL diagnostics statement>
signal value	<resignal statement> <signal statement>
signed integer	<exponent>
signed numeric literal	<literal>
similar pattern	<similar predicate>
similar predicate	<predicate>
simple case	<case specification>
simple case operand 1	<simple case statement>
simple case operand 2	<simple case statement when clause>
simple case statement	<case statement>
simple case statement when clause	<simple case statement>
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	<condition number> <connection name> <connection user name> <descriptor name> <extended cursor name> <extended statement name> <fetch orientation> <item number> <number of conditions> <occurrences> <signal information item> <simple value specification 1> <simple value specification 2> <SQL statement variable> <SQL-server name> <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>
source character set specification	<translation 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	<partial method specification> <specific method specification designator>
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> <translation 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 conformance	<SQL variant>
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 edition	<SQL variant>
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 specification>
SQL prefix	<embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
SQL procedure statement	<externally-invoked procedure> <handler action> <SQL routine body> <statement or declaration> <terminated SQL statement> <triggered SQL statement>
SQL provenance	<SQL object identifier>
SQL routine body	<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 list	<case statement else clause> <compound statement> <for statement> <if statement else clause> <if statement elseif clause> <if statement then clause> <loop statement> <repeat statement> <searched case statement when clause> <simple case statement when clause> <while statement>
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 variable declaration	<local declaration>
SQL variable name	<SQL variable name list>
SQL variable name list	<SQL variable declaration>
SQL variable reference	<general value specification> <simple target specification> <simple value specification> <target specification>
SQL variant	<SQL object identifier>
SQL-client module name	<module name clause>
SQL-data access indication	<alter routine characteristic> <method characteristic> <routine characteristic>
SQL-invoked function	<module function> <schema function>
SQL-invoked procedure	<module procedure> <schema procedure>
SQL-invoked routine	<SQL schema definition statement> <SQL-server module contents> <statement or declaration>
SQL-path characteristic	<set path statement>
SQL-server module character set specification	<SQL-server module definition>
SQL-server module contents	<SQL-server module definition>
SQL-server module definition	<SQL schema definition statement>
SQL-server module name	<drop module statement> <SQL-server module definition>
SQL-server module path specification	<SQL-server module definition>
SQL-server module schema clause	<SQL-server module definition>
SQL-server name	<connection target>
SQLSTATE char	<SQLSTATE class value> <SQLSTATE subclass value>
SQLSTATE class value	<SQL condition>
SQLSTATE subclass value	<SQL condition>
sqlstate value	<condition declaration> <condition value> <signal value>
standard character set name	<character set specification>
start field	<interval qualifier>
start position	<bit substring function> <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 label	<beginning label> <ending label> <iterate statement> <leave statement>
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	<bit substring function> <blob overlay function> <blob substring function> <character overlay function> <character substring function>
string position expression	<position expression>
string value expression	<bit length expression> <char length expression> <octet length expression> <string position expression> <value expression>
string value function	<bit primary> <blob primary> <character primary>
subquery	<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 name	<alter table statement> <drop table statement> <drop view statement> <explicit table> <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	<only spec> <table primary>
table primary	<cross join> <natural join> <table reference> <union join>
table reference	<cross join> <natural join> <qualified join> <table reference list> <union join>
table reference list	<from clause>
table scope	<table definition>
table subquery	<derived table> <exists predicate> <in predicate value> <match predicate> <quantified comparison predicate> <unique predicate>
table value constructor	<simple table>
target character set specification	<translation definition>
target data type	<drop user-defined cast statement> <user-defined cast definition>
target specification	<assignment target> <fetch target list> <into argument> <modified field target> <mutated target specification> <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> <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> <SQL-server module definition> <statement or declaration>
term	<interval term> <numeric value expression> <term>
terminated local cursor declaration	<local cursor declaration list>
terminated local declaration	<local declaration list>
terminated local handler declaration	<local handler declaration list>
terminated SQL statement	<SQL statement list>
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>
transform definition	<schema element> <SQL schema definition statement>
transform element	<transform element list>
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>
transforms to be dropped	<drop transform statement>
translation definition	<schema element> <SQL schema definition statement>
translation name	<character translation> <drop translation statement> <existing translation name> <object name> <translation definition>
translation routine	<translation source>
translation source	<translation 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>
type predicate	<predicate>
underscore	<identifier part> <introducer> <regular character set> <SQL language identifier> <SQL special character>
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 specification> <datetime value> <exact numeric literal> <Fortran type specification> <goto target> <interval fractional seconds precision> <interval leading field precision> <large object length> <length> <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>
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 clause>
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	<Ada user-defined type variable> <C user-defined type locator variable> <C user-defined type variable> <COBOL user-defined type variable> <data type> <exclusive user-defined type specification> <Fortran user-defined type variable> <general value specification> <generalized expression> <group specification> <inclusive user-defined type specification> <MUMPS user-defined type variable> <Pascal user-defined type 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>
user-defined type body	<user-defined type definition>
user-defined type definition	<schema element> <SQL schema definition statement>
user-defined type name	<Ada user-defined type locator variable> <alter type statement> <COBOL user-defined type locator variable> <drop data type statement> <drop transform statement> <drop user-defined ordering statement> <Fortran user-defined type locator variable> <method specification designator> <MUMPS user-defined type locator variable> <object name> <Pascal user-defined type locator variable> <PL/I user-defined type locator variable> <specific routine designator> <transform definition> <user-defined ordering definition> <user-defined type> <user-defined type body>
user-defined type specification	<type list>
user-defined type value expression	<specific type method> <type predicate> <value expression>
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> <assignment source> <case abbreviation> <case operand> <cast operand> <contextually typed row value constructor element> <cycle mark value> <derived column> <general set function> <generalized expression> <non-cycle mark value> <parenthesized value expression> <result expression> <return value> <row value constructor element> <row value special case> <simple case operand 1> <simple case operand 2> <sort key> <SQL argument> <subtype operand> <update source> <when operand>
value expression primary	<all fields reference> <array value expression> <attribute or method reference> <bit primary> <blob primary> <character primary> <collection value expression> <datetime primary> <direct invocation> <field reference> <generalized invocation> <interval primary> <method reference> <numeric primary> <reference value expression> <user-defined type value expression>
value specification	<catalog name characteristic> <character set name characteristic> <role specification> <row value special case> <schema name characteristic> <set session user identifier statement> <SQL-path characteristic> <transform group characteristic>
vertical bar	<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>
while statement	<SQL control statement>
white space	<separator>
with clause	<query expression>
with column list	<with list element>
with list	<with clause>
with list element	<with list>
with or without time zone	<datetime type>
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> <reserved word>
ACTION	<referential action> <reserved word>
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> <reserved word>
ADMIN	<grant role statement> <non-reserved word> <revoke role statement> <role definition>
AFTER	<reserved word> <trigger action time>
ALL	<all> <constraint name list> <disconnect object> <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>
AllocConnect	<CLI generic name>
AllocEnv	<CLI generic name>
AllocHandle	<CLI generic name>
AllocStmt	<CLI generic name>
ALTER	<alter column definition> <alter domain statement> <alter routine statement> <alter table statement> <alter type statement> <reserved word>
AND	<between predicate> <boolean term> <commit statement> <embedded authorization clause> <module authorization clause> <reserved word> <rollback statement>
ANY	<CLI parameter data type> <computational operation> <reserved word> <some>
ARE	<embedded character set declaration> <module character set specification> <reference scope check> <reserved word> <SQL-server module character set specification>
ARRAY	<array value list constructor> <collection type constructor> <empty specification> <Pascal type specification> <reserved word>
AS	<Ada array locator variable> <Ada BLOB locator variable> <Ada CLOB locator variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <as clause> <C array locator variable> <C BLOB locator variable> <C CLOB 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 user-defined type locator variable> <COBOL user-defined type variable> <connection target> <domain definition> <drop user-defined cast statement> <for statement> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran CLOB locator variable> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <generalized expression> <generalized invocation> <locator indication> <MUMPS array locator variable> <MUMPS BLOB locator variable> <MUMPS CLOB 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 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 user-defined type locator variable> <PL/I user-defined type variable> <reserved word> <set session characteristics statement> <subtype treatment> <table primary> <user-defined cast definition> <user-defined type body> <view definition> <with list element>
ASC	<ordering specification> <reserved word>
ASENSITIVE	<cursor sensitivity> <non-reserved word>
ASSERTION	<assertion definition> <drop assertion statement> <reserved word>
ASSIGNMENT	<non-reserved word> <user-defined cast definition>
ASYMMETRIC	<between predicate> <non-reserved word>
AT	<reserved word> <time zone>
ATOMIC	<compound statement> <non-reserved word>
ATTRIBUTE	<add attribute definition> <drop attribute definition> <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	<reserved word> <trigger action time>
BEGIN	<compound statement> <embedded SQL begin declare> <embedded SQL MUMPS declare> <reserved word>
BETWEEN	<between predicate> <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>
BindCol	<CLI generic name>
BindParameter	<CLI generic name>
BIT	<Ada qualified type specification> <Ada unqualified type specification> <bit string type> <C bit variable> <COBOL bit type> <Fortran type specification> <Pascal type specification> <PL/I type specification> <reserved word>
BIT_LENGTH	<bit length expression> <non-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	<recursive search order> <reserved word>
BY	<corresponding spec> <equals ordering form> <full ordering form> <grant privilege statement> <grant role statement> <group by clause> <order by clause> <recursive search order> <reserved word> <revoke privilege statement> <revoke role statement>
C	<hexit> <language name> <non-reserved word> <simple Latin upper case letter>
CALL	<call statement> <reserved word>
CALLED	<non-reserved word> <null-call clause>
Cancel	<CLI generic name>
CARDINALITY	<cardinality expression> <descriptor item name> <non-reserved word>
CASCADE	<drop behavior> <referential action> <reserved word>
CASCADED	<levels clause> <reserved word>
CASE	<reserved word> <searched case> <searched case statement> <simple case> <simple case statement>
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> <reserved word>
CATALOG_NAME	<condition information item name> <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> <CLI parameter data 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>
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>
CloseCursor	<CLI generic name>
COALESCE	<case abbreviation> <non-reserved word>
COBOL	<language name> <non-reserved word>
ColAttribute	<CLI generic name>
COLLATE	<collate clause> <reserved word>
COLLATION	<collation definition> <drop collation statement> <object name> <reserved word>
COLLATION_CATALOG	<descriptor item name> <non-reserved word>
COLLATION_NAME	<descriptor item name> <non-reserved word>
COLLATION_SCHEMA	<descriptor item name> <non-reserved word>
COLUMN	<add column definition> <alter column definition> <drop column definition> <reserved word>
ColumnPrivileges	<CLI generic name>
Columns	<CLI generic name>
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 declaration> <reserved word>
CONDITION_IDENTIFIER	<condition information item name> <non-reserved word>
CONDITION_NUMBER	<condition information item name> <non-reserved word>
CONNECT	<connect statement> <reserved word>
Connect	<CLI generic name>
CONNECTION	<reserved word> <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	<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> <reserved word> <routine type> <specific method specification designator>
CONTAINS	<non-reserved word> <SQL-data access indication>
CONTINUE	<condition action> <handler type> <reserved word>
CONVERT	<form-of-use conversion> <non-reserved word>
CopyDesc	<CLI generic name>
CORRESPONDING	<corresponding spec> <reserved word>
COUNT	<computational operation> <header item name> <non-reserved word> <set function specification>
CREATE	<assertion definition> <character set definition> <collation definition> <domain definition> <reserved word> <role definition> <schema definition> <schema function> <schema procedure> <SQL-server module definition> <table definition> <transform definition> <translation 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>
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>
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> <for statement> <reserved word> <statement cursor>
CURSOR_NAME	<condition information item name> <non-reserved word>
CYCLE	<cycle clause> <reserved word>
DATA	<descriptor item name> <reserved word> <SQL-data access indication>
DataSources	<CLI generic name>
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	<condition declaration> <declare cursor> <dynamic declare cursor> <embedded authorization declaration> <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <handler declaration> <module function> <module procedure> <PL/I variable definition> <reserved word> <SQL variable declaration> <temporary table declaration>
DEF	<CLI parameter mode>
DEFAULT	<connection object> <connection target> <cycle clause> <default clause> <default specification> <drop column default clause> <drop domain default clause> <from default> <referential action> <reserved word> <schema character set specification> <transform group characteristic>
DEFERRABLE	<constraint characteristics> <reserved word>
DEFERRED	<constraint check time> <reserved word> <set constraints mode statement>
DEFIN	<CLI parameter mode>
DEFINED	<external security clause> <non-reserved word>
DEFINER	<external security clause> <non-reserved word>
DEFOUT	<CLI parameter mode>
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>
DEPTH	<recursive search order> <reserved word>
DEREF	<reference resolution> <reserved word>
DERIVED	<non-reserved word> <reference generation>
DESC	<ordering specification> <reserved word>
DESCRIBE	<describe input statement> <describe output statement> <reserved word>
DescribeCol	<CLI generic name>
DESCRIPTOR	<allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <into descriptor> <reserved word> <set descriptor statement> <using descriptor>
DETERMINISTIC	<deterministic characteristic> <reserved word>
DIAGNOSTICS	<diagnostics size> <get diagnostics statement> <reserved word>
directno	<Part 5 direct no>
directyes	<Part 5 direct yes>
DISCONNECT	<disconnect statement> <reserved word>
Disconnect	<CLI generic name>
DISPATCH	<dispatch clause> <non-reserved word>
DISPLAY	<COBOL numeric type>
DISTINCT	<cast to distinct> <cast to source> <distinct predicate> <non-join query expression> <non-join query term> <reserved word> <set quantifier>
DO	<for statement> <reserved word> <while statement>
DOMAIN	<alter domain statement> <domain definition> <drop domain statement> <object name> <reserved word>
DOUBLE	<approximate numeric type> <Fortran type specification> <reserved word>
double	<C numeric variable>
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 module statement> <drop role statement> <drop routine statement> <drop schema statement> <drop table constraint definition> <drop table statement> <drop transform statement> <drop translation 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> <statement information item name>
DYNAMIC_FUNCTION_CODE	<header item name> <statement information item name>
EACH	<reserved word> <triggered action>
edition1987	<1987>
edition1989	<1989 base>
edition1992	<1992>
edition1999	<1999>
ELSE	<case statement else clause> <else clause> <if statement else clause> <reserved word>
ELSEIF	<if statement elseif clause> <reserved word>
embeddedAda	<Part 5 embedded Ada>
embeddedC	<Part 5 embedded C>
embeddedCOBOL	<Part 5 embedded COBOL>
embeddedFortran	<Part 5 embedded Fortran>
embeddedMUMPS	<Part 5 embedded MUMPS>
embeddedno	<Part 5 embedded no>
embeddedPascal	<Part 5 embedded Pascal>
embeddedPLI	<Part 5 embedded PL/I>
END	<compound statement> <embedded SQL end declare> <embedded SQL MUMPS declare> <for statement> <if statement> <loop statement> <repeat statement> <reserved word> <searched case> <searched case statement> <simple case> <simple case statement> <SQL-server module definition> <while statement>
END-EXEC	<reserved word> <SQL terminator>
EndTran	<CLI generic name>
EQUALS	<equals ordering form> <reserved word>
Error	<CLI generic name>
ESCAPE	<character like predicate> <octet like predicate> <regular expression substring function> <reserved word> <similar predicate>
EVERY	<computational operation> <non-reserved word>
EXCEPT	<non-join query expression> <reserved word>
EXCEPTION	<condition information> <reserved word>
EXEC	<reserved word> <SQL prefix>
ExecDirect	<CLI generic name>
EXECUTE	<action> <execute immediate statement> <execute statement> <reserved word>
Execute	<CLI generic name>
EXISTS	<exists predicate> <reserved word>
EXIT	<handler type> <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	<CLI generic name>
FETCH	<dynamic fetch statement> <fetch statement> <reserved word>
FetchScroll	<CLI generic name>
FINAL	<finality> <non-reserved word>
FIRST	<fetch orientation> <recursive search order> <reserved word>
FIXED	<PL/I type fixed binary> <PL/I type fixed decimal>
float	<C numeric variable>
FLOAT	<approximate numeric type> <PL/I type float binary> <reserved word>
FOR	<bit substring function> <blob overlay function> <blob substring function> <character overlay function> <character substring function> <collation definition> <condition declaration> <declare cursor> <drop transform statement> <drop user-defined ordering statement> <dynamic declare cursor> <embedded authorization clause> <for statement> <group specification> <handler declaration> <method specification designator> <module authorization clause> <reserved word> <result set cursor> <revoke option extension> <revoke role statement> <specific routine designator> <statement cursor> <transform definition> <transform group characteristic> <translation definition> <triggered action> <updatability clause> <user-defined ordering definition>
FOREIGN	<referential constraint definition> <reserved word>
ForeignKeys	<CLI generic name>
FORTRAN	<language name> <non-reserved word>
FOUND	<condition value> <major category> <reserved word>
FREE	<free locator statement> <reserved word>
FreeConnect	<CLI generic name>
FreeEnv	<CLI generic name>
FreeHandle	<CLI generic name>
FreeStmt	<CLI generic name>
FROM	<bit substring function> <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> <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> <translation definition> <trim operands>
FULL	<full ordering form> <match predicate> <match type> <outer join type> <reserved word>
FUNCTION	<function specification> <reserved word> <routine type>
GENERAL	<parameter style> <reserved word>
GENERATED	<non-reserved word> <reference generation> <system-generated representation>
GET	<character set source> <get descriptor statement> <get diagnostics statement> <reserved word>
GetConnectAttr	<CLI generic name>
GetCursorName	<CLI generic name>
GetData	<CLI generic name>
GetDescField	<CLI generic name>
GetDescRec	<CLI generic name>
GetDiagField	<CLI generic name>
GetDiagRec	<CLI generic name>
GetEnvAttr	<CLI generic name>
GetFeatureInfo	<CLI generic name>
GetFunctions	<CLI generic name>
GetInfo	<CLI generic name>
GetLength	<CLI generic name>
GetParamData	<CLI generic name>
GetPosition	<CLI generic name>
GetSessionInfo	<CLI generic name>
GetStmtAttr	<CLI generic name>
GetSubString	<CLI generic name>
GetTypeInfo	<CLI generic name>
GLOBAL	<global or local> <reserved word> <scope option>
GO	<go to> <reserved word>
GOTO	<go to> <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>
GROUPING	<grouping operation> <grouping sets specification> <reserved word>
gt	<Package PKG(i)> <packages> <Part (n)> <right arrow>
HANDLE	<reserved word>
HANDLER	<handler declaration>
HAVING	<having clause> <reserved word>
HIERARCHY	<grant privilege statement> <non-reserved word> <revoke option extension>
High	<high>
HOLD	<cursor holdability> <hold locator statement> <reserved word> <statement cursor>
HOUR	<non-second primary datetime field> <reserved word>
IDENTITY	<reserved word>
IF	<if statement> <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> <CLI parameter mode> <in predicate> <parameter mode> <reserved word> <string position expression>
INDICATOR	<descriptor item name> <indicator parameter> <indicator variable> <reserved word>
INDICATOR_TYPE	<Ada qualified type specification> <Ada unqualified type specification>
INITIALLY	<constraint check time> <reserved word>
INNER	<join type> <reserved word>
INOUT	<parameter mode> <reserved word>
INPUT	<describe input statement> <null-call clause> <reserved word>
INSENSITIVE	<cursor sensitivity> <non-reserved word>
INSERT	<action> <insert statement> <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	<CLI parameter data type> <exact numeric type> <Fortran type specification> <Pascal type specification> <reserved word>
IntegrityNo	<integrity no>
IntegrityYes	<integrity yes>
Interfaces	<Ada qualified type specification>
Intermediate	<intermediate>
INTERSECT	<non-join query term> <reserved word>
INTERVAL	<interval literal> <interval type> <reserved word>
INTO	<fetch statement> <insert statement> <into arguments> <into descriptor> <reserved word> <select statement: single row>
INVOKER	<external security clause> <non-reserved word>
IS	<Ada array locator variable> <Ada BLOB locator variable> <Ada BLOB variable> <Ada CLOB locator variable> <Ada CLOB 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 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 bit type> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB locator variable> <COBOL CLOB 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> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran BLOB variable> <Fortran CLOB locator variable> <Fortran CLOB 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 REF variable> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <null predicate> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal BLOB variable> <Pascal CLOB locator variable> <Pascal CLOB 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 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> <system-generated representation> <type predicate>
iso	<arc1>
ISOLATION	<isolation level> <reserved word>
ITERATE	<iterate statement>
JOIN	<cross join> <natural join> <qualified join> <reserved word> <union join>
KEY	<referential constraint definition> <reserved word> <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> <reserved word>
LATERAL	<lateral derived table> <reserved word>
LEADING	<COBOL numeric type> <reserved word> <trim specification>
LEAVE	<leave statement> <reserved word>
LEFT	<outer join type> <reserved word>
LENGTH	<descriptor item name> <non-reserved word>
LEVEL	<descriptor item name> <isolation level> <reserved word>
LIKE	<character like predicate> <like clause> <octet like predicate> <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 user-defined type locator variable> <C array locator variable> <C BLOB locator variable> <C CLOB locator variable> <C user-defined type locator variable> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL CLOB locator variable> <COBOL user-defined type locator variable> <Fortran array locator variable> <Fortran BLOB locator variable> <Fortran CLOB 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 user-defined type locator variable> <original method specification> <Pascal array locator variable> <Pascal BLOB locator variable> <Pascal CLOB 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 user-defined type locator variable> <reserved word>
LOGICAL	<Fortran type specification>
long	<C numeric variable>
LOOP	<loop statement> <reserved word>
Low	<low>
LOWER	<fold> <non-reserved word>
lt	<Package PKG(i)> <packages> <Part (n)>
MAP	<map category> <reserved word>
MATCH	<match predicate> <references specification> <reserved word>
MAX	<allocate descriptor statement> <computational operation> <non-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>
MOD	<modulus expression> <non-reserved word>
MODIFIES	<reserved word> <SQL-data access indication>
MODULE	<column reference> <drop module statement> <local or schema qualifier> <local qualifier> <module name clause> <object name> <reserved word> <SQL-server module definition>
moduleno	<Part 4 module no>
moduleyes	<Part 4 module yes>
MONTH	<non-second primary datetime field> <reserved word>
MORE	<non-reserved word> <statement information item name>
MoreResults	<CLI generic name>
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> <reserved word> <SQL-server module character set specification>
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> <reserved word>
NEW	<new specification> <old or new values alias> <reserved word>
NEXT	<fetch orientation> <reserved word>
NextResult	<CLI generic name>
NO	<commit statement> <cursor scrollability> <pad characteristic> <referential action> <reserved word> <rollback statement> <SQL-data access indication>
no	<Part (n)>
No	<Package PKG(i)> <Part (n) no>
NONE	<reserved word> <role specification>
NOT	<between predicate> <boolean factor> <boolean test> <character like predicate> <column constraint> <compound statement> <condition value> <constraint characteristics> <deterministic characteristic> <finality> <in predicate> <instantiable clause> <major category> <null predicate> <octet like predicate> <reference scope check> <reserved word> <similar predicate> <type predicate>
NULL	<column constraint> <null predicate> <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>
NUMBER	<non-reserved word> <statement information item name>
NUMERIC	<exact numeric type> <reserved word>
NumResultCols	<CLI generic name>
OBJECT	<binary large object string type> <character string type> <national character string type> <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> <Pascal type specification> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <referenceable view specification> <reserved word> <table contents source> <trigger event> <type predicate> <updatability clause> <update statement: positioned>
OLD	<old or new values alias> <reserved word>
ON	<delete rule> <join condition> <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> <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>
ORDERING	<drop user-defined ordering statement> <non-reserved word> <user-defined ordering definition>
ORDINALITY	<collection derived table> <reserved word>
OUT	<CLI parameter mode> <parameter mode> <reserved word>
OUTER	<join type> <reserved word>
OUTPUT	<describe output statement> <reserved word>
OVERLAPS	<overlaps predicate> <reserved word>
OVERLAY	<blob overlay function> <character overlay function> <non-reserved word>
OVERRIDING	<non-reserved word> <override clause> <overriding method specification>
Package	<Package PKG(i)> <packages>
PACKED	<Pascal type specification>
PAD	<pad characteristic> <reserved word>
ParamData	<CLI generic name>
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>
Part	<Part (n)>
Part-	<Part (n) no>
PARTIAL	<match predicate> <match type> <reserved word>
PASCAL	<language name> <non-reserved word>
PATH	<path specification> <reserved word> <SQL-path characteristic>
PIC	<COBOL binary integer> <COBOL bit type> <COBOL character type> <COBOL national character type> <COBOL numeric type>
PICTURE	<COBOL binary integer> <COBOL bit type> <COBOL character type> <COBOL national character type> <COBOL numeric type>
PKG	<Package PKG(i)> <packages>
PLACING	<blob overlay function> <character overlay function>
PLI	<language name> <non-reserved word>
POSITION	<blob position expression> <non-reserved word> <string position expression>
PRECISION	<approximate numeric type> <descriptor item name> <Fortran type specification> <reserved word>
PREPARE	<deallocate prepared statement> <prepare statement> <reserved word>
Prepare	<CLI generic name>
PRESERVE	<reserved word> <table commit action>
PRIMARY	<reserved word> <unique specification>
PrimaryKeys	<CLI generic name>
PRIOR	<fetch orientation> <reserved word>
PRIVILEGES	<object privileges> <reserved word>
PROCEDURE	<externally-invoked procedure> <reserved word> <result set cursor> <routine type> <SQL-invoked procedure>
PUBLIC	<grantee> <reserved word>
PutData	<CLI generic name>
READ	<level of isolation> <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>
REDO	<reserved word>
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>
RELATIVE	<fetch orientation> <relative category> <reserved word>
RELEASE	<release savepoint statement> <reserved word>
REPEAT	<repeat statement> <reserved word>
REPEATABLE	<level of isolation> <non-reserved word>
RESIGNAL	<reserved word> <resignal statement>
RESTRICT	<alter routine behaviour> <drop attribute definition> <drop behavior> <drop method specification> <referential action> <reserved word>
RESULT	<dynamic result sets characteristic> <original method specification> <reserved word> <SQL parameter declaration>
RETURN	<cursor returnability> <reserved word> <return statement> <statement cursor>
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	<CLI returns clause> <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> <reserved word> <role definition> <set role statement>
ROLLBACK	<reserved word> <rollback statement>
ROLLUP	<reserved word> <rollup list>
ROUTINE	<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> <old or new values alias> <reserved word> <row type> <row value constructor> <triggered action>
RowCount	<CLI generic name>
ROWS	<reserved word> <table definition> <temporary table declaration>
ROW_COUNT	<non-reserved word> <statement information item name>
Rules	<SQLSTATE class value> <SQLSTATE subclass value>
SAVEPOINT	<release savepoint statement> <reserved word> <savepoint clause> <savepoint statement>
SCALE	<descriptor item name> <non-reserved word>
SCHEMA	<drop schema statement> <embedded authorization clause> <module authorization clause> <reserved word> <schema definition> <schema name characteristic> <SQL-server module schema clause>
SCHEMA_NAME	<condition information item name> <non-reserved word>
SCOPE	<drop column scope clause> <non-reserved word> <scope clause>
SCOPE_CATALOG	<descriptor item name>
SCOPE_NAME	<descriptor item name>
SCOPE_SCHEMA	<descriptor item name>
SCROLL	<cursor scrollability> <reserved word> <statement cursor>
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> <reserved word>
SECURITY	<external security clause> <non-reserved word>
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> <non-reserved word>
SEPARATE	<COBOL numeric type>
SERIALIZABLE	<level of isolation> <non-reserved word>
SERVER_NAME	<condition information item name> <non-reserved word>
SESSION	<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> <assignment statement> <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> <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 role statement> <set schema statement> <set session characteristics statement> <set session user identifier statement> <set signal information> <set transaction statement> <set transform group statement> <update statement: positioned> <update statement: searched>
SetConnectAttr	<CLI generic name>
SetCursorName	<CLI generic name>
SetDescField	<CLI generic name>
SetDescRec	<CLI generic name>
SetEnvAttr	<CLI generic name>
SETS	<dynamic result sets characteristic> <grouping sets specification> <reserved word>
SetStmtAttr	<CLI generic name>
short	<C character type> <C numeric variable>
SIGN	<COBOL numeric type>
SIGNAL	<reserved word> <signal statement>
SIMILAR	<regular expression substring function> <reserved word> <similar predicate>
SIMPLE	<match predicate> <match type> <non-reserved word>
SIZE	<diagnostics size> <reserved word>
SMALLINT	<Ada qualified type specification> <Ada unqualified type specification> <CLI parameter data type> <CLI returns clause> <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	<pad characteristic> <reserved word>
SpecialColumns	<CLI generic name>
SPECIFIC	<partial method specification> <reserved word> <routine characteristic> <specific method specification designator> <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 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 NCLOB variable> <C REF variable> <C user-defined type locator variable> <C user-defined type variable> <CLI by-value prefix> <COBOL array locator variable> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL CLOB locator variable> <COBOL CLOB 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 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 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 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 REF variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <reserved word> <set descriptor statement> <SQL prefix> <SQL-data access indication> <to sql> <using descriptor>
sqlbindings1999	<Part 5 conformance>
sqlcli1999	<Part 3 conformance>
SQLEXCEPTION	<condition value> <major category> <reserved word>
sqlpsm1999	<Part 4 conformance>
SQLR	<CLI by-reference prefix>
SQLSTATE	<reserved word> <SQL condition> <sqlstate value> <status parameter>
SQLSTATE_TYPE	<Ada qualified type specification> <Ada unqualified type specification>
SQLWARNING	<condition value> <major category> <reserved word>
standard	<arc2>
START	<reserved word> <start transaction statement>
StartTran	<CLI generic name>
STATE	<reserved word> <state category>
STATEMENT	<non-reserved word> <triggered action>
static	<C storage class>
STATIC	<dispatch clause> <embedded authorization clause> <method specification designator> <module authorization clause> <partial method specification> <reserved word> <routine type> <specific method specification designator>
STRUCTURE	<described object> <non-reserved word>
STYLE	<non-reserved word> <parameter style clause>
SUBCLASS_ORIGIN	<condition information item name> <non-reserved word>
SUBSTRING	<bit substring function> <blob substring function> <character substring function> <non-reserved word> <regular expression substring function>
SUM	<computational operation> <non-reserved word>
SYMMETRIC	<between predicate> <non-reserved word>
Syntax	<SQLSTATE class value> <SQLSTATE subclass value>
SYSTEM	<non-reserved word> <override clause> <reference generation> <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> <table definition> <temporary table declaration>
TablePrivileges	<CLI generic name>
Tables	<CLI generic name>
TABLE_NAME	<condition information item name> <non-reserved word>
TEMPORARY	<reserved word> <table scope> <temporary table declaration>
the	<SQLSTATE class value> <SQLSTATE subclass value>
THEN	<if statement elseif clause> <if statement then clause> <reserved word> <searched case statement when clause> <searched when clause> <simple case statement when clause> <simple when clause>
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> <to sql> <translation definition>
TOP_LEVEL_COUNT	<header item name> <non-reserved word>
TRAILING	<reserved word> <trim specification>
TRANSACTION	<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	<drop transform statement> <non-reserved word> <transform definition> <transform group characteristic> <transform group specification>
TRANSFORMS	<drop transform statement> <non-reserved word> <transform definition>
TRANSLATE	<character translation> <non-reserved word>
TRANSLATION	<drop translation statement> <object name> <reserved word> <translation 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 REF variable> <Ada user-defined type locator variable> <Ada user-defined type variable> <alter type statement> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C CLOB locator variable> <C CLOB 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 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 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 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 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 REF variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <transform group characteristic> <user-defined type definition>
UNCOMMITTED	<level of isolation> <non-reserved word>
UNDER	<action> <reserved word> <subtable clause> <subtype clause> <subview clause>
UNDO	<handler type> <reserved word>
UNION	<non-join query expression> <reserved word> <union join>
UNIQUE	<match predicate> <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>
UNTIL	<repeat statement> <reserved word>
UPDATE	<action> <dynamic update statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <trigger event> <updatability clause> <update rule> <update statement: positioned> <update statement: searched>
UPPER	<fold> <non-reserved word>
USAGE	<action> <COBOL array locator variable> <COBOL binary integer> <COBOL bit type> <COBOL BLOB locator variable> <COBOL BLOB variable> <COBOL CLOB locator variable> <COBOL CLOB variable> <COBOL NCLOB variable> <COBOL numeric type> <COBOL REF variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <reserved word>
USER	<connection target> <default option> <general value specification> <override clause> <reference generation> <reserved word>
USER_DEFINED_TYPE_CATALOG	<descriptor item name>
USER_DEFINED_TYPE_NAME	<descriptor item name>
USER_DEFINED_TYPE_SCHEMA	<descriptor item name>
USING	<character translation> <cycle clause> <form-of-use conversion> <named columns join> <reserved word> <user-defined representation> <using arguments> <using descriptor>
VALUE	<general value specification> <get descriptor information> <override clause> <reserved word> <set descriptor information> <sqlstate value> <unique constraint definition>
VALUES	<contextually typed table value constructor> <from default> <reserved word> <table value constructor>
VARCHAR	<C VARCHAR variable> <character string type> <MUMPS character variable> <reserved word>
VARYING	<bit string type> <C NCHAR VARYING variable> <character string type> <national character string type> <PL/I type specification> <reserved word>
VIEW	<drop view statement> <reserved word> <view definition>
volatile	<C class modifier>
WHEN	<reserved word> <searched case statement when clause> <searched when clause> <simple case statement 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> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <update statement: positioned> <update statement: searched> <where clause>
WHILE	<reserved word> <while statement>
WITH	<allocate descriptor statement> <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> <statement cursor> <to sql> <user-defined cast definition> <view column option> <view definition> <with clause> <with or without time zone>
WITHOUT	<cursor holdability> <cursor returnability> <nesting option> <reserved word> <with or without time zone>
WORK	<commit statement> <reserved word> <rollback statement>
WRITE	<reserved word> <transaction access mode>
YEAR	<non-second primary datetime field> <reserved word>
yes	<Part (n)>
Yes	<Package PKG(i)>
ZONE	<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 .