BNF Grammar for ISO/IEC 9075:1992 - Database Language SQL (SQL-92)

 
Cross-Reference: rules
Cross-Reference: keywords

Derived from file sql-92.bnf version 2.3 dated 2004/03/31 19:34:09
Generated on 2005-07-13 18:32:46+00:00 by file bnf2html.pl version 3.7 dated 2005/07/13 18:32:35

Using Appendix G of "Understanding the New SQL: A Complete Guide" by J Melton and A R Simon (Morgan Kaufmann, 1993, ISBN 0-55860-245-3) as the source of the syntax, here is (most of) the BNF syntax for SQL-92. The missing parts are the Cobol, Fortran, MUMPS, Pascal and PL/I variable definition rules.

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


Key SQL Statements and Fragments

  • ALLOCATE CURSOR <allocate cursor statement>
  • ALTER DOMAIN <alter domain statement>
  • ALTER TABLE <alter table statement>
  • CLOSE cursor <close statement> <dynamic 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 SCHEMA <schema definition>
  • CREATE TABLE <table definition>
  • CREATE TRANSLATION <translation 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> <dynamic fetch statement>
  • GET DIAGNOSTICS <get diagnostics statement>
  • GRANT <grant statement>
  • INSERT <insert statement>
  • Literal <literal>
  • MODULE <module>
  • OPEN cursor <open statement> <dynamic open statement>
  • PREPARE <prepare statement>
  • Preparable statement <preparable statement>
  • REVOKE <revoke statement>
  • ROLLBACK WORK <rollback statement>
  • Search condition <search condition>
  • 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 authorization identifier statement>
  • SET TIME ZONE <set local time zone statement>
  • SET TRANSACTION <set transaction statement>
  • UPDATE <update statement: positioned> <update statement: searched> <dynamic update statement: positioned>
  • Value expression <value expression>

    Top


    Basic Definitions of Characters Used, Tokens, Symbols, Etc.

      <SQL terminal character>    ::=
             <SQL language character>
         |     <SQL embedded 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>
         |     <greater than operator>
         |     <equals operator>
         |     <question mark>
         |     <underscore>
         |     <vertical bar>

      <space>    ::=   !! space character in character set in use

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

      <underscore>    ::=   _

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

      <SQL embedded language character>    ::=   <left bracket> | <right bracket>

      <left bracket>    ::=   [

      <right bracket>    ::=   ]

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

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

      <regular identifier>    ::=   <identifier body>

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

      <identifier start>    ::=   !! See the Syntax rules

      <identifier part>    ::=   <identifier start> | <digit>

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

      <reserved word>    ::=
             ABSOLUTE | ACTION | ADD | ALL | ALLOCATE | ALTER | AND | ANY | ARE
         |     AS | ASC | ASSERTION | AT | AUTHORIZATION | AVG
         |     BEGIN | BETWEEN | BIT | BIT_LENGTH | BOTH | BY
         |     CASCADE | CASCADED | CASE | CAST | CATALOG | CHAR | CHARACTER | CHARACTER_LENGTH
         |     CHAR_LENGTH | CHECK | CLOSE | COALESCE | COLLATE | COLLATION | COLUMN | COMMIT
         |     CONNECT | CONNECTION | CONSTRAINT | CONSTRAINTS | CONTINUE | CONVERT | CORRESPONDING
         |     CREATE | CROSS | CURRENT | CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | CURRENT_USER | CURSOR
         |     DATE | DAY | DEALLOCATE | DEC | DECIMAL | DECLARE | DEFAULT
         |     DEFERRABLE | DEFERRED | DELETE | DESC | DESCRIBE | DESCRIPTOR | DIAGNOSTICS
         |     DISCONNECT | DISTINCT | DOMAIN | DOUBLE | DROP
         |     ELSE | END | END -EXEC | ESCAPE | EXCEPT | EXCEPTION | EXEC | EXECUTE | EXISTS | EXTERNAL | EXTRACT
         |     FALSE | FETCH | FIRST | FLOAT | FOR | FOREIGN | FOUND | FROM | FULL
         |     GET | GLOBAL | GO | GOTO | GRANT | GROUP
         |     HAVING | HOUR
         |     IDENTITY | IMMEDIATE | IN | INDICATOR | INITIALLY | INNER | INPUT | INSENSITIVE
         |     INSERT | INT | INTEGER | INTERSECT | INTERVAL | INTO | IS | ISOLATION
         |     JOIN
         |     KEY
         |     LANGUAGE | LAST | LEADING | LEFT | LEVEL | LIKE | LOCAL | LOWER
         |     MATCH | MAX | MIN | MINUTE | MODULE | MONTH
         |     NAMES | NATIONAL | NATURAL | NCHAR | NEXT | NO | NOT | NULL | NULLIF | NUMERIC
         |     OCTET_LENGTH | OF | ON | ONLY | OPEN | OPTION | OR | ORDER | OUTER | OUTPUT | OVERLAPS
         |     PAD | PARTIAL | POSITION | PRECISION | PREPARE | PRESERVE | PRIMARY | PRIOR | PRIVILEGES | PROCEDURE | PUBLIC
         |     READ | REAL | REFERENCES | RELATIVE | RESTRICT | REVOKE | RIGHT | ROLLBACK | ROWS
         |     SCHEMA | SCROLL | SECOND | SECTION | SELECT | SESSION | SESSION_USER | SET
         |     SIZE | SMALLINT | SOME | SPACE | SQL | SQLCODE | SQLERROR | SQLSTATE | SUBSTRING | SUM | SYSTEM_USER
         |     TABLE | TEMPORARY | THEN | TIME | TIMESTAMP | TIMEZONE_HOUR | TIMEZONE_MINUTE
         |     TO | TRAILING | TRANSACTION | TRANSLATE | TRANSLATION | TRIM | TRUE
         |     UNION | UNIQUE | UNKNOWN | UPDATE | UPPER | USAGE | USER | USING
         |     VALUE | VALUES | VARCHAR | VARYING | VIEW
         |     WHEN | WHENEVER | WHERE | WITH | WORK | WRITE
         |     YEAR
         |     ZONE

      <non-reserved word>    ::=
             ADA
         |     C | CATALOG_NAME | CHARACTER_SET_CATALOG | CHARACTER_SET_NAME | CHARACTER_SET_SCHEMA
         |     CLASS_ORIGIN | COBOL | COLLATION_CATALOG | COLLATION_NAME | COLLATION_SCHEMA
         |     COLUMN_NAME | COMMAND_FUNCTION | COMMITTED | CONDITION_NUMBER | CONNECTION_NAME
         |     CONSTRAINT_CATALOG | CONSTRAINT_NAME | CONSTRAINT_SCHEMA | CURSOR_NAME
         |     DATA | DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_PRECISION | DYNAMIC_FUNCTION
         |     FORTRAN
         |     LENGTH
         |     MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | MORE | MUMPS
         |     NAME | NULLABLE | NUMBER
         |     PASCAL | PLI
         |     REPEATABLE | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE | ROW_COUNT
         |     SCALE | SCHEMA_NAME | SERIALIZABLE | SERVER_NAME | SUBCLASS_ORIGIN
         |     TABLE_NAME | TYPE
         |     UNCOMMITTED | UNNAMED

    Top


    Literal Numbers, Strings, Dates and Times

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

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

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

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

      <mantissa>    ::=   <exact numeric literal>

      <exponent>    ::=   <signed integer>

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

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

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

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

      <nonquote character>    ::=   !! See the Syntax rules

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

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

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

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

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

      <newline>    ::=   !! implementation defined end of line indicator

      <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

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

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

      <introducer>    ::=   <underscore>

      <character set specification>    ::=
             <standard character repertoire name>
         |     <implementation-defined character repertoire name>
         |     <user-defined character repertoire name>
         |     <standard universal character form-of-use name>
         |     <implementation-defined universal character form-of-use name>

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

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

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

      <catalog name>    ::=   <identifier>

      <identifier>    ::=   [ <introducer> <character set specification> ] <actual identifier>

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

      <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

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

      <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 repertoire name>    ::=   <character set name>

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

      <standard universal character form-of-use name>    ::=   <character set name>

      <implementation-defined universal character form-of-use name>    ::=   <character set name>

      <date string>    ::=   <quote> <date value> <quote>

      <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 string>    ::=   <quote> <time value> [ <time zone interval> ] <quote>

      <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 string>    ::=   <quote> <date value> <space> <time value> [ <time zone interval> ] <quote>

      <interval string>    ::=   <quote> { <year-month literal> | <day-time literal> } <quote>

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

      <not equals operator>    ::=   <>

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

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

      <concatenation operator>    ::=   ||

      <double period>    ::=   ..

    Top


    SQL Module

      <module>    ::=
             <module name clause> <language clause> <module authorization clause>
             [ <temporary table declaration> ... ]
             <module contents> ...

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

      <module name>    ::=   <identifier>

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

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

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

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

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

      <authorization identifier>    ::=   <identifier>

      <temporary table declaration>    ::=
         DECLARE LOCAL TEMPORARY TABLE <qualified local table name> <table element list> [ ON COMMIT { PRESERVE | DELETE } ROWS ]

      <qualified local table name>    ::=   MODULE <period> <local table name>

      <local table name>    ::=   <qualified identifier>

      <qualified identifier>    ::=   <identifier>

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

      <table element>    ::=   <column definition> | <table constraint definition>

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

      <column name>    ::=   <identifier>

    Top


    Data Types

      <data type>    ::=
             <character string type> [ CHARACTER SET <character set specification> ]
         |     <national character string type>
         |     <bit string type>
         |     <numeric 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> ]

      <length>    ::=   <unsigned integer>

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

      <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

      <datetime type>    ::=
             DATE
         | TIME [ <left paren> <time precision> <right paren> ] [ WITH TIME ZONE ]
         | TIMESTAMP [ <left paren> <timestamp precision> <right paren> ] [ WITH TIME ZONE ]

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

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

      <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 datetime field> [ <left paren> <interval leading field precision> <right paren> ]

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

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

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

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

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

      <domain name>    ::=   <qualified name>

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

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

      <default option>    ::=
             <literal>
         |     <datetime value function>
         |     USER
         |     CURRENT_USER
         |     SESSION_USER
         |     SYSTEM_USER
         |     NULL

    Top


    Literals

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

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

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

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

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

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

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

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

      <datetime value function>    ::=
             <current date value function>
         |     <current time value function>
         |     <current 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> ]

    Top


    Constraints

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

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

      <constraint name>    ::=   <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> ]

      <table name>    ::=   <qualified name> | <qualified local table name>

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

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

      <match type>    ::=   FULL | PARTIAL

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

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

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

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

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

    Top


    Search Condition

      <search condition>    ::=
             <boolean term>
         | <search condition> 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> | <left paren> <search condition> <right paren>

      <predicate>    ::=
             <comparison predicate>
         | <between predicate>
         | <in predicate>
         | <like predicate>
         | <null predicate>
         | <quantified comparison predicate>
         | <exists predicate>
         | <match predicate>
         | <overlaps predicate>

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

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

      <row value constructor element>    ::=
             <value expression>
         | <null specification>
         | <default specification>

      <value expression>    ::=
             <numeric value expression>
         | <string value expression>
         | <datetime value expression>
         | <interval 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>    ::=
             <unsigned value specification>
         | <column reference>
         | <set function specification>
         | <scalar subquery>
         | <case expression>
         | <left paren> <value expression> <right paren>
         | <cast specification>

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

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

      <general value specification>    ::=
             <parameter specification>
         | <dynamic parameter specification>
         | <variable specification>
         | USER
         | CURRENT_USER
         | SESSION_USER
         | SYSTEM_USER
         | VALUE

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

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

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

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

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

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

      <C host identifier>    ::=   !! See syntax rules

      <Cobol host identifier>    ::=   !! See syntax rules

      <Fortran host identifier>    ::=   !! See syntax rules

      <MUMPS host identifier>    ::=   !! See syntax rules

      <Pascal host identifier>    ::=   !! See syntax rules

      <PL/I host identifier>    ::=   !! See syntax rules

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

      <column reference>    ::=   [ <qualifier> <period> ] <column name>

      <qualifier>    ::=   <table name> | <correlation name>

      <correlation name>    ::=   <identifier>

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

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

      <set function type>    ::=   AVG | MAX | MIN | SUM | COUNT

      <set quantifier>    ::=   DISTINCT | ALL

    Top


    Queries

      <scalar subquery>    ::=   <subquery>

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

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

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

      <non-join query term>    ::=
             <non-join query primary>
         |     <query term> INTERSECT [ ALL ] [ <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> | <qualifier> <period> <asterisk>

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

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

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

      <from clause>    ::=   FROM <table reference> [ { <comma> <table reference> }... ] Note that <correlation specification> does not appear in the ISO/IEC grammar. The notation is written out longhand several times, instead.

      <table reference>    ::=
             <table name> [ <correlation specification> ]
         | <derived table> <correlation specification>
         | <joined table>

      <correlation specification>    ::=
             [ AS ] <correlation name> [ <left paren> <derived column list> <right paren> ]

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

      <derived table>    ::=   <table subquery>

      <table subquery>    ::=   <subquery>

      <joined table>    ::=
             <cross join>
         | <qualified join>
         | <left paren> <joined table> <right paren>

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

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

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

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

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

      <group by clause>    ::=   GROUP BY <grouping column reference list>

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

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

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

      <collation name>    ::=   <qualified name>

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

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

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

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

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

    Top


    Query expression components

      <case expresssion>    ::=   <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> | NULL

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

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

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

      <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> | <bit value function>

      <character value function>    ::=
             <character substring function>
         | <fold>
         | <form-of-use conversion>
         | <character translation>
         | <trim function>

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

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

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

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

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

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

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

      <datetime field>    ::=   <non-second 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 qualifier> ]

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

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

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

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

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

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

      <null specification>    ::=   NULL

      <default specification>    ::=   DEFAULT

      <row value constructor 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>

      <between predicate>    ::=
             <row value constructor> [ NOT ] BETWEEN <row value constructor> AND <row value constructor>

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

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

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

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

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

      <pattern>    ::=   <character value expression>

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

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

      <quantified comparison predicate>    ::=   <row value constuctor> <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 constructor> MATCH [ UNIQUE ] [ PARTIAL | FULL ] <table subquery>

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

      <row value constructor 1>    ::=   <row value constructor>

      <row value constructor 2>    ::=   <row value constructor>

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

    Top


    More about constraints

      <constraint attributes>    ::=
             <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 check time> ]

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

      <unique constraint definition>    ::=   <unique specification> <left paren> <unique column list> <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>

    Top


    Module contents

      <module contents>    ::=
             <declare cursor>
         |     <dynamic declare cursor>
         |     <procedure>

      <declare cursor>    ::=
             DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR FOR <cursor specification>

      <cursor name>    ::=   <identifier>

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

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

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

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

      <sort key>    ::=   <column name> | <unsigned integer>

      <ordering specification>    ::=   ASC | DESC

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

      <dynamic declare cursor>    ::=
             DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR FOR <statement name>

      <statement name>    ::=   <identifier>

    Top


    SQL Procedures

      <procedure>    ::=
         PROCEDURE <procedure name> <parameter declaration list> <semicolon> <SQL procedure statement> <semicolon>

      <procedure name>    ::=   <identifier>

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

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

      <status parameter>    ::=   SQLCODE | SQLSTATE

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

    Top


    SQL Schema Definition Statements

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

      <SQL schema definition statement>    ::=
             <schema definition>
         |     <table definition>
         |     <view definition>
         |     <grant statement>
         |     <domain definition>
         |     <character set definition>
         |     <collation definition>
         |     <translation definition>
         |     <assertion definition>

      <schema definition>    ::=
             CREATE SCHEMA <schema name clause>
                 [ <schema character set specification> ]
                 [ <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 specification>    ::=   DEFAULT CHARACTER SET <character set specification>

      <schema element>    ::=
             <domain definition>
         |     <table definition>
         |     <view definition>
         |     <grant statement>
         |     <assertion definition>
         |     <character set definition>
         |     <collation definition>
         |     <translation definition>

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

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

      <table definition>    ::=
             CREATE [ { GLOBAL | LOCAL } TEMPORARY ] TABLE <table name> <table element list> [ ON COMMIT { DELETE | PRESERVE } ROWS ]

      <view definition>    ::=
             CREATE VIEW <table name> [ <left paren> <view column list> <right paren> ]
                 AS <query expression> [ WITH [ <levels clause> ] CHECK OPTION ]

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

      <levels clause>    ::=   CASCADED | LOCAL

      <grant statement>    ::=
             GRANT <privileges> ON <object name> TO <grantee> [ { <comma> <grantee> }... ] [ WITH GRANT OPTION ]

      <privileges>    ::=   ALL PRIVILEGES | <action list>

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

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

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

      <object name>    ::=
             [ TABLE ] <table name>
         |     DOMAIN <domain name>
         |     COLLATION <collation name>
         |     CHARACTER SET <character set name>
         |     TRANSLATION <translation name> <grantee> := PUBLIC | <authorization identifier>

      <assertion definition>    ::=
             CREATE ASSERTION <constraint name> <assertion check> [ <constraint attributes> ]

      <assertion check>    ::=   CHECK <left paren> <search condition> <right paren>

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

      <character set source>    ::=   GET <existing character set name>

      <existing character set name>    ::=
             <standard character repertoire name>
         |     <implementation-defined character repertoire name>
         |     <schema character set name>

      <schema character set name>    ::=   <character set name>

      <limited collation definition>    ::=
             COLLATION FROM <collation source>

      <collation source>    ::=   <collating sequence definition> | <translation collation>

      <collating sequence definition>    ::=
             <external collation>
         |     <schema collation name>
         |     DESC <left paren> <collation name> <right paren>
         |     DEFAULT

      <external collation>    ::=
         EXTERNAL <left paren> <quote> <external collation name> <quote> <right paren>

      <external collation name>    ::=   <standard collation name> | <implementation-defined collation name>

      <standard collation name>    ::=   <collation name>

      <implementation-defined collation name>    ::=   <collation name>

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

      <translation collation>    ::=   TRANSLATION <translation name> [ THEN COLLATION <collation name> ]

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

      <pad attribute>    ::=   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>    ::=   <translation specification>

      <translation specification>    ::=
             <external translation>
         |     IDENTITY
         |     <schema translation name>

      <external translation>    ::=
             EXTERNAL <left paren> <quote> <external translation name> <quote> <right paren>

      <external translation name>    ::=
             <standard translation name>
         |     <implementation-defined translation name>

      <standard translation name>    ::=   <translation name>

      <implementation-defined translation name>    ::=   <translation name>

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

      <SQL schema manipulation statement>    ::=
             <drop schema statement>
         |     <alter table statement>
         |     <drop table statement>
         |     <drop view statement>
         |     <revoke statement>
         |     <alter domain statement>
         |     <drop domain statement>
         |     <drop character set statement>
         |     <drop collation statement>
         |     <drop translation statement>
         |     <drop assertion statement>

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

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

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

      <drop column default clause>    ::=   DROP DEFAULT

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

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

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

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

      <drop view statement>    ::=   DROP VIEW <table name> <drop behaviour>

      <revoke statement>    ::=
             REVOKE [ GRANT OPTION FOR ] <privileges> ON <object name>
                 FROM <grantee> [ { <comma> <grantee> }... ] <drop behaviour>

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

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

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

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

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

    Top


    SQL Data Manipulation Statements

      <SQL data statement>    ::=
             <open statement>
         |     <fetch statement>
         |     <close statement>
         |     <select statement: single row>
         |     <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>    ::=   <parameter name> | <embedded variable name> | <literal>

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

      <target specification>    ::=
             <parameter specification>
         |     <variable 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> }... ]

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

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

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

      <insert statement>    ::=   INSERT INTO <table name> <insert columns and source>

      <insert columns and source>    ::=
             [ <left paren> <insert column list> <right paren> ] <query expression>
         |     DEFAULT VALUES

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

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

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

      <set clause>    ::=   <object column> <equals operator> <update source>

      <object column>    ::=   <column name>

      <update source>    ::=   <value expression> | <null specification> | DEFAULT

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

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

      <set transaction statement>    ::=
             SET 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 constraints mode statement>    ::=
             SET CONSTRAINTS <constraint name list> { DEFERRED | IMMEDIATE }

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

      <commit statement>    ::=   COMMIT [ WORK ]

      <rollback statement>    ::=   ROLLBACK [ WORK ]

    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 <user name> ]
         |     DEFAULT

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

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

      <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 catalog statement>
         |     <set schema statement>
         |     <set names statement>
         |     <set session authorization identifier statement>
         |     <set local time zone statement>

      <set catalog statement>    ::=   SET CATALOG <value specification>

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

      <set schema statement>    ::=   SET SCHEMA <value specification>

      <set names statement>    ::=   SET NAMES <value specification>

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

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

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

    Top


    Dynamic SQL

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

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

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

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

      <scope option>    ::=   GLOBAL | LOCAL

      <occurrences>    ::=   <simple value specification>

      <deallocate descriptor statement>    ::=   DEALLOCATE DESCRIPTOR <descriptor name>

      <set descriptor statement>    ::=
             SET DESCRIPTOR <descriptor name> <set descriptor information>

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

      <set count>    ::=   COUNT <equals operator> <simple value specification 1>

      <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>    ::=
             TYPE
         |     LENGTH
         |     OCTET_LENGTH
         |     RETURNED_LENGTH
         |     RETURNED_OCTET_LENGTH
         |     PRECISION
         |     SCALE
         |     DATETIME_INTERVAL_CODE
         |     DATETIME_INTERVAL_PRECISION
         |     NULLABLE
         |     INDICATOR
         |     DATA
         |     NAME
         |     UNNAMED
         |     COLLATION_CATALOG
         |     COLLATION_SCHEMA
         |     COLLATION_NAME
         |     CHARACTER_SET_CATALOG
         |     CHARACTER_SET_SCHEMA
         |     CHARACTER_SET_NAME

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

      <get descriptor statement>    ::=   GET DESCRIPTOR <descriptor name> <get descriptor information>

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

      <get count>    ::=   <simple target specification 1> <equals operator> COUNT

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

      <simple target specification>    ::=   <parameter name> | <embedded variable name>

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

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

      <using descriptor>    ::=   { USING | INTO } SQL DESCRIPTOR <descriptor name>

      <describe output statement>    ::=   DESCRIBE [ OUTPUT ] <SQL statement name> <using descriptor>

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

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

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

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

      <argument>    ::=   <target specification>

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

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

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

      <allocate cursor statement>    ::=
             ALLOCATE <extended cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR FOR <extended statement name>

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

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

      <dynamic cursor name>    ::=   <cursor name> | <extended cursor name>

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

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

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

      <dynamic update statement: positioned>    ::=
             UPDATE <table name>
                 SET <set clause> [ { <comma> <set clause> }... ]
                 WHERE CURRENT OF <dynamic cursor name>

      <SQL diagnostics statement>    ::=   <get diagnostics 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 | DYNAMIC_FUNCTION | ROW_COUNT

      <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>    ::=
             CONDITION_NUMBER
         |     RETURNED_SQLSTATE
         |     CLASS_ORIGIN
         |     SUBCLASS_ORIGIN
         |     SERVER_NAME
         |     CONNECTION_NAME
         |     CONSTRATIN_CATALOG
         |     CONSTRAINT_SCHEMA
         |     CONSTRAINT_NAME
         |     CATALOG_NAME
         |     SCHEMA_NAME
         |     TABLE_NAME
         |     COLUMN_NAME
         |     CURSOR_NAME
         |     MESSAGE_TEXT
         |     MESSAGE_LENGTH
         |     MESSAGE_OCTET_LENGTH

      <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 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> }...} :
             <Ada type specification> [ <Ada initial value> ]

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

      <Ada qualified type specification>    ::=
             SQL_STANDARD .CHAR [ CHARACTER SET [ IS ] <character set specification> ] <left paren> 1 <double period> <length> <right paren>
         |     SQL_STANDARD .BIT <left paren> 1 <double period> <length> <right paren>
         |     SQL_STANDARD .SMALLINT
         |     SQL_STANDARD .INT
         |     SQL_STANDARD .REAL
         |     SQL_STANDARD .DOUBLE_PRECISION
         |     SQL_STANDARD .SQLCODE_TYPE
         |     SQL_STANDARD .SQLSTATE_TYPE
         |     SQL_STANDARD .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
         |     SQLCODE_TYPE
         |     SQLSTATE_TYPE
         |     INDICATOR_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>    ::=
             char [ 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 array specification>    ::=   <left bracket> <length> <right bracket>

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

      <Cobol variable definition>    ::=
         /* ...omitted... */

      <Fortran variable definition>    ::=
         /* ...omitted... */

      <MUMPS variable definition>    ::=
         /* ...omitted... */

      <Pascal variable definition>    ::=
         /* ...omitted... */

      <PL/I variable definition>    ::=
         /* ...omitted... */

      <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 statement>    ::=   <SQL prefix> <statement or declaration> [ <SQL terminator> ]

      <statement or declaration>    ::=
             <declare cursor>
         |     <dynamic declare cursor>
         |     <temporary table declaration>
         |     <embedded exception declaration>
         |     <SQL procedure statement>

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

      <condition>    ::=   SQLERROR | NOT FOUND

      <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

      <preparable statement>    ::=
             <preparable SQL data statement>
         |     <preparable SQL schema statement>
         |     <preparable SQL transaction statement>
         |     <preparable SQL session statement>
         |     <preparable SQL 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 <table name> ] WHERE CURRENT OF <cursor name>

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

      <preparable SQL schema statement>    ::=   <SQL schema statement>

      <preparable SQL transaction statement>    ::=   <SQL transaction statement>

      <preparable SQL session statement>    ::=   <SQL session statement>

      <preparable SQL implementation-defined statement>    ::=   !! See the syntax rules

      <direct SQL statement>    ::=
             <direct SQL data statement>
         |     <SQL schema statement>
         |     <SQL transaction statement>
         |     <SQL connection statement>
         |     <SQL session stateament>
         |     <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> ]

      <direct implementation-defined statement>    ::=   !! See the syntax rules

    Top


    Identifying the version of SQL in use

      <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 variant>    ::=   <1987> | <1989> | <1992>

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

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

    Top


    END OF SQL-92 GRAMMAR



    Cross-Reference Table: Rules

    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    Rule (non-terminal) Rules using it
    1987 <SQL variant>
    1989 <SQL variant>
    1989 base <1989>
    1989 package <1989>
    1992 <SQL variant>
    action <action list>
    action list <privileges>
    actual identifier <identifier>
    Ada assignment operator <Ada initial value>
    Ada host identifier <Ada variable definition> <host identifier>
    Ada initial value <Ada variable definition>
    Ada qualified type specification <Ada type specification>
    Ada type specification <Ada variable definition>
    Ada unqualified type specification <Ada type specification>
    Ada variable definition <host variable definition>
    add column definition <alter table action>
    add domain constraint definition <alter domain action>
    add table constraint definition <alter table action>
    all <quantifier>
    allocate cursor statement <SQL dynamic data statement>
    allocate descriptor statement <system descriptor statement>
    alter column action <alter column definition>
    alter column definition <alter table action>
    alter domain action <alter domain statement>
    alter domain statement <SQL schema manipulation statement>
    alter table action <alter table statement>
    alter table statement <SQL schema manipulation statement>
    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>
    argument <using arguments>
    as clause <derived column>
    assertion check <assertion definition>
    assertion definition <schema element> <SQL schema definition statement>
    asterisk <interval term> <select list> <select sublist> <set function specification> <SQL special character> <term>
    authorization identifier <module authorization identifier> <schema authorization identifier>
    between predicate <predicate>
    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 <data type>
    bit substring function <bit value function>
    bit value expression <bit concatenation> <bit substring function> <string value expression>
    bit value function <string value function>
    boolean factor <boolean term>
    boolean primary <boolean test>
    boolean term <boolean term> <search condition>
    boolean test <boolean factor>
    C array specification <C bit variable> <C character variable> <C VARCHAR variable>
    C bit variable <C derived variable>
    C character variable <C variable specification>
    C class modifier <C variable definition>
    C derived variable <C variable specification>
    C host identifier <C bit variable> <C character variable> <C numeric variable> <C VARCHAR variable> <host identifier>
    C initial value <C bit variable> <C character variable> <C numeric variable> <C VARCHAR variable>
    C numeric variable <C variable specification>
    C storage class <C variable definition>
    C VARCHAR variable <C derived variable>
    C variable definition <host variable definition>
    C variable specification <C variable definition>
    case abbreviation <case expresssion>
    case expression <value expression primary>
    case operand <simple case>
    case specification <case expresssion>
    cast operand <cast specification>
    cast specification <value expression primary>
    cast target <cast specification>
    catalog name <schema name>
    char length expression <length expression>
    character factor <character value expression> <concatenation>
    character primary <character factor>
    character representation <Ada initial value> <C initial value> <character string literal> <national character string literal>
    character set definition <schema element> <SQL schema definition statement>
    character set name <character set definition> <drop character set statement> <implementation-defined character repertoire name> <implementation-defined universal character form-of-use name> <object name> <schema character set name> <standard character repertoire name> <standard universal character form-of-use name> <user-defined character repertoire name>
    character set source <character set definition>
    character set specification <Ada qualified type specification> <C character variable> <C VARCHAR variable> <character string literal> <collation definition> <data type> <embedded character set declaration> <identifier> <module character set specification> <schema character set specification> <source character set specification> <target character set specification>
    character string literal <delimiter token> <general literal>
    character string type <data type>
    character substring function <character value function>
    character translation <character value function>
    character value expression <character substring function> <character translation> <concatenation> <escape character> <fold> <form-of-use conversion> <match value> <pattern> <position expression> <string value expression> <trim character> <trim source>
    character value function <string value function>
    check constraint definition <column constraint> <domain constraint> <table constraint>
    close statement <SQL data statement>
    Cobol host identifier <host identifier>
    Cobol variable definition <host variable definition>
    collate clause <character factor> <character set definition> <column definition> <domain definition> <grouping column reference> <sort specification>
    collating sequence definition <collation source>
    collation definition <schema element> <SQL schema definition statement>
    collation name <collate clause> <collating sequence definition> <collation definition> <drop collation statement> <implementation-defined collation name> <object name> <schema collation name> <standard collation name> <translation collation>
    collation source <collation definition> <limited collation definition>
    colon <Ada assignment operator> <day-time interval> <embedded variable name> <parameter name> <SQL special character> <time value> <time zone interval> <time-interval>
    column constraint <column constraint definition>
    column constraint definition <column definition>
    column definition <add column definition> <table element>
    column name <alter column definition> <as clause> <column definition> <column name list> <column reference> <drop column definition> <object column> <sort key>
    column name list <corresponding column list> <derived column list> <insert column list> <join column list> <privilege column list> <reference column list> <unique column list> <updatability clause> <view column list>
    column reference <grouping column reference> <value expression primary>
    comma <action list> <Ada variable definition> <C bit variable> <C character variable> <C numeric variable> <C VARCHAR variable> <case abbreviation> <column name list> <condition information> <constraint name list> <dynamic update statement: positioned> <exact numeric type> <fetch target list> <from clause> <get descriptor information> <grant statement> <grouping column reference list> <in value list> <parameter declaration list> <revoke statement> <row value constructor list> <select list> <select target list> <set clause list> <set descriptor information> <set transaction statement> <single datetime field> <sort specification list> <SQL special character> <statement information> <table element list> <table value constructor list> <using arguments>
    comment <separator>
    comment character <comment>
    comment introducer <comment>
    commit statement <SQL transaction statement>
    comp op <comparison predicate> <quantified comparison predicate>
    comparison predicate <predicate>
    concatenation <character value expression>
    concatenation operator <bit concatenation> <concatenation> <delimiter token>
    condition <embedded exception condition>
    condition action <embedded exception condition>
    condition information <sql diagnostics information>
    condition information item <condition information>
    condition information item name <condition information item>
    condition number <condition information>
    connect statement <SQL connection statement>
    connection name <connection object> <connection target>
    connection object <disconnect object> <set connection statement>
    connection target <connect statement>
    constraint attributes <assertion definition> <column constraint definition> <domain constraint>
    constraint check time <constraint attributes> <table constraint definition>
    constraint name <assertion definition> <constraint name definition> <constraint name list> <drop assertion statement> <drop domain constraint definition> <drop table constraint definition>
    constraint name definition <column constraint definition> <domain constraint> <table constraint definition>
    constraint name list <set constraints mode statement>
    correlation name <correlation specification> <qualifier>
    correlation specification <table reference>
    corresponding column list <corresponding spec>
    corresponding spec <non-join query expression> <non-join query term>
    cross join <joined table>
    current date value function <datetime value function>
    current time value function <datetime value function>
    current timestamp value function <datetime value function>
    cursor name <close statement> <declare cursor> <delete statement: positioned> <dynamic cursor name> <dynamic declare cursor> <fetch statement> <open statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned>
    cursor specification <declare cursor> <dynamic select statement>
    data type <column definition> <domain definition> <parameter declaration>
    date literal <datetime literal>
    date string <date literal> <delimiter token>
    date value <date string> <timestamp string>
    datetime factor <datetime term>
    datetime field <extract field>
    datetime literal <general literal>
    datetime primary <datetime factor>
    datetime term <datetime value expression> <interval value expression>
    datetime type <data 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 <interval string>
    days value <date value> <day-time interval>
    deallocate descriptor statement <system descriptor statement>
    deallocate prepared statement <SQL dynamic statement>
    declare cursor <module contents> <statement or declaration>
    default clause <column definition> <domain definition> <set column default clause> <set domain default clause>
    default option <default clause>
    default specification <row value constructor element>
    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>
    derived column <select sublist>
    derived column list <correlation specification>
    derived table <table reference>
    describe input statement <describe statement>
    describe output statement <describe statement>
    descriptor item name <get item information> <set item information>
    descriptor name <allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <set descriptor statement> <using descriptor>
    desribe statement <SQL dynamic statement>
    diagnostics size <transaction mode>
    digit <hexit> <identifier part> <SQL language character> <SQL language identifier part> <unsigned integer>
    direct implementation-defined statement <direct SQL statement>
    direct select statement: multiple rows <direct SQL data statement>
    direct SQL data statement <direct SQL statement>
    disconnect object <disconnect statement>
    disconnect statement <SQL connection statement>
    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 period <Ada qualified type specification> <Ada unqualified type specification> <delimiter token>
    double quote <delimited identifier> <doublequote symbol> <SQL special character>
    doublequote symbol <delimited identifier part>
    drop assertion statement <SQL schema manipulation statement>
    drop behaviour <drop column definition> <drop domain statement> <drop schema statement> <drop table constraint definition> <drop table statement> <drop view statement> <revoke 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 domain constraint definition <alter domain action>
    drop domain default clause <alter domain action>
    drop domain 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 translation 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>
    dynamic select statement <preparable SQL data statement>
    dynamic single row select statement <preparable SQL data statement>
    dynamic update statement: positioned <SQL dynamic data statement>
    else clause <searched case> <simple case>
    embedded character set declaration <embedded SQL declare section> <embedded SQL MUMPS declare>
    embedded exception declaration <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 variable name <indicator variable> <simple target specification> <simple value specification> <variable specification>
    end field <interval qualifier>
    equals operator <Ada assignment operator> <C initial value> <comp op> <condition information item> <get count> <get item information> <set clause> <set count> <set item information> <SQL special character> <statement information item>
    escape character <like predicate>
    exact numeric literal <mantissa> <unsigned numeric literal>
    exact numeric type <numeric type>
    execute immediate statement <SQL dynamic statement>
    execute statement <SQL dynamic statement>
    existing character set name <character set source>
    exists predicate <predicate>
    explicit table <simple table>
    exponent <approximate numeric literal>
    extended cursor name <allocate cursor statement> <dynamic cursor name>
    extended statement name <allocate cursor statement> <SQL statement name>
    external collation <collating sequence definition>
    external collation name <external collation>
    external translation <translation specification>
    external translation name <external translation>
    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>
    fold <character value function>
    form-of-use conversion <character value function>
    form-of-use conversion name <form-of-use conversion>
    Fortran host identifier <host identifier>
    Fortran variable definition <host variable definition>
    from clause <table expression>
    general literal <literal> <unsigned literal>
    general set function <set function specification>
    general value specification <unsigned value specification> <value specification>
    get count <get descriptor information>
    get descriptor information <get descriptor statement>
    get descriptor statement <system descriptor statement>
    get diagnostics statement <SQL diagnostics statement>
    get item information <get descriptor information>
    go to <condition action>
    goto target <go to>
    grant statement <schema element> <SQL schema definition statement>
    grantee <grant statement> <revoke statement>
    greater than operator <comp op> <SQL special character>
    greater than or equals operator <comp op> <delimiter token>
    group by clause <table expression>
    grouping column reference <grouping column reference list>
    grouping column reference list <group by clause>
    having clause <table expression>
    hex string literal <general literal> <nondelimiter token>
    hexit <hex string literal>
    high <SQL conformance>
    host identifier <embedded variable name>
    host label identifier <goto target>
    host PL/I label variable <goto target>
    host variable definition <embedded SQL declare section> <embedded SQL MUMPS declare>
    hours value <day-time interval> <time value> <time zone interval> <time-interval>
    identifier <authorization identifier> <catalog name> <column name> <correlation name> <cursor name> <module name> <parameter name> <procedure name> <qualified identifier> <statement name> <unqualified schema name>
    identifier body <regular identifier>
    identifier part <identifier body>
    identifier start <identifier body> <identifier part>
    implementation-defined character repertoire name <character set specification> <existing character set name>
    implementation-defined collation name <external collation name>
    implementation-defined translation name <external translation name>
    implementation-defined universal character form-of-use name <character set specification>
    in predicate <predicate>
    in predicate value <in predicate>
    in value list <in predicate value>
    indicator parameter <parameter specification>
    indicator variable <variable specification>
    insert column list <insert columns and source>
    insert columns and source <insert statement>
    insert statement <direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
    integrity no <1989 package>
    integrity yes <1989 package>
    intermediate <SQL conformance>
    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>
    interval qualifier <interval literal> <interval primary> <interval type> <interval value expression>
    interval string <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 <data type>
    interval value expression <datetime value expression> <extract source> <interval value expression 1> <set time zone value> <time zone specifier> <value expression>
    interval value expression 1 <interval value expression>
    introducer <character string literal> <identifier>
    isolation level <transaction mode>
    item number <get descriptor information> <set descriptor information>
    join column list <named columns join>
    join condition <join specification>
    join specification <qualified join>
    join type <qualified join>
    joined table <joined table> <query expression> <query primary> <query term> <table reference>
    key word <nondelimiter token>
    language clause <module>
    language name <language clause>
    left bracket <C array specification> <delimiter token> <SQL embedded language character>
    left paren <1987> <1989 base> <1992> <action> <Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <arc1> <arc2> <assertion check> <bit length expression> <bit string type> <bit substring function> <boolean primary> <case abbreviation> <cast specification> <char length expression> <character string type> <character substring function> <character translation> <check constraint definition> <collating sequence definition> <correlation specification> <corresponding spec> <current time value function> <current timestamp value function> <datetime type> <end field> <exact numeric type> <external collation> <external translation> <extract expression> <fold> <form-of-use conversion> <general set function> <high> <in predicate value> <insert columns and source> <integrity no> <integrity yes> <intermediate> <interval value expression> <joined table> <low> <named columns join> <national character string type> <non-join query primary> <octet length expression> <parameter declaration list> <position expression> <referenced table and columns> <referential constraint definition> <row value constructor> <set function specification> <single datetime field> <SQL prefix> <SQL special character> <start field> <subquery> <table element list> <trim function> <unique constraint definition> <value expression primary> <view definition>
    length <Ada qualified type specification> <Ada unqualified type specification> <bit string type> <C array specification> <character string type> <national character string type>
    length expression <numeric value function>
    less than operator <comp op> <SQL special character>
    less than or equals operator <comp op> <delimiter token>
    level of isolation <isolation level>
    levels clause <view definition>
    like predicate <predicate>
    limited collation definition <character set definition>
    literal <default option> <simple value specification> <value specification>
    local table name <qualified local table name>
    low <SQL conformance>
    mantissa <approximate numeric literal>
    match predicate <predicate>
    match type <references specification>
    match value <like predicate>
    minus sign <comment introducer> <date value> <datetime value expression> <interval value expression> <numeric value expression> <sign> <SQL special character> <year-month literal>
    minutes value <day-time interval> <time value> <time zone interval> <time-interval>
    module authorization clause <module>
    module authorization identifier <module authorization clause>
    module character set specification <module name clause>
    module contents <module>
    module name <module name clause>
    module name clause <module>
    months value <date value> <year-month literal>
    MUMPS host identifier <host identifier>
    MUMPS variable definition <host variable definition>
    named columns join <join specification>
    national character string literal <general literal> <nondelimiter token>
    national character string type <data type>
    newline <comment> <separator>
    non-join query expression <non-join query primary> <query expression>
    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 datetime field <datetime field> <end field> <single datetime field> <start field>
    nondelimiter token <token>
    nondoublequote character <delimited identifier part>
    nonquote character <character representation> <comment character>
    not equals operator <comp op> <delimiter token>
    null predicate <predicate>
    null specification <row value constructor element> <update source>
    number of conditions <diagnostics size>
    numeric primary <factor>
    numeric type <data type>
    numeric value expression <numeric value expression> <start position> <string length> <value expression>
    numeric value function <numeric primary>
    object column <set clause>
    object name <grant statement> <revoke statement>
    occurrences <allocate descriptor statement>
    octet length expression <length expression>
    open statement <SQL data statement>
    order by clause <cursor specification> <direct select statement: multiple rows>
    ordering specification <sort specification>
    outer join type <join type>
    overlaps predicate <predicate>
    pad attribute <collation definition>
    parameter declaration <parameter declaration list>
    parameter declaration list <procedure>
    parameter name <indicator parameter> <parameter declaration> <parameter specification> <simple target specification> <simple value specification>
    parameter specification <general value specification> <target specification>
    parameter using clause <execute statement>
    Pascal host identifier <host identifier>
    Pascal variable definition <host variable definition>
    pattern <like predicate>
    percent <SQL special character>
    period <character set name> <column reference> <exact numeric literal> <qualified local table name> <qualified name> <schema name> <seconds value> <select sublist> <SQL special character>
    PL/I host identifier <host identifier>
    PL/I variable definition <host variable definition>
    plus sign <datetime value expression> <interval value expression> <numeric value expression> <sign> <SQL special character>
    position expression <numeric value function>
    precision <exact numeric type>
    predicate <boolean primary>
    preparable dynamic delete statement: positioned <preparable SQL data statement>
    preparable dynamic update statement: positioned <preparable SQL data statement>
    preparable SQL data statement <preparable statement>
    preparable SQL implementation-defined 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>
    privilege column list <action>
    privileges <grant statement> <revoke statement>
    procedure <module contents>
    procedure name <procedure>
    qualified identifier <local table name> <qualified name>
    qualified join <joined table>
    qualified local table name <table name> <temporary table declaration>
    qualified name <collation name> <constraint name> <domain name> <form-of-use conversion name> <table name> <translation name>
    qualifier <column reference> <select sublist>
    quantified comparison predicate <predicate>
    quantifier <quantified comparison predicate>
    query expression <cursor specification> <direct select statement: multiple rows> <insert columns and source> <non-join query expression> <subquery> <view definition>
    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> <SQL special character>
    quote <bit string literal> <character string literal> <comment character> <date string> <external collation> <external translation> <hex string literal> <interval string> <national character string literal> <quote symbol> <SQL special character> <time string> <timestamp string>
    quote symbol <character representation>
    reference column list <referenced table and columns> <referencing columns>
    referenced table and columns <references specification>
    references specification <column constraint> <referential constraint definition>
    referencing columns <referential constraint definition>
    referential action <delete rule> <update rule>
    referential constraint definition <table constraint>
    referential triggered action <references specification>
    regular identifier <actual identifier> <nondelimiter token>
    reserved word <key word>
    result <else clause> <searched when clause> <simple when clause>
    result expression <result>
    result using clause <execute statement>
    revoke statement <SQL schema manipulation statement>
    right bracket <C array specification> <delimiter token> <SQL embedded language character>
    right paren <1987> <1989 base> <1992> <action> <Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <arc1> <arc2> <assertion check> <bit length expression> <bit string type> <bit substring function> <boolean primary> <case abbreviation> <cast specification> <char length expression> <character string type> <character substring function> <character translation> <check constraint definition> <collating sequence definition> <correlation specification> <corresponding spec> <current time value function> <current timestamp value function> <datetime type> <end field> <exact numeric type> <external collation> <external translation> <extract expression> <fold> <form-of-use conversion> <general set function> <high> <in predicate value> <insert columns and source> <integrity no> <integrity yes> <intermediate> <interval value expression> <joined table> <low> <named columns join> <national character string type> <non-join query primary> <octet length expression> <parameter declaration list> <position expression> <referenced table and columns> <referential constraint definition> <row value constructor> <set function specification> <single datetime field> <SQL special character> <SQL terminator> <start field> <subquery> <table element list> <trim function> <unique constraint definition> <value expression primary> <view definition>
    rollback statement <SQL transaction statement>
    row subquery <row value constructor>
    row value constructor <between predicate> <comparison predicate> <in predicate> <match predicate> <row value constructor 1> <row value constructor 2> <table value constructor list>
    row value constructor 1 <overlaps predicate>
    row value constructor 2 <overlaps predicate>
    row value constructor element <row value constructor> <row value constructor list>
    row value constructor list <row value constructor>
    row value constuctor <quantified comparison predicate>
    scalar subquery <value expression primary>
    scale <exact numeric type>
    schema authorization identifier <schema name clause>
    schema character set name <existing character set name>
    schema character set specification <schema definition>
    schema collation name <collating sequence definition>
    schema definition <SQL schema definition statement>
    schema element <schema definition>
    schema name <character set name> <drop schema statement> <module authorization clause> <qualified name> <schema name clause>
    schema name clause <schema definition>
    schema translation name <translation specification>
    scope option <descriptor name> <extended cursor name> <extended statement name>
    search condition <assertion check> <boolean primary> <check constraint definition> <delete statement: searched> <having clause> <join condition> <search condition> <searched when clause> <update statement: searched> <where clause>
    searched case <case specification>
    searched when clause <searched case>
    seconds fraction <seconds value>
    seconds integer value <seconds value>
    seconds value <day-time interval> <time value> <time-interval>
    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>
    semicolon <C variable definition> <procedure> <SQL special character> <SQL terminator>
    separator <bit string literal> <character string literal> <hex string literal> <national character string literal>
    set catalog statement <SQL session statement>
    set clause <dynamic update statement: positioned> <preparable dynamic update statement: positioned> <set clause list>
    set clause list <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 count <set descriptor information>
    set descriptor information <set descriptor statement>
    set descriptor statement <system descriptor statement>
    set domain default clause <alter domain action>
    set function specification <value expression primary>
    set function type <general set function>
    set item information <set descriptor information>
    set local time zone statement <SQL session statement>
    set names statement <SQL session statement>
    set quantifier <general set function> <query specification> <select statement: single row>
    set schema statement <SQL session statement>
    set session authorization identifier statement <SQL session statement>
    set time zone value <set local time zone statement>
    set transaction statement <SQL transaction statement>
    sign <factor> <interval factor> <interval literal> <signed integer> <signed numeric literal> <time zone interval>
    signed integer <exponent>
    signed numeric literal <literal>
    simple case <case specification>
    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>
    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 count>
    simple target specification 2 <get item information>
    simple value specification <condition number> <connection name> <descriptor name> <extended cursor name> <extended statement name> <fetch orientation> <item number> <number of conditions> <occurrences> <simple value specification 1> <simple value specification 2> <SQL statement variable> <SQL-server name> <user name>
    simple value specification 1 <set count>
    simple value specification 2 <set item information>
    simple when clause <simple case>
    single datetime field <interval qualifier>
    solidus <interval term> <SQL special character> <term>
    some <quantifier>
    sort key <sort specification>
    sort specification <sort specification list>
    sort specification list <order by clause>
    source character set specification <translation definition>
    space <day-time interval> <separator> <SQL special character> <timestamp string>
    SQL conformance <SQL variant>
    SQL connection statement <direct SQL statement> <SQL procedure statement>
    SQL data change statement <SQL data statement>
    SQL data statement <SQL procedure statement>
    sql diagnostics information <get diagnostics statement>
    SQL diagnostics statement <SQL procedure statement>
    SQL dynamic data statement <SQL dynamic statement>
    SQL dynamic statement <SQL procedure statement>
    SQL edition <SQL variant>
    SQL embedded language character <SQL terminal character>
    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 prefix <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
    SQL procedure statement <procedure> <statement or declaration>
    SQL provenance <SQL object identifier>
    SQL schema definition statement <SQL schema statement>
    SQL schema manipulation statement <SQL schema statement>
    SQL schema statement <direct SQL statement> <preparable SQL schema statement> <SQL procedure statement>
    SQL session stateament <direct SQL statement>
    SQL session statement <preparable SQL session statement> <SQL procedure statement>
    SQL special character <delimiter token> <SQL language character>
    SQL statement name <deallocate prepared statement> <describe input statement> <describe output statement> <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 <direct SQL statement> <preparable SQL transaction statement> <SQL procedure statement>
    SQL variant <SQL object identifier>
    SQL-server name <connection target>
    standard character repertoire name <character set specification> <existing character set name>
    standard collation name <external collation name>
    standard translation name <external translation name>
    standard universal character form-of-use name <character set specification>
    start field <interval qualifier>
    start position <bit substring function> <character substring function>
    statement information <sql diagnostics information>
    statement information item <statement information>
    statement information item name <statement information item>
    statement name <dynamic declare cursor> <SQL statement name>
    statement or declaration <embedded SQL statement>
    status parameter <parameter declaration>
    string length <bit substring function> <character substring function>
    string value expression <bit length expression> <char length expression> <octet length expression> <value expression>
    string value function <bit primary> <character primary>
    subquery <row subquery> <scalar subquery> <table subquery>
    system descriptor statement <SQL dynamic statement>
    table constraint <table constraint definition>
    table constraint definition <add table constraint definition> <table element>
    table definition <schema element> <SQL schema definition statement>
    table element <table element list>
    table element list <table definition> <temporary table declaration>
    table expression <query specification> <select statement: single row>
    table name <alter table statement> <delete statement: positioned> <delete statement: searched> <drop table statement> <drop view statement> <dynamic delete statement: positioned> <dynamic update statement: positioned> <explicit table> <insert statement> <object name> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <qualifier> <referenced table and columns> <table definition> <table reference> <update statement: positioned> <update statement: searched> <view definition>
    table reference <cross join> <from clause> <qualified join>
    table subquery <derived table> <exists predicate> <in predicate value> <match predicate> <quantified comparison predicate> <unique predicate>
    table value constructor <simple table>
    table value constructor list <table value constructor>
    target character set specification <translation definition>
    target specification <argument> <fetch target list> <select target list>
    temporary table declaration <direct SQL data statement> <module> <statement or declaration>
    term <interval term> <numeric value expression> <term>
    time fractional seconds precision <time precision> <timestamp precision>
    time interval <day-time literal>
    time literal <datetime literal>
    time precision <current time value function> <datetime type>
    time string <delimiter token> <time literal>
    time value <time string> <timestamp string>
    time zone <datetime factor>
    time zone field <extract field>
    time zone interval <time string> <timestamp string>
    time zone specifier <time zone>
    timestamp literal <datetime literal>
    timestamp precision <current timestamp value function> <datetime type>
    timestamp string <delimiter token> <timestamp literal>
    transaction access mode <transaction mode>
    transaction mode <set transaction statement>
    translation collation <collation source>
    translation definition <schema element> <SQL schema definition statement>
    translation name <character translation> <drop translation statement> <implementation-defined translation name> <object name> <schema translation name> <standard translation name> <translation collation> <translation definition>
    translation source <translation definition>
    translation specification <translation source>
    trim character <trim operands>
    trim function <character value function>
    trim operands <trim function>
    trim source <trim operands>
    trim specification <trim operands>
    truth value <boolean test>
    type name <cast target>
    underscore <identifier body> <introducer> <SQL language identifier> <SQL special character>
    unique column list <unique constraint definition>
    unique constraint definition <table constraint>
    unique specification <column constraint> <unique constraint definition>
    unqualified schema name <schema name>
    unsigned integer <datetime value> <exact numeric literal> <goto target> <interval fractional seconds precision> <interval leading field precision> <length> <precision> <scale> <seconds fraction> <seconds integer value> <signed integer> <sort key> <time fractional seconds precision>
    unsigned literal <unsigned value specification>
    unsigned numeric literal <nondelimiter token> <signed numeric literal> <unsigned literal>
    unsigned value specification <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>
    user name <connection target>
    user-defined character repertoire name <character set specification>
    using arguments <using clause>
    using clause <dynamic open statement> <parameter using clause> <result using clause>
    using descriptor <describe input statement> <describe output statement> <using clause>
    value expression <case abbreviation> <case operand> <cast operand> <derived column> <general set function> <in value list> <result expression> <row value constructor element> <update source> <value expression primary> <when operand>
    value expression primary <bit primary> <character primary> <datetime primary> <interval primary> <numeric primary>
    value specification <set catalog statement> <set names statement> <set schema statement> <set session authorization identifier statement>
    variable specification <general value specification> <target specification>
    vertical bar <SQL special character>
    view column list <view definition>
    view definition <schema element> <SQL schema definition statement>
    when operand <simple when clause>
    where clause <table expression>
    year-month literal <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
    ABSOLUTE <fetch orientation> <reserved word>
    ACTION <referential action> <reserved word>
    action <action list>
    ADA <language name> <non-reserved word>
    ADD <add column definition> <add domain constraint definition> <add table constraint definition> <reserved word>
    ALL <all> <constraint name list> <disconnect object> <non-join query expression> <non-join query term> <privileges> <reserved word> <set quantifier>
    ALLOCATE <allocate cursor statement> <allocate descriptor statement> <reserved word>
    ALTER <alter column definition> <alter domain statement> <alter table statement> <reserved word>
    amp <ampersand>
    AND <between predicate> <boolean term> <reserved word>
    ANY <reserved word> <some>
    ARE <embedded character set declaration> <module character set specification> <reserved word>
    AS <as clause> <cast specification> <character set definition> <connection target> <correlation specification> <domain definition> <reserved word> <view definition>
    ASC <ordering specification> <reserved word>
    ASSERTION <assertion definition> <drop assertion statement> <reserved word>
    AT <reserved word> <time zone>
    AUTHORIZATION <module authorization clause> <reserved word> <schema name clause> <set session authorization identifier statement>
    auto <C storage class>
    AVG <reserved word> <set function type>
    BEGIN <embedded SQL begin declare> <embedded SQL MUMPS declare> <reserved word>
    BETWEEN <between predicate> <reserved word>
    BIT <Ada qualified type specification> <Ada unqualified type specification> <bit string type> <C bit variable> <reserved word>
    BIT_LENGTH <bit length expression> <reserved word>
    BOTH <reserved word> <trim specification>
    BY <corresponding spec> <group by clause> <order by clause> <reserved word>
    C <hexit> <language name> <non-reserved word> <simple Latin upper case letter>
    CASCADE <drop behaviour> <referential action> <reserved word>
    CASCADED <levels clause> <reserved word>
    CASE <reserved word> <searched case> <simple case>
    CAST <cast specification> <reserved word>
    CATALOG <reserved word> <set catalog statement>
    CATALOG_NAME <condition information item name> <non-reserved word>
    char <C character variable>
    CHAR <Ada qualified type specification> <Ada unqualified type specification> <character string type> <national character string type> <reserved word>
    CHARACTER <Ada qualified type specification> <C character variable> <C VARCHAR variable> <character set definition> <character string type> <data type> <drop character set statement> <national character string type> <object name> <reserved word> <schema character set specification>
    CHARACTER_LENGTH <char length expression> <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> <reserved word>
    CHECK <assertion check> <check constraint definition> <reserved word> <view definition>
    CLASS_ORIGIN <condition information item name> <non-reserved word>
    CLOSE <close statement> <dynamic close statement> <reserved word>
    COALESCE <case abbreviation> <reserved word>
    COBOL <language name> <non-reserved word>
    COLLATE <collate clause> <reserved word>
    COLLATION <collation definition> <drop collation statement> <limited collation definition> <object name> <reserved word> <translation collation>
    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>
    COLUMN_NAME <condition information item name> <non-reserved word>
    COMMAND_FUNCTION <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_NUMBER <condition information item name> <non-reserved word>
    CONNECT <connect statement> <reserved word>
    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>
    CONSTRAINTS <reserved word> <set constraints mode statement>
    CONSTRAINT_CATALOG <non-reserved word>
    CONSTRAINT_NAME <condition information item name> <non-reserved word>
    CONSTRAINT_SCHEMA <condition information item name> <non-reserved word>
    CONSTRATIN_CATALOG <condition information item name>
    CONTINUE <condition action> <reserved word>
    CONVERT <form-of-use conversion> <reserved word>
    CORRESPONDING <corresponding spec> <reserved word>
    COUNT <get count> <set count> <set function specification> <set function type>
    CREATE <assertion definition> <character set definition> <collation definition> <domain definition> <reserved word> <schema definition> <table definition> <translation definition> <view definition>
    CROSS <cross join> <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_TIME <current time value function> <reserved word>
    CURRENT_TIMESTAMP <current timestamp value function> <reserved word>
    CURRENT_USER <default option> <general value specification> <reserved word>
    CURSOR <allocate cursor statement> <declare cursor> <dynamic declare cursor> <reserved word>
    CURSOR_NAME <condition information item name> <non-reserved word>
    DATA <descriptor item name> <non-reserved word>
    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 datetime field> <reserved word>
    DEALLOCATE <deallocate descriptor statement> <deallocate prepared statement> <reserved word>
    DEC <exact numeric type> <reserved word>
    DECIMAL <exact numeric type> <reserved word>
    DECLARE <declare cursor> <dynamic declare cursor> <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <reserved word> <temporary table declaration>
    DEFAULT <collating sequence definition> <connection object> <connection target> <default clause> <default specification> <drop column default clause> <drop domain default clause> <insert columns and source> <referential action> <reserved word> <schema character set specification> <update source>
    DEFERRABLE <constraint attributes> <reserved word>
    DEFERRED <constraint check time> <reserved word> <set constraints mode statement>
    DELETE <action> <delete rule> <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <preparable dynamic delete statement: positioned> <reserved word> <table definition> <temporary table declaration>
    DESC <collating sequence definition> <ordering specification> <reserved word>
    DESCRIBE <describe input statement> <describe output statement> <reserved word>
    DESCRIPTOR <allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <reserved word> <set descriptor statement> <using descriptor>
    DIAGNOSTICS <diagnostics size> <get diagnostics statement> <reserved word>
    DISCONNECT <disconnect statement> <reserved word>
    DISTINCT <reserved word> <set quantifier>
    DOMAIN <alter domain statement> <domain definition> <drop domain statement> <object name> <reserved word>
    DOUBLE <approximate numeric type> <reserved word>
    double <C numeric variable>
    DOUBLE_PRECISION <Ada qualified type specification> <Ada unqualified type specification>
    DROP <drop assertion statement> <drop character set statement> <drop collation statement> <drop column default clause> <drop column definition> <drop domain constraint definition> <drop domain default clause> <drop domain statement> <drop schema statement> <drop table constraint definition> <drop table statement> <drop translation statement> <drop view statement> <reserved word>
    DYNAMIC_FUNCTION <non-reserved word> <statement information item name>
    edition1987 <1987>
    edition1989 <1989 base>
    edition1992 <1992>
    ELSE <else clause> <reserved word>
    END <embedded SQL end declare> <embedded SQL MUMPS declare> <reserved word> <searched case> <simple case>
    END-EXEC <reserved word> <SQL terminator>
    ESCAPE <like predicate> <reserved word>
    EXCEPT <non-join query expression> <reserved word>
    EXCEPTION <condition information> <reserved word>
    EXEC <reserved word> <SQL prefix>
    EXECUTE <execute immediate statement> <execute statement> <reserved word>
    EXISTS <exists predicate> <reserved word>
    extern <C storage class>
    EXTERNAL <external collation> <external translation> <reserved word>
    EXTRACT <extract expression> <reserved word>
    FALSE <reserved word> <truth value>
    FETCH <dynamic fetch statement> <fetch statement> <reserved word>
    FIRST <fetch orientation> <reserved word>
    float <C numeric variable>
    FLOAT <approximate numeric type> <reserved word>
    FOR <allocate cursor statement> <bit substring function> <character substring function> <collation definition> <declare cursor> <dynamic declare cursor> <reserved word> <revoke statement> <translation definition> <updatability clause>
    FOREIGN <referential constraint definition> <reserved word>
    FORTRAN <language name> <non-reserved word>
    FOUND <condition> <reserved word>
    FROM <bit substring function> <character substring function> <collation definition> <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <dynamic fetch statement> <extract expression> <fetch statement> <from clause> <limited collation definition> <preparable dynamic delete statement: positioned> <prepare statement> <reserved word> <revoke statement> <translation definition> <trim operands>
    FULL <match predicate> <match type> <outer join type> <reserved word>
    GET <character set source> <get descriptor statement> <get diagnostics statement> <reserved word>
    GLOBAL <reserved word> <scope option> <table definition>
    GO <go to> <reserved word>
    GOTO <go to> <reserved word>
    GRANT <grant statement> <reserved word> <revoke statement>
    GROUP <group by clause> <reserved word>
    gt <action list> <greater than operator> <greater than or equals operator> <not equals operator>
    HAVING <having clause> <reserved word>
    High <high>
    HOUR <non-second datetime field> <reserved word>
    IDENTITY <reserved word> <translation specification>
    IMMEDIATE <constraint check time> <execute immediate statement> <reserved word> <set constraints mode statement>
    IN <in predicate> <position expression> <reserved word>
    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>
    INPUT <describe input statement> <reserved word>
    INSENSITIVE <allocate cursor statement> <declare cursor> <dynamic declare cursor> <reserved word>
    INSERT <action> <insert statement> <reserved word>
    INT <Ada qualified type specification> <Ada unqualified type specification> <exact numeric type> <reserved word>
    INTEGER <exact numeric type> <reserved word>
    IntegrityNo <integrity no>
    IntegrityYes <integrity yes>
    Intermediate <intermediate>
    INTERSECT <non-join query term> <reserved word>
    INTERVAL <interval literal> <interval type> <reserved word>
    INTO <fetch statement> <insert statement> <reserved word> <select statement: single row> <using arguments> <using descriptor>
    IS <Ada qualified type specification> <boolean test> <C character variable> <C VARCHAR variable> <null predicate> <reserved word>
    iso <arc1>
    ISOLATION <isolation level> <reserved word>
    JOIN <cross join> <qualified join> <reserved word>
    KEY <referential constraint definition> <reserved word> <unique specification>
    LANGUAGE <language clause> <reserved word>
    LAST <fetch orientation> <reserved word>
    LEADING <reserved word> <trim specification>
    LEFT <outer join type> <reserved word>
    LENGTH <descriptor item name> <non-reserved word>
    LEVEL <isolation level> <reserved word>
    LIKE <like predicate> <reserved word>
    LOCAL <levels clause> <reserved word> <scope option> <set time zone value> <table definition> <temporary table declaration> <time zone specifier>
    long <C numeric variable>
    Low <low>
    LOWER <fold> <reserved word>
    lt <approximate numeric type> <less than operator> <less than or equals operator> <not equals operator>
    MATCH <match predicate> <references specification> <reserved word>
    MAX <allocate descriptor statement> <reserved word> <set function type>
    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>
    MIN <reserved word> <set function type>
    MINUTE <non-second datetime field> <reserved word>
    MODULE <module name clause> <qualified local table name> <reserved word>
    MONTH <non-second datetime field> <reserved word>
    MORE <non-reserved word> <statement information item name>
    MUMPS <language name> <non-reserved word>
    NAME <descriptor item name> <non-reserved word>
    NAMES <embedded character set declaration> <module character set specification> <reserved word> <set names statement>
    NATIONAL <national character string type> <reserved word>
    NATURAL <qualified join> <reserved word>
    NCHAR <national character string type> <reserved word>
    NEXT <fetch orientation> <reserved word>
    NO <pad attribute> <referential action> <reserved word>
    NOT <between predicate> <boolean factor> <boolean test> <column constraint> <condition> <constraint attributes> <in predicate> <like predicate> <null predicate> <reserved word>
    NULL <cast operand> <column constraint> <default option> <null predicate> <null specification> <referential action> <reserved word> <result>
    NULLABLE <descriptor item name> <non-reserved word>
    NULLIF <case abbreviation> <reserved word>
    NUMBER <non-reserved word> <statement information item name>
    NUMERIC <exact numeric type> <reserved word>
    OCTET_LENGTH <descriptor item name> <octet length expression> <reserved word>
    OF <delete statement: positioned> <dynamic delete statement: positioned> <dynamic update statement: positioned> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <updatability clause> <update statement: positioned>
    omitted <Cobol variable definition> <Fortran variable definition> <MUMPS variable definition> <Pascal variable definition> <PL/I variable definition>
    ON <delete rule> <grant statement> <join condition> <reserved word> <revoke statement> <table definition> <temporary table declaration> <update rule>
    ONLY <reserved word> <transaction access mode> <updatability clause>
    OPEN <dynamic open statement> <open statement> <reserved word>
    OPTION <grant statement> <reserved word> <revoke statement> <view definition>
    OR <reserved word> <search condition>
    ORDER <order by clause> <reserved word>
    OUTER <join type> <reserved word>
    OUTPUT <describe output statement> <reserved word>
    OVERLAPS <overlaps predicate> <reserved word>
    PAD <pad attribute> <reserved word>
    PARTIAL <match predicate> <match type> <reserved word>
    PASCAL <language name> <non-reserved word>
    PLI <language name> <non-reserved word>
    POSITION <position expression> <reserved word>
    precision <approximate numeric type>
    PRECISION <approximate numeric type> <descriptor item name> <reserved word>
    PREPARE <deallocate prepared statement> <prepare statement> <reserved word>
    PRESERVE <reserved word> <table definition> <temporary table declaration>
    PRIMARY <reserved word> <unique specification>
    PRIOR <fetch orientation> <reserved word>
    PRIVILEGES <privileges> <reserved word>
    PROCEDURE <procedure> <reserved word>
    PUBLIC <reserved word>
    READ <level of isolation> <reserved word> <transaction access mode> <updatability clause>
    REAL <Ada qualified type specification> <Ada unqualified type specification> <approximate numeric type> <reserved word>
    REFERENCES <action> <references specification> <reserved word>
    RELATIVE <fetch orientation> <reserved word>
    REPEATABLE <level of isolation> <non-reserved word>
    RESTRICT <drop behaviour> <reserved word>
    RETURNED_LENGTH <descriptor item name> <non-reserved word>
    RETURNED_OCTET_LENGTH <descriptor item name> <non-reserved word>
    RETURNED_SQLSTATE <condition information item name> <non-reserved word>
    REVOKE <reserved word> <revoke statement>
    RIGHT <outer join type> <reserved word>
    ROLLBACK <reserved word> <rollback statement>
    ROWS <reserved word> <table definition> <temporary table declaration>
    ROW_COUNT <non-reserved word> <statement information item name>
    SCALE <descriptor item name> <non-reserved word>
    SCHEMA <drop schema statement> <module authorization clause> <reserved word> <schema definition> <set schema statement>
    SCHEMA_NAME <condition information item name> <non-reserved word>
    SCROLL <allocate cursor statement> <declare cursor> <dynamic declare cursor> <reserved word>
    SECOND <datetime field> <end field> <reserved word> <single datetime field>
    SECTION <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <reserved word>
    SELECT <action> <query specification> <reserved word> <select statement: single row>
    SERIALIZABLE <level of isolation> <non-reserved word>
    SERVER_NAME <condition information item name> <non-reserved word>
    SESSION <reserved word> <set session authorization identifier statement>
    SESSION_USER <default option> <general value specification> <reserved word>
    SET <Ada qualified type specification> <C character variable> <C VARCHAR variable> <character set definition> <data type> <drop character set statement> <dynamic update statement: positioned> <object name> <preparable dynamic update statement: positioned> <referential action> <reserved word> <schema character set specification> <set catalog statement> <set column default clause> <set connection statement> <set constraints mode statement> <set descriptor statement> <set domain default clause> <set local time zone statement> <set names statement> <set schema statement> <set session authorization identifier statement> <set transaction statement> <update statement: positioned> <update statement: searched>
    short <C numeric variable>
    SIZE <diagnostics size> <reserved word>
    SMALLINT <Ada qualified type specification> <Ada unqualified type specification> <exact numeric type> <reserved word>
    SOME <reserved word> <some>
    SPACE <pad attribute> <reserved word>
    SQL <embedded character set declaration> <reserved word> <SQL prefix> <using descriptor>
    SQLCODE <reserved word> <status parameter>
    SQLCODE_TYPE <Ada qualified type specification> <Ada unqualified type specification>
    SQLERROR <condition> <reserved word>
    SQLSTATE <reserved word> <status parameter>
    SQLSTATE_TYPE <Ada qualified type specification> <Ada unqualified type specification>
    SQL_STANDARD <Ada qualified type specification>
    standard <arc2>
    static <C storage class>
    SUBCLASS_ORIGIN <condition information item name> <non-reserved word>
    SUBSTRING <bit substring function> <character substring function> <reserved word>
    SUM <reserved word> <set function type>
    SYSTEM_USER <default option> <general value specification> <reserved word>
    TABLE <alter table statement> <drop table statement> <explicit table> <object name> <reserved word> <table definition> <temporary table declaration>
    TABLE_NAME <condition information item name> <non-reserved word>
    TEMPORARY <reserved word> <table definition> <temporary table declaration>
    THEN <reserved word> <searched when clause> <simple when clause> <translation collation>
    TIME <datetime type> <reserved word> <set local time zone statement> <time literal> <time zone specifier>
    TIMESTAMP <datetime type> <reserved word> <timestamp literal>
    TIMEZONE_HOUR <reserved word> <time zone field>
    TIMEZONE_MINUTE <reserved word> <time zone field>
    TO <connect statement> <go to> <grant statement> <interval qualifier> <reserved word> <translation definition>
    TRAILING <reserved word> <trim specification>
    TRANSACTION <reserved word> <set transaction statement>
    TRANSLATE <character translation> <reserved word>
    TRANSLATION <drop translation statement> <object name> <reserved word> <translation collation> <translation definition>
    TRIM <reserved word> <trim function>
    TRUE <reserved word> <truth value>
    TYPE <descriptor item name> <non-reserved word>
    UNCOMMITTED <level of isolation> <non-reserved word>
    UNION <join type> <non-join query expression> <reserved word>
    UNIQUE <match predicate> <reserved word> <unique predicate> <unique specification>
    UNKNOWN <reserved word> <truth value>
    UNNAMED <descriptor item name> <non-reserved word>
    UPDATE <action> <dynamic update statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <updatability clause> <update rule> <update statement: positioned> <update statement: searched>
    UPPER <fold> <reserved word>
    USAGE <action> <reserved word>
    USER <connection target> <default option> <general value specification> <reserved word>
    USING <character translation> <form-of-use conversion> <named columns join> <reserved word> <using arguments> <using descriptor>
    VALUE <general value specification> <get descriptor information> <reserved word> <set descriptor information>
    VALUES <insert columns and source> <reserved word> <table value constructor>
    VARCHAR <C VARCHAR variable> <character string type> <reserved word>
    VARYING <bit string type> <character string type> <national character string type> <reserved word>
    VIEW <drop view statement> <reserved word> <view definition>
    volatile <C class modifier>
    WHEN <reserved word> <searched when clause> <simple when clause>
    WHENEVER <embedded exception condition> <reserved word>
    WHERE <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <dynamic update statement: positioned> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <reserved word> <update statement: positioned> <update statement: searched> <where clause>
    WITH <allocate descriptor statement> <datetime type> <grant statement> <reserved word> <view definition>
    WORK <commit statement> <reserved word> <rollback statement>
    WRITE <reserved word> <transaction access mode>
    YEAR <non-second datetime field> <reserved word>
    ZONE <datetime type> <reserved word> <set local time zone statement> <time zone specifier>

    Top


    Please send feedback to Jonathan Leffler, variously: jleffler@us.ibm.com or jonathan.leffler@gmail.com .