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.8 dated 2004/07/26 18:00:06
Generated on 2011-07-11 19:57:42+00:00 by file bnf2html.pl version 3.11 dated 2011/07/11 19:57:38

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.

    <SQL object identifier>    ::=   <SQL provenance> <SQL variant>

    <SQL provenance>    ::=   <arc1> <arc2> <arc3>

    <arc1>    ::=   iso | 1 | iso <left paren> 1 <right paren>

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

    <arc3>    ::=  9075

    <SQL variant>    ::=   <SQL edition> <SQL conformance>

    <SQL edition>    ::=   <1987> | <1989> | <1992> | <1999>

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

    <SQL conformance>    ::=   <level> <parts> <packages>

    <level>    ::=   <low> | <intermediate> | <high>

    <low>    ::=   0 | Low <left paren> 0 <right paren>

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

    <high>    ::=   2 | High <left paren> 2 <right paren>

    <parts>    ::=   <Part 3> <Part 4> <Part 5> <Part 6> <Part 7> <Part 8> <Part 9> <Part 10>

    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)>    ::=   <Part (n) no > | <Part (n) yes >

    <Part (n) no>    ::=   0 | Part -(n)No <left paren> 0 <right paren>

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

    <Package PKG(i)>    ::=   <Package PKG (i)Yes> | <Package PKG (i)No>

    <Part 3 yes>    ::=   <Part 3 conformance>

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

    <Part 4 yes>    ::=   <Part 4 conformance> <Part 4 module>

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

    <Part 4 module>    ::=   <Part 4 module yes> | <Part 4 module no>

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

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

    <Part 5 yes>    ::=   <Part 5 conformance> <Part 5 direct> <Part 5 embedded>

    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>    ::=   <Part 5 direct yes> | <Part 5 direct no>

    <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 languages>    ::=
             <Part 5 embedded Ada>
         |     <Part 5 embedded C>
         |     <Part 5 embedded COBOL>
         |     <Part 5 embedded Fortran>
         |     <Part 5 embedded MUMPS>
         |     <Part 5 embedded Pascal>
         |     <Part 5 embedded PL/I>

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

    <SQL terminal character>    ::=   <SQL language character>

    <SQL language character>    ::=   <simple Latin letter> | <digit> | <SQL special character>

    <simple Latin letter>    ::=
             <simple Latin upper case letter>
         |     <simple Latin lower case letter>

    <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

    <SQL special character>    ::=
             <space>
         |     <double quote>
         |     <percent>
         |     <ampersand>
         |     <quote>
         |     <left paren>
         |     <right paren>
         |     <asterisk>
         |     <plus sign>
         |     <comma>
         |     <minus sign>
         |     <period>
         |     <solidus>
         |     <colon>
         |     <semicolon>
         |     <less than operator>
         |     <equals operator>
         |     <greater than operator>
         |     <question mark>
         |     <left bracket>
         |     <right bracket>
         |     <circumflex>
         |     <underscore>
         |     <vertical bar>
         |     <left brace>
         |     <right brace>

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

    <greater than operator>    ::=   >

    <question mark>    ::=   ?

    <left bracket>    ::=   [

    <right bracket>    ::=   ]

    <circumflex>    ::=   ^

    <underscore>    ::=   _

    <vertical bar>    ::=  /* Nothing */ |

    <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>    ::=   <actual identifier>

    <actual identifier>    ::=   <regular identifier> | <delimited identifier>

    <regular identifier>    ::=   <identifier body>

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

    <identifier start>    ::=   <initial alphabetic character> | <ideographic character>

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

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

    <identifier part>    ::=
             <alphabetic character>
         |     <ideographic character>
         |     <decimal digit character>
         |     <identifier combining character>
         |     <underscore>
         |     <alternate underscore>
         |     <extender character>
         |     <identifier ignorable character>
         |     <connector character>

    <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>    ::=   <double quote> <delimited identifier body> <double quote>

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

    <delimited identifier part>    ::=   <nondoublequote character> | <doublequote symbol>

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

    <doublequote symbol>    ::=   <double quote> <double quote>

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

    <character set specification>    ::=
             <standard character set name>
         |     <implementation-defined character set name>
         |     <user-defined character set name>

    <standard character set name>    ::=   <character set name>

    <character set name>    ::=   [ <schema name> <period> ] <SQL language identifier>

    <schema name>    ::=   [ <catalog name> <period> ] <unqualified schema name>

    <catalog name>    ::=   <identifier>

    <unqualified schema name>    ::=   <identifier>

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

    <SQL language identifier start>    ::=   <simple Latin letter>

    <SQL language identifier part>    ::=   <simple Latin letter> | <digit>

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

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

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

    <language name>    ::=   ADA | C | COBOL | FORTRAN | MUMPS | PASCAL | PLI | SQL

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

    <module authorization identifier>    ::=   <authorization identifier>

    <authorization identifier>    ::=   <role name> | <user identifier>

    <role name>    ::=   <identifier>

    <user identifier>    ::=   <identifier>

    <module path specification>    ::=   <path specification>

    <path specification>    ::=   PATH <schema name list>

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

    <module transform group specification>    ::=   <transform group specification>

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

    <single group specification>    ::=   <group name>

    <group name>    ::=   <identifier>

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

    <group specification>    ::=   <group name> FOR TYPE <user-defined type>

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

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

    <schema qualified type name>    ::=   [ <schema name> <period> ] <qualified identifier>

    <qualified identifier>    ::=   <identifier>

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

    <table name>    ::=   <local or schema qualified name>

    <local or schema qualified name>    ::=   [ <local or schema qualifier> <period> ] <qualified identifier>

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

    <table element list>    ::=
             <left paren> <table element> [ { <comma> <table element> }... ] <right paren>

    <table element>    ::=
             <column definition>
         |     <table constraint definition>
         |     <like clause>
         |     <self-referencing column specification>
         |     <column options>

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

    <column name>    ::=   <identifier>

    Top


    Data Types

    <data type>    ::=
             <predefined type>
         |     <row type>
         |     <user-defined type>
         |     <reference type>
         |     <collection type>

    <predefined type>    ::=
             <character string type> [ CHARACTER SET <character set specification> ]
         |     <national character string type>
         |     <binary large object string type>
         |     <bit string type>
         |     <numeric type>
         |     <boolean type>
         |     <datetime type>
         |     <interval type>

    <character string type>    ::=
             CHARACTER [ <left paren> <length> <right paren> ]
         |     CHAR [ <left paren> <length> <right paren> ]
         |     CHARACTER VARYING <left paren> <length> <right paren>
         |     CHAR VARYING <left paren> <length> <right paren>
         |     VARCHAR <left paren> <length> <right paren>
         |     CHARACTER LARGE OBJECT [ <left paren> <large object length> <right paren> ]
         |     CHAR LARGE OBJECT [ <left paren> <large object length> <right paren> ]
         |     CLOB [ <left paren> <large object length> <right paren> ]

    <length>    ::=   <unsigned integer>

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

    <large object length>    ::=   <unsigned integer> [ <multiplier> ] | <large object length token>

    <multiplier>    ::=   K | M | G

    <large object length token>    ::=   <digit> ... <multiplier>

    <national character string type>    ::=
             NATIONAL CHARACTER [ <left paren> <length> <right paren> ]
         |     NATIONAL CHAR [ <left paren> <length> <right paren> ]
         |     NCHAR [ <left paren> <length> <right paren> ]
         |     NATIONAL CHARACTER VARYING <left paren> <length> <right paren>
         |     NATIONAL CHAR VARYING <left paren> <length> <right paren>
         |     NCHAR VARYING <left paren> <length> <right paren>
         |     NATIONAL CHARACTER LARGE OBJECT [ <left paren> <large object length> <right paren> ]
         |     NCHAR LARGE OBJECT [ <left paren> <large object length> <right paren> ]
         |     NCLOB [ <left paren> <large object length> <right paren> ]

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

    <numeric type>    ::=   <exact numeric type> | <approximate numeric type>

    <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

    <precision>    ::=   <unsigned integer>

    <scale>    ::=   <unsigned integer>

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

    <time precision>    ::=   <time fractional seconds precision>

    <time fractional seconds precision>    ::=   <unsigned integer>

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

    <timestamp precision>    ::=   <time fractional seconds precision>

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

    <interval qualifier>    ::=   <start field> TO <end field> | <single datetime field>

    <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

    <interval leading field precision>    ::=   <unsigned integer>

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

    <interval fractional seconds precision>    ::=   <unsigned integer>

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

    <row type>    ::=   ROW <row type body>

    <row type body>    ::=   <left paren> <field definition> [ { <comma> <field definition> }... ] <right paren>

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

    <field name>    ::=   <identifier>

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

    <reference scope check action>    ::=   <referential action>

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

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

    <collation name>    ::=   <schema qualified name>

    <schema qualified name>    ::=   [ <schema name> <period> ] <qualified identifier>

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

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

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

    <collection type>    ::=   <data type> <array specification>

    <array specification>    ::=
             <collection type constructor> <left bracket or trigraph> <unsigned integer> <right bracket or trigraph>

    <collection type constructor>    ::=   ARRAY

    <left bracket or trigraph>    ::=   <left bracket> | <left bracket trigraph>

    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.

    <left bracket trigraph>    ::=   <question mark> <question mark> <left paren>

    <right bracket or trigraph>    ::=   <right bracket> | <right bracket trigraph>

    <right bracket trigraph>    ::=   <question mark> <question mark> <right paren>

    <domain name>    ::=   <schema qualified name>

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

    <default option>    ::=
             <literal>
         |     <datetime value function>
         |     USER
         |     CURRENT_USER
         |     CURRENT_ROLE
         |     SESSION_USER
         |     SYSTEM_USER
         |     CURRENT_PATH
         |     <implicitly typed value specification>

    Top


    Literals

    <literal>    ::=   <signed numeric literal> | <general literal>

    <signed numeric literal>    ::=   [ <sign> ] <unsigned numeric literal>

    <sign>    ::=   <plus sign> | <minus sign>

    <unsigned numeric literal>    ::=   <exact numeric literal> | <approximate numeric literal>

    <exact numeric literal>    ::=
             <unsigned integer> [ <period> [ <unsigned integer> ] ]
         |     <period> <unsigned integer>

    <approximate numeric literal>    ::=   <mantissa> E <exponent>

    <mantissa>    ::=   <exact numeric literal>

    <exponent>    ::=   <signed integer>

    <signed integer>    ::=   [ <sign> ] <unsigned integer>

    <general literal>    ::=
             <character string literal>
         |     <national character string literal>
         |     <bit string literal>
         |     <hex string literal>
         |     <binary string literal>
         |     <datetime literal>
         |     <interval literal>
         |     <boolean literal>

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

    <introducer>    ::=   <underscore>

    <character representation>    ::=   <nonquote character> | <quote symbol>

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

    <quote symbol>    ::=   <quote> <quote>

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

    <comment>    ::=   <simple comment> | <bracketed comment>

    <simple comment>    ::=   <simple comment introducer> [ <comment character> ... ] <newline>

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

    <comment character>    ::=   <nonquote character> | <quote>

    <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>    ::=
             <bracketed comment introducer> <bracketed comment contents> <bracketed comment terminator>

    <bracketed comment introducer>    ::=   <slash> <asterisk>

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

    <bracketed comment terminator>    ::=   <asterisk> <slash>

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

    <datetime literal>    ::=   <date literal> | <time literal> | <timestamp literal>

    <date literal>    ::=   DATE <date string>

    <date string>    ::=   <quote> <unquoted date string> <quote>

    <unquoted date string>    ::=   <date value>

    <date value>    ::=   <years value> <minus sign> <months value> <minus sign> <days value>

    <years value>    ::=   <datetime value>

    <datetime value>    ::=   <unsigned integer>

    <months value>    ::=   <datetime value>

    <days value>    ::=   <datetime value>

    <time literal>    ::=   TIME <time string>

    <time string>    ::=   <quote> <unquoted time string> <quote>

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

    <time value>    ::=   <hours value> <colon> <minutes value> <colon> <seconds value>

    <hours value>    ::=   <datetime value>

    <minutes value>    ::=   <datetime value>

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

    <seconds integer value>    ::=   <unsigned integer>

    <seconds fraction>    ::=   <unsigned integer>

    <time zone interval>    ::=   <sign> <hours value> <colon> <minutes value>

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

    <timestamp string>    ::=   <quote> <unquoted timestamp string> <quote>

    <unquoted timestamp string>    ::=   <unquoted date string> <space> <unquoted time string>

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

    <interval string>    ::=   <quote> <unquoted interval string> <quote>

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

    <time interval>    ::=
             <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]
         |     <minutes value> [ <colon> <seconds value> ]
         |     <seconds value>

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

    <datetime value function>    ::=
             <current date value function>
         |     <current time value function>
         |     <current timestamp value function>
         |     <current local time value function>
         |     <current local timestamp value function>

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

    <implicitly typed value specification>    ::=   <null specification> | <empty specification>

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

    <constraint name>    ::=   <schema qualified name>

    <column constraint>    ::=
             NOT NULL
         |     <unique specification>
         |     <references specification>
         |     <check constraint definition>

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

    <reference column list>    ::=   <column name list>

    <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

    <search condition>    ::=   <boolean value expression>

    <boolean value expression>    ::=
             <boolean term>
         |     <boolean value expression> OR <boolean term>

    <boolean term>    ::=
             <boolean factor>
         |     <boolean term> AND <boolean factor>

    <boolean factor>    ::=   [ NOT ] <boolean test>

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

    <boolean primary>    ::=
             <predicate>
         |     <parenthesized boolean value expression>
         |     <nonparenthesized value expression primary>

    <predicate>    ::=
             <comparison predicate>
         |     <between predicate>
         |     <in predicate>
         |     <like predicate>
         |     <null predicate>
         |     <quantified comparison predicate>
         |     <exists predicate>
         |     <unique predicate>
         |     <match predicate>
         |     <overlaps predicate>
         |     <similar predicate>
         |     <distinct predicate>
         |     <type predicate>

    <comparison predicate>    ::=   <row value expression> <comp op> <row value expression>

    <row value expression>    ::=   <row value special case> | <row value constructor>

    <row value special case>    ::=   <value specification> | <value expression>

    <value specification>    ::=   <literal> | <general value specification>

    <general value specification>    ::=
             <host parameter specification>
         |     <SQL parameter reference>
         |     <SQL variable reference>
         |     <dynamic parameter specification>
         |     <embedded variable specification>
         |     CURRENT_DEFAULT_TRANSFORM_GROUP
         |     CURRENT_PATH
         |     CURRENT_ROLE
         |     CURRENT_TRANSFORM_GROUP_FOR_TYPE <user-defined type>
         |     CURRENT_USER
         |     SESSION_USER
         |     SYSTEM_USER
         |     USER
         |     VALUE

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

    <host parameter name>    ::=   <colon> <identifier>

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

    <SQL parameter reference>    ::=   <basic identifier chain>

    <basic identifier chain>    ::=   <identifier chain>

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

    <value expression>    ::=
             <numeric value expression>
         |     <string value expression>
         |     <datetime value expression>
         |     <interval value expression>
         |     <boolean value expression>
         |     <user-defined type value expression>
         |     <row value expression>
         |     <reference value expression>
         |     <collection value expression>

    <numeric value expression>    ::=
             <term>
         |     <numeric value expression> <plus sign> <term>
         |     <numeric value expression> <minus sign> <term>

    <term>    ::=
             <factor>
         |     <term> <asterisk> <factor>
         |     <term> <solidus> <factor>

    <factor>    ::=   [ <sign> ] <numeric primary>

    <numeric primary>    ::=
             <value expression primary>
         |     <numeric value function>

    <value expression primary>    ::=
             <parenthesized value expression>
         |     <nonparenthesized value expression primary>

    <parenthesized value expression>    ::=   <left paren> <value expression> <right paren>

    <nonparenthesized value expression primary>    ::=
             <unsigned value specification>
         |     <column reference>
         |     <set function specification>
         |     <scalar subquery>
         |     <case expression>
         |     <cast specification>
         |     <subtype treatment>
         |     <attribute or method reference>
         |     <reference resolution>
         |     <collection value constructor>
         |     <routine invocation>
         |     <field reference>
         |     <element reference>
         |     <method invocation>
         |     <static method invocation>
         |     <new specification>

    <unsigned value specification>    ::=   <unsigned literal> | <general value specification>

    <unsigned literal>    ::=   <unsigned numeric literal> | <general literal>

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

    <general set function>    ::=
             <set function type> <left paren> [ <set quantifier> ] <value expression> <right paren>

    <set function type>    ::=   <computational 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

    <scalar subquery>    ::=   <subquery>

    <subquery>    ::=   <left paren> <query expression> <right paren>

    <query expression>    ::=   [ <with clause> ] <query expression body>

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

    <query name>    ::=   <identifier>

    <with column list>    ::=   <column name list>

    <search or cycle clause>    ::=
             <search clause>
         |     <cycle clause>
         |     <search clause> <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> ]

    <sort key>    ::=   <value expression>

    <ordering specification>    ::=   ASC | DESC

    <sequence column>    ::=   <column name>

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

    <cycle column>    ::=   <column name>

    <cycle mark column>    ::=   <column name>

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

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

    <path column>    ::=   <column name>

    <query expression body>    ::=   <non-join query expression> | <joined table>

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

    <simple table>    ::=   <query specification> | <table value constructor> | <explicit table>

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

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

    <select sublist>    ::=   <derived column> | <qualified asterisk>

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

    <as clause>    ::=   [ AS ] <column name>

    <qualified asterisk>    ::=
             <asterisked identifier chain> <period> <asterisk>
         |     <all fields reference>

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

    <asterisked identifier>    ::=   <identifier>

    <all fields reference>    ::=   <value expression primary> <period> <asterisk>

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

    <from clause>    ::=   FROM <table reference list>

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

    <table reference>    ::=   <table primary> | <joined table>

    <table primary>    ::=
             <table or query name> [ [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ] ]
         |     <derived table> [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ]
         |     <lateral derived table> [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ]
         |     <collection derived table> [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ]
         |     <only spec> [ [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ] ]
         |     <left paren> <joined table> <right paren>

    <table or query name>    ::=   <table name> | <query name>

    <correlation name>    ::=   <identifier>

    <derived column list>    ::=   <column name list>

    <derived table>    ::=   <table subquery>

    <table subquery>    ::=   <subquery>

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

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

    <collection value expression>    ::=   <value expression primary>

    <only spec>    ::=   ONLY <left paren> <table or query name> <right paren>

    <joined table>    ::=   <cross join> | <qualified join> | <natural join> | <union join>

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

    <qualified join>    ::=   <table reference> [ <join type> ] JOIN <table reference> <join specification>

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

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

    <join specification>    ::=   <join condition> | <named columns join>

    <join condition>    ::=   ON <search condition>

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

    <join column list>    ::=   <column name list>

    <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 element>    ::=
             <ordinary grouping set>
         |     <rollup list>
         |     <cube list>
         |     <grouping sets specification>
         |     <grand total>

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

    <cube list>    ::=   CUBE <left paren> <grouping column reference list> <right paren>

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

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

    <grouping set>    ::=
             <ordinary grouping set>
         |     <rollup list>
         |     <cube list>
         |     <grouping sets specification>
         |     <grand total>

    <ordinary grouping set>    ::=
             <grouping column reference>
         |     <left paren> <grouping column reference list> <right paren>

    <grand total>    ::=   <left paren> <right paren>

    <concatenated grouping>    ::=   <grouping set> <comma> <grouping set list>

    <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

    <query term>    ::=   <non-join query term> | <joined table>

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

    <corresponding column list>    ::=   <column name list>

    <query primary>    ::=   <non-join query primary> | <joined table>

    <case expression>    ::=   <case abbreviation> | <case specification>

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

    <case specification>    ::=   <simple case> | <searched case>

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

    <case operand>    ::=   <value expression>

    <simple when clause>    ::=   WHEN <when operand> THEN <result>

    <when operand>    ::=   <value expression>

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

    <result expression>    ::=   <value expression>

    <else clause>    ::=   ELSE <result>

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

    <searched when clause>    ::=   WHEN <search condition> THEN <result>

    <cast specification>    ::=   CAST <left paren> <cast operand> AS <cast target> <right paren>

    <cast operand>    ::=   <value expression> | <implicitly typed value specification>

    <cast target>    ::=   <domain name> | <data type>

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

    <subtype operand>    ::=   <value expression>

    <target subtype>    ::=   <user-defined type>

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

    <dereference operator>    ::=   <right arrow>

    <right arrow>    ::=   ->

    <SQL argument list>    ::=
             <left paren> [ <SQL argument> [ { <comma> <SQL argument> }... ] ] <right paren>

    <SQL argument>    ::=   <value expression> | <generalized expression> | <target specification>

    <generalized expression>    ::=   <value expression> AS <user-defined type>

    <target specification>    ::=
             <host parameter specification>
         |     <SQL parameter reference>
         |     <column reference>
         |     <SQL variable reference>
         |     <dynamic parameter specification>
         |     <embedded variable specification>

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

    <reference value expression>    ::=   <value expression primary>

    <collection value constructor>    ::=   <array value expression>

    <array value expression>    ::=   <array value constructor> | <array concatenation> | <value expression primary>

    <array value constructor>    ::=   <array value list constructor>

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

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

    <array element>    ::=   <value expression>

    <array concatenation>    ::=
             <array value expression 1> <concatenation operator> <array value expression 2>

    <array value expression 1>    ::=   <array value expression>

    <concatenation operator>    ::=   ||

    <array value expression 2>    ::=   <array value expression>

    <routine invocation>    ::=   <routine name> <SQL argument list>

    <routine name>    ::=   [ <schema name> <period> ] <qualified identifier>

    <field reference>    ::=   <value expression primary> <period> <field name>

    <element reference>    ::=
             <array value expression> <left bracket or trigraph> <numeric value expression> <right bracket or trigraph>

    <method invocation>    ::=   <direct invocation> | <generalized invocation>

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

    <method name>    ::=   <identifier>

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

    <constructor method selection>    ::=   <routine invocation>

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

    <double colon>    ::=   <colon> <colon>

    <new specification>    ::=   NEW <routine invocation>

    <numeric value function>    ::=
             <position expression>
         |     <extract expression>
         |     <length expression>
         |     <cardinality expression>
         |     <absolute value expression>
         |     <modulus expression>

    <position expression>    ::=   <string position expression> | <blob position expression>

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

    <string value expression>    ::=   <character value expression> | <bit value expression> | <blob value expression>

    <character value expression>    ::=   <concatenation> | <character factor>

    <concatenation>    ::=   <character value expression> <concatenation operator> <character factor>

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

    <character primary>    ::=   <value expression primary> | <string value function>

    <string value function>    ::=   <character value function> | <blob value function> | <bit value function>

    <character value function>    ::=
             <character substring function>
         |     <regular expression substring function>
         |     <fold>
         |     <form-of-use conversion>
         |     <character translation>
         |     <trim function>
         |     <character overlay function>
         |     <specific type method>

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

    <start position>    ::=   <numeric value expression>

    <string length>    ::=   <numeric value expression>

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

    <escape character>    ::=   <character value expression>

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

    <translation name>    ::=   <schema qualified name>

    <trim function>    ::=   TRIM <left paren> <trim operands> <right paren>

    <trim operands>    ::=   [ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>

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

    <trim character>    ::=   <character value expression>

    <trim source>    ::=   <character value expression>

    <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 value function>    ::=   <blob substring function> | <blob trim function> | <blob overlay function>

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

    <blob value expression>    ::=   <blob concatenation> | <blob factor>

    <blob concatenation>    ::=   <blob value expression> <concatenation operator> <blob factor>

    <blob factor>    ::=   <blob primary>

    <blob primary>    ::=   <value expression primary> | <string value function>

    <blob trim function>    ::=   TRIM <left paren> <blob trim operands> <right paren>

    <blob trim operands>    ::=   [ [ <trim specification> ] [ <trim octet> ] FROM ] <blob trim source>

    <trim octet>    ::=   <blob value expression>

    <blob trim source>    ::=   <blob value expression>

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

    <bit value function>    ::=   <bit substring function>

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

    <bit value expression>    ::=   <bit concatenation> | <bit factor>

    <bit concatenation>    ::=   <bit value expression> <concatenation operator> <bit factor>

    <bit factor>    ::=   <bit primary>

    <bit primary>    ::=   <value expression primary> | <string value function>

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

    <extract field>    ::=   <primary datetime field> | <time zone field>

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

    <time zone field>    ::=   TIMEZONE_HOUR | TIMEZONE_MINUTE

    <extract source>    ::=   <datetime value expression> | <interval value expression>

    <datetime value expression>    ::=
             <datetime term>
         |     <interval value expression> <plus sign> <datetime term>
         |     <datetime value expression> <plus sign> <interval term>
         |     <datetime value expression> <minus sign> <interval term>

    <interval term>    ::=
             <interval factor>
         |     <interval term 2> <asterisk> <factor>
         |     <interval term 2> <solidus> <factor>
         |     <term> <asterisk> <interval factor>

    <interval factor>    ::=   [ <sign> ] <interval primary>

    <interval primary>    ::=   <value expression primary> | <interval value function>

    <interval value function>    ::=   <interval absolute value function>

    <interval absolute value function>    ::=   ABS <left paren> <interval value expression> <right paren>

    <interval value expression>    ::=
             <interval term>
         |     <interval value expression 1> <plus sign> <interval term 1>
         |     <interval value expression 1> <minus sign> <interval term 1>
         |     <left paren> <datetime value expression> <minus sign>
             <datetime term> <right paren> <interval qualifier>

    <interval value expression 1>    ::=   <interval value expression>

    <interval term 1>    ::=   <interval term>

    <datetime term>    ::=   <datetime factor>

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

    <datetime primary>    ::=   <value expression primary> | <datetime value function>

    <time zone>    ::=   AT <time zone specifier>

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

    <interval term 2>    ::=   <interval term>

    <length expression>    ::=   <char length expression> | <octet length expression> | <bit length expression>

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

    <absolute value expression>    ::=
             ABS <left paren> <numeric value expression> <right paren>

    <modulus expression>    ::=
             MOD <left paren> <numeric value expression dividend> <comma> <numeric value expression divisor> <right paren>

    <numeric value expression dividend>    ::=   <numeric value expression>

    <numeric value expression divisor>    ::=   <numeric value expression>

    <row value constructor>    ::=
             <row value constructor element>
         |     [ ROW ] <left paren> <row value constructor element list> <right paren>
         |     <row subquery>

    <row value constructor element>    ::=   <value expression>

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

    <row subquery>    ::=   <subquery>

    <comp op>    ::=
             <equals operator>
         |     <not equals operator>
         |     <less than operator>
         |     <greater than operator>
         |     <less than or equals operator>
         |     <greater than or equals operator>

    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.

    <not equals operator>    ::=   <less than operator> <greater than operator>

    <less than or equals operator>    ::=   <less than operator> <equals operator>

    <greater than or equals operator>    ::=   <greater than operator> <equals operator>

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

    <in predicate>    ::=   <row value expression> [ NOT ] IN <in predicate value>

    <in predicate value>    ::=   <table subquery> | <left paren> <in value list> <right paren>

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

    <like predicate>    ::=   <character like predicate> | <octet like predicate>

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

    <character match value>    ::=   <character value expression>

    <character pattern>    ::=   <character value expression>

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

    <octet match value>    ::=   <blob value expression>

    <octet pattern>    ::=   <blob value expression>

    <escape octet>    ::=   <blob value expression>

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

    <quantified comparison predicate>    ::=   <row value expression> <comp op> <quantifier> <table subquery>

    <quantifier>    ::=   <all> | <some>

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

    <row value expression 1>    ::=   <row value expression>

    <row value expression 2>    ::=   <row value expression>

    <similar predicate>    ::=
             <character match value> [ NOT ] SIMILAR TO <similar pattern> [ ESCAPE <escape character> ]

    <similar pattern>    ::=   <character value expression>

    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.

    <regular expression>    ::=
             <regular term>
         |     <regular expression> <vertical bar> <regular term>

    <regular term>    ::=
             <regular factor>
         |     <regular term> <regular factor>

    <regular factor>    ::=
             <regular primary>
         |     <regular primary> <asterisk>
         |     <regular primary> <plus sign>

    <regular primary>    ::=
             <character specifier>
         |     <percent>
         |     <regular character set>
         |     <left paren> <regular expression> <right paren>

    <character specifier>    ::=   <non-escaped character> | <escaped character>

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

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

    <regular character set>    ::=
             <underscore>
         |     <left bracket> <character enumeration> ... <right bracket>
         |     <left bracket> <circumflex> <character enumeration> ... <right bracket>
         |     <left bracket> <colon> <regular character set identifier> <colon> <right bracket>

    <character enumeration>    ::=
             <character specifier>
         |     <character specifier> <minus sign> <character specifier>

    <regular character set identifier>    ::=   <identifier>

    Top


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

    <row value expression 3>    ::=   <row value expression>

    <row value expression 4>    ::=   <row value expression>

    <type predicate>    ::=
             <user-defined type value expression> IS [ NOT ] OF <left paren> <type list> <right paren>

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

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

    <exclusive user-defined type specification>    ::=   ONLY <user-defined type>

    <parenthesized boolean value expression>    ::=   <left paren> <boolean value expression> <right paren>

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

    <table constraint>    ::=   <unique constraint definition> | <referential constraint definition> | <check constraint definition>

    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>

    <unique column list>    ::=   <column name list>

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

    <referencing columns>    ::=   <reference column list>

    <like clause>    ::=   LIKE <table name>

    <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

    <module contents>    ::=
             <declare cursor>
         |     <externally-invoked procedure>
         |     <dynamic declare cursor>

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

    <cursor name>    ::=   <local qualified name>

    <local qualified name>    ::=   [ <local qualifier> <period> ] <qualified identifier>

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

    <procedure name>    ::=   <identifier>

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

    <host parameter declaration setup>    ::=   <host parameter declaration list>

    <host parameter declaration list>    ::=
             <left paren> <host parameter declaration>
             [ { <comma> <host parameter declaration> }... ] <right paren>

    <host parameter declaration>    ::=
             <host parameter name> <host parameter data type>
         |     <status parameter>

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

    <locator indication>    ::=   AS LOCATOR

    <status parameter>    ::=   SQLSTATE

    <SQL procedure statement>    ::=   <SQL executable statement>

    <SQL executable statement>    ::=
             <SQL schema statement>
         |     <SQL data statement>
         |     <SQL control statement>
         |     <SQL transaction statement>
         |     <SQL connection statement>
         |     <SQL session statement>
         |     <SQL diagnostics statement>
         |     <SQL dynamic statement>

    Top


    SQL Schema Definition Statements

    <SQL schema statement>    ::=
             <SQL schema definition statement>
         |     <SQL schema manipulation statement>

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

    <SQL schema definition statement>    ::=
             <schema definition>
         |     <table definition>
         |     <view definition>
         |     <SQL-invoked routine>
         |     <grant statement>
         |     <role definition>
         |     <domain definition>
         |     <character set definition>
         |     <collation definition>
         |     <translation definition>
         |     <assertion definition>
         |     <trigger definition>
         |     <user-defined type definition>
         |     <user-defined cast definition>
         |     <user-defined ordering definition>
         |     <transform definition>
         |     <SQL-server module definition>

    <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 authorization identifier>    ::=   <authorization identifier>

    <schema character set or path>    ::=
             <schema character set specification>
         |     <schema path specification>
         |     <schema character set specification> <schema path specification>
         |     <schema path specification> <schema character set specification>

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

    <schema path specification>    ::=   <path specification>

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

    <schema element>    ::=
             <table definition>
         |     <view definition>
         |     <domain definition>
         |     <character set definition>
         |     <collation definition>
         |     <translation definition>
         |     <assertion definition>
         |     <trigger definition>
         |     <user-defined type definition>
         |     <schema routine>
         |     <grant statement>
         |     <role definition>
         |     <user-defined cast definition>
         |     <user-defined ordering definition>
         |     <transform definition>

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

    <supertable clause>    ::=   <supertable name>

    <supertable name>    ::=   <table name>

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

    <view specification>    ::=   <regular view specification> | <referenceable view specification>

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

    <view column list>    ::=   <column name list>

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

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

    <view element list>    ::=
             <left paren> [ <self-referencing column specification> <comma> ]
             <view element> [ { <comma> <view element> }... ] <right paren>

    <view element>    ::=   <view column option>

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

    <character set source>    ::=   GET <character set specification>

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

    <existing collation name>    ::=   <collation name>

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

    <source character set specification>    ::=   <character set specification>

    <target character set specification>    ::=   <character set specification>

    <translation source>    ::=   <existing translation name> | <translation routine>

    <existing translation name>    ::=   <translation name>

    <translation routine>    ::=   <specific routine designator>

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

    <routine type>    ::=
             ROUTINE | FUNCTION | PROCEDURE
         |     [ INSTANCE | STATIC | CONSTRUCTOR ] METHOD

    <specific name>    ::=   <schema qualified name>

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

    <schema qualified routine name>    ::=   <schema qualified name>

    <data type list>    ::=
             <left paren> [ <data type> [ { <comma> <data type> }... ] ] <right paren>

    <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 name>    ::=   <schema qualified name>

    <trigger action time>    ::=   BEFORE | AFTER

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

    <trigger column list>    ::=   <column name 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>

    <old values correlation name>    ::=   <correlation name>

    <new values correlation name>    ::=   <correlation name>

    <old values table alias>    ::=   <identifier>

    <new values table alias>    ::=   <identifier>

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

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

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

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

    <representation>    ::=   <predefined type> | <member list>

    <member list>    ::=   <left paren> <member> [ { <comma> <member> }... ] <right paren>

    <member>    ::=   <attribute definition>

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

    <attribute name>    ::=   <identifier>

    <attribute default>    ::=   <default clause>

    <instantiable clause>    ::=   INSTANTIABLE | NOT INSTANTIABLE

    <finality>    ::=   FINAL | NOT FINAL

    <reference type specification>    ::=   <user-defined representation> | <derived representation> | <system-generated representation>

    <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 ref identifier>    ::=   <identifier>

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

    <cast to type identifier>    ::=   <identifier>

    <derived representation>    ::=   REF FROM <list of attributes>

    <list of attributes>    ::=
             <left paren> <attribute name> [ { <comma> <attribute name> }...] <right paren>

    <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 distinct identifier>    ::=   <identifier>

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

    <cast to source identifier>    ::=   <identifier>

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

    <method specification>    ::=   <original method specification> | <overriding 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 list>    ::=
             <left paren> [ <SQL parameter declaration>
             [ { <comma> <SQL parameter declaration> }... ] ] <right paren>

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

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

    <SQL parameter name>    ::=   <identifier>

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

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

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

    <result cast>    ::=   CAST FROM <result cast from type>

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

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

    <specific method name>    ::=   [ <schema name> <period> ] <qualified identifier>

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

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

    <method characteristic>    ::=
             <language clause>
         |     <parameter style clause>
         |     <deterministic characteristic>
         |     <SQL-data access indication>
         |     <null-call clause>

    <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 routine>    ::=   <schema procedure> | <schema function>

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

    <routine characteristic>    ::=
             <language clause>
         |     <parameter style clause>
         |     SPECIFIC <specific name>
         |     <deterministic characteristic>
         |     <SQL-data access indication>
         |     <null-call clause>
         |     <dynamic result sets characteristic>

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

    <maximum dynamic result sets>    ::=   <unsigned integer>

    <routine body>    ::=   <SQL routine body> | <external body reference>

    <SQL routine body>    ::=   <SQL procedure statement>

    <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 routine name>    ::=   <identifier> | <character string literal>

    <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 statement>    ::=   <grant privilege statement> | <grant role statement>

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

    <privileges>    ::=   <object privileges> ON <object name>

    <object privileges>    ::=   ALL PRIVILEGES | <action> [ { <comma> <action> }... ]

    <action>    ::=
             SELECT
         |     SELECT <left paren> <privilege column list> <right paren>
         |     SELECT <left paren> <privilege method list> <right paren>
         |     DELETE
         |     INSERT [ <left paren> <privilege column list> <right paren> ]
         |     UPDATE [ <left paren> <privilege column list> <right paren> ]
         |     REFERENCES [ <left paren> <privilege column list> <right paren> ]
         |     USAGE
         |     TRIGGER
         |     UNDER
         |     EXECUTE

    <privilege column list>    ::=   <column name list>

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

    <object name>    ::=
             [ TABLE ] <table name>
         |     DOMAIN <domain name>
         |     COLLATION <collation name>
         |     CHARACTER SET <character set name>
         |     MODULE <module name>
         |     TRANSLATION <translation name>
         |     TYPE <user-defined type name>
         |     <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 granted>    ::=   <role name>

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

    <source data type>    ::=   <data type>

    <cast function>    ::=   <specific routine designator>

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

    <ordering form>    ::=   <equals ordering form> | <full ordering form>

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

    <ordering category>    ::=   <relative category> | <map category> | <state category>

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

    <relative function specification>    ::=   <specific routine designator>

    <map category>    ::=   MAP WITH <map function specification>

    <map function specification>    ::=   <specific routine designator>

    <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 group>    ::=   <group name> <left paren> <transform element list> <right paren>

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

    <transform element>    ::=   <to sql> | <from sql>

    <to sql>    ::=   TO SQL WITH <to sql function>

    <to sql function>    ::=   <specific routine designator>

    <from sql>    ::=   FROM SQL WITH <from sql function>

    <from sql function>    ::=   <specific routine designator>

    Top


    SQL Schema Manipulation Statements

    <SQL schema manipulation statement>    ::=
             <drop schema statement>
         |     <alter table statement>
         |     <drop table statement>
         |     <drop view statement>
         |     <alter routine statement>
         |     <drop routine statement>
         |     <drop user-defined cast statement>
         |     <revoke statement>
         |     <drop role statement>
         |     <alter domain statement>
         |     <drop domain statement>
         |     <drop character set statement>
         |     <drop collation statement>
         |     <drop translation statement>
         |     <drop assertion statement>
         |     <drop trigger statement>
         |     <alter type statement>
         |     <drop data type statement>
         |     <drop user-defined ordering statement>
         |     <drop transform statement>
         |     <drop module statement>

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

    <drop behavior>    ::=   CASCADE | RESTRICT

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

    <alter table action>    ::=
             <add column definition>
         |     <alter column definition>
         |     <drop column definition>
         |     <add table constraint definition>
         |     <drop table constraint definition>

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

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

    <alter column action>    ::=
             <set column default clause>
         |     <drop column default clause>
         |     <add column scope clause>
         |     <drop column scope clause>

    <set column default clause>    ::=   SET <default clause>

    <drop column default clause>    ::=   DROP DEFAULT

    <add column scope clause>    ::=   ADD <scope clause>

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

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

    <add table constraint definition>    ::=   ADD <table constraint definition>

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

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

    <drop view statement>    ::=   DROP VIEW <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 characteristic>    ::=
             <language clause>
         |     <parameter style clause>
         |     <SQL-data access indication>
         |     <null-call clause>
         |     <dynamic result sets characteristic>
         |     NAME <external routine name>

    <alter routine behaviour>    ::=   RESTRICT

    <drop routine statement>    ::=   DROP <specific routine designator> <drop behavior>

    <drop user-defined cast statement>    ::=
             DROP CAST <left paren> <source data type> AS <target data type> <right paren>
             <drop behavior>

    <revoke statement>    ::=   <revoke privilege statement> | <revoke role statement>

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

    <role revoked>    ::=   <role name>

    <drop role statement>    ::=   DROP ROLE <role name>

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

    <alter domain action>    ::=
             <set domain default clause>
         |     <drop domain default clause>
         |     <add domain constraint definition>
         |     <drop domain constraint definition>

    <set domain default clause>    ::=   SET <default clause>

    <drop domain default clause>    ::=   DROP DEFAULT

    <add domain constraint definition>    ::=   ADD <domain constraint>

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

    <alter type action>    ::=
             <add attribute definition>
         |     <drop attribute definition>
         |     <add original method specification>
         |     <add overriding method specification>
         |     <drop method specification>

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

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

    <add original method specification>    ::=   ADD <original method specification>

    <add overriding method specification>    ::=   ADD <overriding method specification>

    <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 data type statement>    ::=   DROP TYPE <user-defined type name> <drop behavior>

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

    <transforms to be dropped>    ::=   ALL | <transform group element>

    <transform group element>    ::=   <group name>

    Top


    SQL Data Manipulation Statements

    <SQL data statement>    ::=
             <open statement>
         |     <fetch statement>
         |     <close statement>
         |     <select statement: single row>
         |     <free locator statement>
         |     <hold locator statement>
         |     <SQL data change statement>

    <open statement>    ::=   OPEN <cursor name>

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

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

    <simple value specification>    ::=
             <literal>
         |     <host parameter name>
         |     <SQL parameter reference>
         |     <SQL variable reference>
         |     <embedded variable name>

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

    <locator reference>    ::=   <host parameter name> | <embedded variable name>

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

    <SQL data change statement>    ::=
             <delete statement: positioned>
         |     <delete statement: searched>
         |     <insert statement>
         |     <update statement: positioned>
         |     <update statement: searched>

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

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

    <target table>    ::=
             <table name>
         |     [ ONLY ] <left paren> <table name> <right paren>

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

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

    <insertion target>    ::=   <table name>

    <insert columns and source>    ::=   <from subquery> | <from constructor> | <from default>

    <from subquery>    ::=
             [ <left paren> <insert column list> <right paren> ] [ <override clause> ] <query expression>

    <insert column list>    ::=   <column name list>

    <from constructor>    ::=
             [ <left paren> <insert column list> <right paren> ] [ <override clause> ]
             <contextually typed table value constructor>

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

    <contextually typed row value expression>    ::=
             <row value special case>
         |     <contextually typed row value constructor>

    <contextually typed row value constructor>    ::=
             <contextually typed row value constructor element>
         |     [ ROW ] <left paren> <contextually typed row value constructor element list> <right paren>

    <contextually typed row value constructor element>    ::=
             <value expression> | <contextually typed value specification>

    <contextually typed value specification>    ::=
             <implicitly typed value specification> | <default specification>

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

    <set clause>    ::=
             <update target> <equals operator> <update source>
         |     <mutated set clause> <equals operator> <update source>

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

    <update target>    ::=
             <object column>
         |     <object column> <left bracket or trigraph> <simple value specification> <right bracket or trigraph>

    <object column>    ::=   <column name>

    <update source>    ::=   <value expression> | <contextually typed value specification>

    <mutated set clause>    ::=   <mutated target> <period> <method name>

    <mutated target>    ::=   <object column> | <mutated set clause>

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

    Top


    SQL Control Statements

    <SQL control statement>    ::=
             <call statement>
         |     <return statement>
         |     <assignment statement>
         |     <compound statement>
         |     <case statement>
         |     <if statement>
         |     <iterate statement>
         |     <leave statement>
         |     <loop statement>
         |     <while statement>
         |     <repeat statement>
         |     <for statement>

    <call statement>    ::=   CALL <routine invocation>

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

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

    Top


    Transaction Management

    <SQL transaction statement>    ::=
             <start transaction statement>
         |     <set transaction statement>
         |     <set constraints mode statement>
         |     <savepoint statement>
         |     <release savepoint statement>
         |     <commit statement>
         |     <rollback statement>

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

    <transaction mode>    ::=   <isolation level> | <transaction access mode> | <diagnostics size>

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

    <number of conditions>    ::=   <simple value specification>

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

    <savepoint specifier>    ::=   <savepoint name>

    <savepoint name>    ::=   <identifier>

    <simple target specification>    ::=
             <host parameter specification>
         |     <SQL parameter reference>
         |     <column reference>
         |     <SQL variable reference>
         |     <embedded variable name>

    <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

    <SQL connection statement>    ::=   <connect statement> | <set connection statement> | <disconnect statement>

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

    <connection name>    ::=   <simple value specification>

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

    <SQL session statement>    ::=
             <set session user identifier statement>
         |     <set role statement>
         |     <set local time zone statement>
         |     <set session characteristics statement>
         |     <set catalog statement>
         |     <set schema statement>
         |     <set names statement>
         |     <set path statement>
         |     <set transform group statement>

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

    <set role statement>    ::=   SET ROLE <role specification>

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

    <set local time zone statement>    ::=   SET TIME ZONE <set time zone value>

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

    <session characteristic>    ::=   <transaction characteristics>

    <SQL diagnostics statement>    ::=   <get diagnostics statement> | <signal statement> | <resignal statement>

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

    <SQL diagnostics information>    ::=   <statement information> | <condition information>

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

    <statement information item>    ::=
             <simple target specification> <equals operator> <statement information item name>

    <statement information item name>    ::=
             NUMBER
         |     MORE
         |     COMMAND_FUNCTION
         |     COMMAND_FUNCTION_CODE
         |     DYNAMIC_FUNCTION
         |     DYNAMIC_FUNCTION_CODE
         |     ROW_COUNT
         |     TRANSACTIONS_COMMITTED
         |     TRANSACTIONS_ROLLED_BACK
         |     TRANSACTION_ACTIVE

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

    <condition number>    ::=   <simple value specification>

    <condition information item>    ::=
             <simple target specification> <equals operator> <condition information item name>

    <condition information item name>    ::=
             CATALOG_NAME
         |     CLASS_ORIGIN
         |     COLUMN_NAME
         |     CONDITION_IDENTIFIER
         |     CONDITION_NUMBER
         |     CONNECTION_NAME
         |     CONSTRAINT_CATALOG
         |     CONSTRAINT_NAME
         |     CONSTRAINT_SCHEMA
         |     CURSOR_NAME
         |     MESSAGE_LENGTH
         |     MESSAGE_OCTET_LENGTH
         |     MESSAGE_TEXT
         |     PARAMETER_MODE
         |     PARAMETER_NAME
         |     PARAMETER_ORDINAL_POSITION
         |     RETURNED_SQLSTATE
         |     ROUTINE_CATALOG
         |     ROUTINE_NAME
         |     ROUTINE_SCHEMA
         |     SCHEMA_NAME
         |     SERVER_NAME
         |     SPECIFIC_NAME
         |     SUBCLASS_ORIGIN
         |     TABLE_NAME
         |     TRIGGER_CATALOG
         |     TRIGGER_NAME
         |     TRIGGER_SCHEMA

    <dereference operation>    ::=
             <reference value expression> <dereference operator> <attribute name>

    <method reference>    ::=
             <value expression primary> <dereference operator> <method name> <SQL argument list>

    <method selection>    ::=   <routine invocation>

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

    <new invocation>    ::=   <method invocation> | <routine invocation>

    <static method selection>    ::=   <routine invocation>

    <token>    ::=   <nondelimiter token> | <delimiter token>

    <nondelimiter token>    ::=
             <regular identifier>
         |     <key word>
         |     <unsigned numeric literal>
         |     <national character string literal>
         |     <bit string literal>
         |     <hex string literal>
         |     <large object length token>
         |     <multiplier>

    <key word>    ::=   <reserved word> | <non-reserved word>

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

    <reserved word>    ::=
             ABSOLUTE | ACTION | ADD | AFTER | ALL | ALLOCATE | ALTER | AND | ANY | ARE
         |     ARRAY | AS | ASC | ASSERTION | AT | AUTHORIZATION
         |     BEFORE | BEGIN | BETWEEN | BINARY | BIT | BLOB | BOOLEAN | BOTH
         |     BREADTH | BY
         |     CALL | CASCADE | CASCADED | CASE | CAST | CATALOG | CHAR | CHARACTER
         |     CHECK | CLOB | CLOSE | COLLATE | COLLATION | COLUMN | COMMIT
         |     CONDITION | CONNECT | CONNECTION | CONSTRAINT | CONSTRAINTS
         |     CONSTRUCTOR | CONTINUE | CORRESPONDING | CREATE | CROSS | CUBE
         |     CURRENT | CURRENT_DATE | CURRENT_DEFAULT_TRANSFORM_GROUP
         |     CURRENT_TRANSFORM_GROUP_FOR_TYPE | CURRENT_PATH | CURRENT_ROLE
         |     CURRENT_TIME | CURRENT_TIMESTAMP | CURRENT_USER | CURSOR | CYCLE
         |     DATA | DATE | DAY | DEALLOCATE | DEC | DECIMAL | DECLARE | DEFAULT
         |     DEFERRABLE | DEFERRED | DELETE | DEPTH | DEREF | DESC
         |     DESCRIBE | DESCRIPTOR | DETERMINISTIC
         |     DIAGNOSTICS | DISCONNECT | DISTINCT | DO | DOMAIN | DOUBLE
         |     DROP | DYNAMIC
         |     EACH | ELSE | ELSEIF | END | END-EXEC | EQUALS | ESCAPE | EXCEPT
         |     EXCEPTION | EXEC | EXECUTE | EXISTS | EXIT | EXTERNAL
         |     FALSE | FETCH | FIRST | FLOAT | FOR | FOREIGN | FOUND | FROM | FREE
         |     FULL | FUNCTION
         |     GENERAL | GET | GLOBAL | GO | GOTO | GRANT | GROUP | GROUPING
         |     HANDLE | HAVING | HOLD | HOUR
         |     IDENTITY | IF | IMMEDIATE | IN | INDICATOR
         |     INITIALLY | INNER | INOUT | INPUT | INSERT | INT | INTEGER
         |     INTERSECT | INTERVAL | INTO | IS | ISOLATION
         |     JOIN
         |     KEY
         |     LANGUAGE | LARGE | LAST | LATERAL | LEADING | LEAVE | LEFT
         |     LEVEL | LIKE | LOCAL | LOCALTIME | LOCALTIMESTAMP | LOCATOR | LOOP
         |     MAP | MATCH | METHOD | MINUTE | MODIFIES | MODULE | MONTH
         |     NAMES | NATIONAL | NATURAL | NCHAR | NCLOB | NESTING | NEW | NEXT
         |     NO | NONE | NOT | NULL | NUMERIC
         |     OBJECT | OF | OLD | ON | ONLY | OPEN | OPTION
         |     OR | ORDER | ORDINALITY | OUT | OUTER | OUTPUT | OVERLAPS
         |     PAD | PARAMETER | PARTIAL | PATH | PRECISION
         |     PREPARE | PRESERVE | PRIMARY | PRIOR | PRIVILEGES | PROCEDURE | PUBLIC
         |     READ | READS | REAL | RECURSIVE | REDO | REF | REFERENCES | REFERENCING
         |     RELATIVE | RELEASE | REPEAT | RESIGNAL | RESTRICT | RESULT | RETURN
         |     RETURNS | REVOKE | RIGHT | ROLE | ROLLBACK | ROLLUP | ROUTINE
         |     ROW | ROWS
         |     SAVEPOINT | SCHEMA | SCROLL | SEARCH | SECOND | SECTION | SELECT
         |     SESSION | SESSION_USER | SET | SETS | SIGNAL | SIMILAR | SIZE
         |     SMALLINT | SOME | SPACE | SPECIFIC | SPECIFICTYPE | SQL | SQLEXCEPTION
         |     SQLSTATE | SQLWARNING | START | STATE | STATIC | SYSTEM_USER
         |     TABLE | TEMPORARY | THEN | TIME | TIMESTAMP
         |     TIMEZONE_HOUR | TIMEZONE_MINUTE | TO | TRAILING | TRANSACTION
         |     TRANSLATION | TREAT | TRIGGER | TRUE
         |     UNDER | UNDO | UNION | UNIQUE | UNKNOWN | UNNEST | UNTIL | UPDATE
         |     USAGE | USER | USING
         |     VALUE | VALUES | VARCHAR | VARYING | VIEW
         |     WHEN | WHENEVER | WHERE | WHILE | WITH | WITHOUT | WORK | WRITE
         |     YEAR
         |     ZONE

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

    <non-reserved word>    ::=
             ABS | ADA | ADMIN | ASENSITIVE | ASSIGNMENT | ASYMMETRIC | ATOMIC
         |     ATTRIBUTE | AVG
         |     BIT_LENGTH
         |     C | CALLED | CARDINALITY | CATALOG_NAME | CHAIN | CHAR_LENGTH
         |     CHARACTERISTICS | CHARACTER_LENGTH | CHARACTER_SET_CATALOG
         |     CHARACTER_SET_NAME | CHARACTER_SET_SCHEMA | CHECKED | CLASS_ORIGIN
         |     COALESCE | COBOL | COLLATION_CATALOG | COLLATION_NAME | COLLATION_SCHEMA
         |     COLUMN_NAME | COMMAND_FUNCTION | COMMAND_FUNCTION_CODE | COMMITTED
         |     CONDITION_IDENTIFIER | CONDITION_NUMBER | CONNECTION_NAME
         |     CONSTRAINT_CATALOG | CONSTRAINT_NAME | CONSTRAINT_SCHEMA | CONTAINS
         |     CONVERT | COUNT | CURSOR_NAME
         |     DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_PRECISION | DEFINED
         |     DEFINER | DEGREE | DERIVED | DISPATCH
         |     EVERY | EXTRACT
         |     FINAL | FORTRAN
         |     G | GENERATED | GRANTED
         |     HIERARCHY
         |     IMPLEMENTATION | INSENSITIVE | INSTANCE | INSTANTIABLE | INVOKER
         |     K | KEY_MEMBER | KEY_TYPE
         |     LENGTH | LOWER
         |     M | MAX | MIN | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT
         |     MOD | MORE | MUMPS
         |     NAME | NULLABLE | NUMBER | NULLIF
         |     OCTET_LENGTH | ORDERING | OPTIONS | OVERLAY | OVERRIDING
         |     PASCAL | PARAMETER_MODE | PARAMETER_NAME
         |     PARAMETER_ORDINAL_POSITION | PARAMETER_SPECIFIC_CATALOG
         |     PARAMETER_SPECIFIC_NAME | PARAMETER_SPECIFIC_SCHEMA | PLI | POSITION
         |     REPEATABLE | RETURNED_CARDINALITY | RETURNED_LENGTH
         |     RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE | ROUTINE_CATALOG
         |     ROUTINE_NAME | ROUTINE_SCHEMA | ROW_COUNT
         |     SCALE | SCHEMA_NAME | SCOPE | SECURITY | SELF | SENSITIVE | SERIALIZABLE
         |     SERVER_NAME | SIMPLE | SOURCE | SPECIFIC_NAME | STATEMENT | STRUCTURE
         |     STYLE | SUBCLASS_ORIGIN | SUBSTRING | SUM | SYMMETRIC | SYSTEM
         |     TABLE_NAME | TOP_LEVEL_COUNT | TRANSACTIONS_COMMITTED
         |     TRANSACTIONS_ROLLED_BACK | TRANSACTION_ACTIVE | TRANSFORM
         |     TRANSFORMS | TRANSLATE | TRIGGER_CATALOG | TRIGGER_SCHEMA
         |     TRIGGER_NAME | TRIM | TYPE
         |     UNCOMMITTED | UNNAMED | UPPER

    <delimiter token>    ::=
             <character string literal>
         |     <date string>
         |     <time string>
         |     <timestamp string>
         |     <interval string>
         |     <delimited identifier>
         |     <SQL special character>
         |     <not equals operator>
         |     <greater than or equals operator>
         |     <less than or equals operator>
         |     <concatenation operator>
         |     <right arrow>
         |     <left bracket trigraph>
         |     <right bracket trigraph>
         |     <double colon>
         |     <double period>

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

    <CLI routine name>    ::=   <CLI name prefix> <CLI generic name>

    <CLI name prefix>    ::=   <CLI by-reference prefix> | <CLI by-value prefix>

    <CLI by-reference prefix>    ::=   SQLR

    <CLI by-value prefix>    ::=   SQL

    <CLI generic name>    ::=
             AllocConnect | AllocEnv | AllocHandle | AllocStmt
         |     BindCol | BindParameter
         |     Cancel | CloseCursor | ColAttribute | ColumnPrivileges | Columns | Connect | CopyDesc
         |     DataSources | DescribeCol | Disconnect
         |     EndTran | Error | ExecDirect | Execute
         |     Fetch | FetchScroll | ForeignKeys | FreeConnect | FreeEnv | FreeHandle | FreeStmt
         |     GetConnectAttr | GetCursorName | GetData | GetDescField | GetDescRec | GetDiagField
         |     GetDiagRec | GetEnvAttr | GetFeatureInfo | GetFunctions | GetInfo | GetLength
         |     GetParamData | GetPosition | GetSessionInfo | GetStmtAttr | GetSubString | GetTypeInfo
         |     MoreResults
         |     NextResult | NumResultCols
         |     ParamData | Prepare | PrimaryKeys | PutData
         |     RowCount
         |     SetConnectAttr | SetCursorName | SetDescField | SetDescRec | SetEnvAttr | SetStmtAttr
         |     SpecialColumns | StartTran
         |     TablePrivileges | Tables
         |     <implementation-defined CLI generic name>

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

    <CLI parameter list>    ::=
             <left paren> <CLI parameter declaration> [ { <comma> <CLI parameter declaration> }... ] <right paren>

    <CLI parameter declaration>    ::=
             <CLI parameter name> <CLI parameter mode> <CLI parameter data type>

    <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

    <assignment statement>    ::=
             SET <assignment target> <equals operator> <assignment source>

    <assignment target>    ::=   <target specification> | <modified field reference> | <mutator reference>

    <SQL variable reference>    ::=   <basic identifier chain>

    <modified field reference>    ::=   <modified field target> <period> <field name>

    <modified field target>    ::=
         <target specification> | <left paren> <target specification> <right paren> | <modified field reference>

    <mutator reference>    ::=   <mutated target specification> <period> <method name>

    <mutated target specification>    ::=
             <target specification> | <left paren> <target specification> <right paren> | <mutator reference>

    <assignment source>    ::=   <value expression> | <contextually typed source>

    <contextually typed source>    ::=
             <implicitly typed value specification> | <contextually typed row value expression>

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

    <beginning label>    ::=   <statement label>

    <statement label>    ::=   <identifier>

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

    <terminated local declaration>    ::=   <local declaration> <semicolon>

    <local declaration>    ::=   <SQL variable declaration> | <condition declaration>

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

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

    <SQL variable name>    ::=   <identifier>

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

    <condition name>    ::=   <identifier>

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

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

    <terminated local cursor declaration>    ::=   <declare cursor> <semicolon>

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

    <terminated local handler declaration>    ::=   <handler declaration> <semicolon>

    <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

    <handler action>    ::=   <SQL procedure statement>

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

    <terminated SQL statement>    ::=   <SQL procedure statement> <semicolon>

    <ending label>    ::=   <statement label>

    <case statement>    ::=   <simple case statement> | <searched case statement>

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

    <simple case operand 1>    ::=   <value expression>

    <simple case statement when clause>    ::=
             WHEN <simple case operand 2> THEN <SQL statement list>

    <simple case operand 2>    ::=   <value expression>

    <case statement else clause>    ::=   ELSE <SQL statement list>

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

    <searched case statement when clause>    ::=
             WHEN <search condition> THEN <SQL statement list>

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

    <if statement then clause>    ::=   THEN <SQL statement list>

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

    <if statement else clause>    ::=   ELSE <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> ]

    <for loop variable name>    ::=   <identifier>

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

    <signal value>    ::=   <condition name> | <sqlstate value>

    <set signal information>    ::=   SET <signal information item list>

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

    <signal information item>    ::=
             <condition information item name> <equals operator> <simple value specification>

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

    <default schema name>    ::=   <schema name>

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

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

    <module routine>    ::=   <module procedure> | <module function>

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

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

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

    <triggered SQL statement>    ::=   <SQL procedure statement>

    Top


    Dynamic SQL

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

    <SQL dynamic statement>    ::=
             <system descriptor statement>
         |     <prepare statement>
         |     <deallocate prepared statement>
         |     <describe statement>
         |     <execute statement>
         |     <execute immediate statement>
         |     <SQL dynamic data statement>

    <system descriptor statement>    ::=
             <allocate descriptor statement>
         |     <deallocate descriptor statement>
         |     <set descriptor statement>
         |     <get descriptor statement>

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

    <descriptor name>    ::=   [ <scope option> ] <simple value specification>

    <scope option>    ::=   GLOBAL | LOCAL

    <embedded variable name>    ::=   <colon> <host identifier>

    <host identifier>    ::=
             <Ada host identifier>
         |     <C host identifier>
         |     <COBOL host identifier>
         |     <Fortran host identifier>
         |     <MUMPS host identifier>
         |     <Pascal host identifier>
         |     <PL/I host identifier>

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

    <occurrences>    ::=   <simple value specification>

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

    <set header information>    ::=
             <header item name> <equals operator> <simple value specification 1>

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

    <simple value specification 1>    ::=   <simple value specification>

    <item number>    ::=   <simple value specification>

    <set item information>    ::=
             <descriptor item name> <equals operator> <simple value specification 2>

    <descriptor item name>    ::=
             CARDINALITY
         |     CHARACTER_SET_CATALOG
         |     CHARACTER_SET_NAME
         |     CHARACTER_SET_SCHEMA
         |     COLLATION_CATALOG
         |     COLLATION_NAME
         |     COLLATION_SCHEMA
         |     DATA
         |     DATETIME_INTERVAL_CODE
         |     DATETIME_INTERVAL_PRECISION
         |     DEGREE
         |     INDICATOR
         |     KEY_MEMBER
         |     LENGTH
         |     LEVEL
         |     NAME
         |     NULLABLE
         |     OCTET_LENGTH
         |     PARAMETER_MODE
         |     PARAMETER_ORDINAL_POSITION
         |     PARAMETER_SPECIFIC_CATALOG
         |     PARAMETER_SPECIFIC_NAME
         |     PARAMETER_SPECIFIC_SCHEMA
         |     PRECISION
         |     RETURNED_CARDINALITY
         |     RETURNED_LENGTH
         |     RETURNED_OCTET_LENGTH
         |     SCALE
         |     SCOPE_CATALOG
         |     SCOPE_NAME
         |     SCOPE_SCHEMA
         |     TYPE
         |     UNNAMED
         |     USER_DEFINED_TYPE_CATALOG
         |     USER_DEFINED_TYPE_NAME
         |     USER_DEFINED_TYPE_SCHEMA

    <simple value specification 2>    ::=   <simple value specification>

    <item number>    ::=   <simple value specification>

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

    <get header information>    ::=
             <simple target specification 1> <equals operator> <header item name>

    <simple target specification 1>    ::=   <simple target specification>

    <get item information>    ::=
             <simple target specification 2> <equals operator> <descriptor item name>

    <simple target specification 2>    ::=   <simple target specification>

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

    <SQL statement name>    ::=
             <statement name>
         |     <extended statement name>

    <statement name>    ::=   <identifier>

    <extended statement name>    ::=   [ <scope option> ] <simple value specification>

    <SQL statement variable>    ::=   <simple value specification>

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

    <describe statement>    ::=   <describe input statement> | <describe output statement>

    <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

    <extended cursor name>    ::=   [ <scope option> ] <simple value specification>

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

    <result using clause>    ::=   <output using clause>

    <output using clause>    ::=   <into arguments> | <into descriptor>

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

    <into argument>    ::=   <target specification>

    <dynamic parameter specification>    ::=   <question mark>

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

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

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

    <parameter using clause>    ::=   <input using clause>

    <input using clause>    ::=   <using arguments> | <using input descriptor>

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

    <using argument>    ::=   <general value specification>

    <using input descriptor>    ::=   <using descriptor>

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

    <SQL dynamic data statement>    ::=
             <allocate cursor statement>
         |     <dynamic open statement>
         |     <dynamic fetch statement>
         |     <dynamic close statement>
         |     <dynamic delete statement: positioned>
         |     <dynamic update statement: positioned>

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

    <cursor intent>    ::=   <statement cursor> | <result set cursor>

    <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 cursor name>    ::=   <cursor name> | <extended cursor name>

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

    <double period>    ::=   <period> <period>

    <direct SQL statement>    ::=   <directly executable statement> <semicolon>

    <directly executable statement>    ::=
             <direct SQL data statement>
         |     <SQL schema statement>
         |     <SQL transaction statement>
         |     <SQL connection statement>
         |     <SQL session statement>
         |     <direct implementation-defined statement>

    <direct SQL data statement>    ::=
             <delete statement: searched>
         |     <direct select statement: multiple rows>
         |     <insert statement>
         |     <update statement: searched>
         |     <temporary table declaration>

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

    <set catalog statement>    ::=   SET <catalog name characteristic>

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

    <set schema statement>    ::=   SET <schema name characteristic>

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

    <set names statement>    ::=   SET <character set name characteristic>

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

    <set path statement>    ::=   SET <SQL-path characteristic>

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

    <set transform group statement>    ::=   SET <transform group characteristic>

    <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 declare section>    ::=
             <embedded SQL begin declare>
             [ <embedded character set declaration> ]
             [ <host variable definition> ... ]
             <embedded SQL end declare>
         |     <embedded SQL MUMPS declare>

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

    <SQL prefix>    ::=   EXEC SQL | <ampersand> SQL <left paren>

    <SQL terminator>    ::=   END-EXEC | <semicolon> | <right paren>

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

    <host variable definition>    ::=
             <Ada variable definition>
         |     <C variable definition>
         |     <COBOL variable definition>
         |     <Fortran variable definition>
         |     <MUMPS variable definition>
         |     <Pascal variable definition>
         |     <PL/I variable definition>

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

    <Ada type specification>    ::=
             <Ada qualified type specification>
         |     <Ada unqualified type specification>
         |     <Ada derived type specification>

    <Ada qualified type specification>    ::=
             Interfaces.SQL <period> CHAR [ CHARACTER SET [ IS ] <character set specification> ]
             <left paren> 1 <double period> <length> <right paren>
         |     Interfaces.SQL <period> BIT <left paren> 1 <double period> <length> <right paren>
         |     Interfaces.SQL <period> SMALLINT
         |     Interfaces.SQL <period> INT
         |     Interfaces.SQL <period> REAL
         |     Interfaces.SQL <period> DOUBLE_PRECISION
         |     Interfaces.SQL <period> BOOLEAN
         |     Interfaces.SQL <period> SQLSTATE_TYPE
         |     Interfaces.SQL <period> INDICATOR_TYPE

    <Ada unqualified type specification>    ::=
             CHAR <left paren> 1 <double period> <length> <right paren>
         |     BIT <left paren> 1 <double period> <length> <right paren>
         |     SMALLINT
         |     INT
         |     REAL
         |     DOUBLE_PRECISION
         |     BOOLEAN
         |     SQLSTATE_TYPE
         |     INDICATOR_TYPE

    <Ada derived type specification>    ::=
             <Ada CLOB variable>
         |     <Ada BLOB variable>
         |     <Ada user-defined type variable>
         |     <Ada CLOB locator variable>
         |     <Ada BLOB locator variable>
         |     <Ada user-defined type locator variable>
         |     <Ada array locator variable>
         |     <Ada REF variable>

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

    <Ada BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <Ada user-defined type variable>    ::=
             SQL TYPE IS <user-defined type> AS <predefined type>

    <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 REF variable>    ::=
             SQL TYPE IS <reference type>

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

    <Ada assignment operator>    ::=   <colon> <equals operator>

    <C variable definition>    ::=
             [ <C storage class> ] [ <C class modifier> ] <C variable specification> <semicolon>

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

    <C class modifier>    ::=   const | volatile

    <C variable specification>    ::=   <C numeric variable> | <C character variable> | <C derived variable>

    <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 array specification>    ::=   <left bracket> <length> <right bracket>

    <C derived variable>    ::=
             <C VARCHAR variable>
         |     <C NCHAR variable>
         |     <C NCHAR VARYING variable>
         |     <C CLOB variable>
         |     <C NCLOB variable>
         |     <C BLOB variable>
         |     <C bit variable>
         |     <C user-defined type variable>
         |     <C CLOB locator variable>
         |     <C BLOB locator variable>
         |     <C array locator variable>
         |     <C user-defined type locator variable>
         |     <C REF variable>

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

    <C REF variable>    ::=
             SQL TYPE IS <reference type>

    <COBOL variable definition>    ::=
             {01|77} <COBOL host identifier> <COBOL type specification>
             [ <character representation> ... ] <period>

    <COBOL type specification>    ::=
             <COBOL character type>
         |     <COBOL national character type>
         |     <COBOL bit type>
         |     <COBOL numeric type>
         |     <COBOL integer type>
         |     <COBOL derived type specification>

    <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 specification>    ::=   <COBOL nines> [ V [ <COBOL nines> ] ] | V <COBOL nines>

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

    <COBOL integer type>    ::=   <COBOL binary integer>

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

    <COBOL derived type specification>    ::=
             <COBOL CLOB variable>
         |     <COBOL NCLOB variable>
         |     <COBOL BLOB variable>
         |     <COBOL user-defined type variable>
         |     <COBOL CLOB locator variable>
         |     <COBOL BLOB locator variable>
         |     <COBOL array locator variable>
         |     <COBOL user-defined type locator variable>
         |     <COBOL REF variable>

    <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 derived type specification>    ::=
             <Fortran CLOB variable>
         |     <Fortran BLOB variable>
         |     <Fortran user-defined type variable>
         |     <Fortran CLOB locator variable>
         |     <Fortran BLOB locator variable>
         |     <Fortran user-defined type locator variable>
         |     <Fortran array locator variable>
         |     <Fortran REF variable>

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

    <Fortran BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <Fortran user-defined type variable>    ::=
             SQL TYPE IS <user-defined type> AS <predefined type>

    <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

    <Fortran REF variable>    ::=
             SQL TYPE IS <reference type>

    <MUMPS variable definition>    ::=
             <MUMPS numeric variable> <semicolon>
         |     <MUMPS character variable> <semicolon>
         |     <MUMPS derived type specification> <semicolon>

    <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 length specification>    ::=
             <left paren> <length> <right paren>

    <MUMPS derived type specification>    ::=
             <MUMPS CLOB variable>
         |     <MUMPS BLOB variable>
         |     <MUMPS user-defined type variable>
         |     <MUMPS CLOB locator variable>
         |     <MUMPS BLOB locator variable>
         |     <MUMPS user-defined type locator variable>
         |     <MUMPS array locator variable>
         |     <MUMPS REF variable>

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

    <MUMPS BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <MUMPS user-defined type variable>    ::=
             SQL TYPE IS <user-defined type> AS <predefined type>

    <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

    <MUMPS REF variable>    ::=   SQL TYPE IS <reference type>

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

    <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 derived type specification>    ::=
             <Pascal CLOB variable>
         |     <Pascal BLOB variable>
         |     <Pascal user-defined type variable>
         |     <Pascal CLOB locator variable>
         |     <Pascal BLOB locator variable>
         |     <Pascal user-defined type locator variable>
         |     <Pascal array locator variable>
         |     <Pascal REF variable>

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

    <Pascal BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <Pascal user-defined type variable>    ::=
             SQL TYPE IS <user-defined type> AS <predefined type>

    <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

    <Pascal REF variable>    ::=   SQL TYPE IS <reference type>

    <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 derived type specification>    ::=
             <PL/I CLOB variable>
         |     <PL/I BLOB variable>
         |     <PL/I user-defined type variable>
         |     <PL/I CLOB locator variable>
         |     <PL/I BLOB locator variable>
         |     <PL/I user-defined type locator variable>
         |     <PL/I array locator variable>
         |     <PL/I REF variable>

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

    <PL/I BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <PL/I user-defined type variable>    ::=
             SQL TYPE IS <user-defined type> AS <predefined type>

    <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

    <PL/I REF variable>    ::=   SQL TYPE IS <reference type>

    <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 host program>    ::=
             <embedded SQL Ada program>
         |     <embedded SQL C program>
         |     <embedded SQL COBOL program>
         |     <embedded SQL Fortran program>
         |     <embedded SQL MUMPS program>
         |     <embedded SQL Pascal program>
         |     <embedded SQL PL/I program>

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

    <statement or declaration>    ::=
             <declare cursor>
         |     <dynamic declare cursor>
         |     <temporary table declaration>
         |     <embedded authorization declaration>
         |     <embedded path specification>
         |     <embedded transform group specification>
         |     <embedded exception declaration>
         |     <handler declaration>
         |     <SQL-invoked routine>
         |     <SQL procedure statement>

    <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 authorization identifier>    ::=   <module authorization identifier>

    <embedded path specification>    ::=   <path specification>

    <embedded transform group specification>    ::=   <transform group specification>

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

    <condition>    ::=   <SQL condition>

    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 char>    ::=   <simple Latin upper case letter> | <digit>

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

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

    <go to>    ::=   { GOTO | GO TO } <goto target>

    <goto target>    ::=   <host label identifier> | <unsigned integer> | <host PL/I label variable>

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

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

    <interval primary>    ::=
             <value expression primary> [ <interval qualifier> ]
         |     <interval value function>

    <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 statement>    ::=
             <preparable SQL data statement>
         |     <preparable SQL schema statement>
         |     <preparable SQL transaction statement>
         |     <preparable SQL control statement>
         |     <preparable SQL session statement>
         |     <preparable implementation-defined statement>

    <preparable SQL data statement>    ::=
             <delete statement: searched>
         |     <dynamic single row select statement>
         |     <insert statement>
         |     <dynamic select statement>
         |     <update statement: searched>
         |     <preparable dynamic delete statement: positioned>
         |     <preparable dynamic update statement: positioned>

    <dynamic single row select statement>    ::=   <query specification>

    <dynamic select statement>    ::=   <cursor specification>

    <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 SQL schema statement>    ::=   <SQL schema statement>

    <preparable SQL transaction statement>    ::=   <SQL transaction statement>

    <preparable SQL control statement>    ::=   <SQL control statement>

    <preparable SQL session statement>    ::=   <SQL session statement>

    <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> <triggered 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 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>
    amp <ampersand>
    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> <triggered SQL statement>
    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> <triggered SQL statement>
    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 <Ada qualified type specification> <Ada unqualified type specification> <character string type> <national character string type> <Pascal type specification> <PL/I type specification> <reserved word>
    char <C character type>
    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> <triggered SQL statement> <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 <CLI generic name>
    EXECUTE <action> <execute immediate statement> <execute statement> <reserved word>
    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 <dynamic fetch statement> <fetch statement> <reserved word>
    Fetch <CLI generic name>
    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 <greater than operator> <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 <less than operator> <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 <Package PKG(i)> <Part (n) no>
    NO <commit statement> <cursor scrollability> <pad characteristic> <referential action> <reserved word> <rollback statement> <SQL-data access indication>
    no <Part (n)>
    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>