Capitolo 446.   Definizione di SQL99 in notazione BNF

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

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

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

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

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

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

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

<double quote> ::= "

<percent> ::= %

<ampersand> ::= &

<quote> ::= '

<left paren> ::= (

<right paren> ::= )

<asterisk> ::= *

<plus sign> ::= +

<comma> ::= ,

<minus sign> ::= -

<period> ::= .

<solidus> ::= /

<colon> ::= :

<semicolon> ::= ;

<less than operator> ::= <

<equals operator> ::= =

<greater than operator> ::= >

<question mark> ::= ?

<left bracket> ::= [

<right bracket> ::= ]

<circumflex> ::= ^

<underscore> ::= _

<vertical bar> ::= |

<left brace> ::= {

<right brace> ::= }

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

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

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

<identifier> ::= <actual identifier>

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

<regular identifier> ::= <identifier body>

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

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

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

<delimited identifier> ::=
        <double quote>
        <delimited identifier body>
        <double quote>

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

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

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

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

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

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

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

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

<catalog name> ::= <identifier>

<unqualified schema name> ::= <identifier>

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

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

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

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

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

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

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

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

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

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

<role name> ::= <identifier>

<user identifier> ::= <identifier>

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

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

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

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

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

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

<group name> ::= <identifier>

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

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

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

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

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

<qualified identifier> ::= <identifier>

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

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

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

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

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

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

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

<column name> ::= <identifier>

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

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

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

<length> ::= <unsigned integer>

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

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

<multiplier> ::= K | M | G

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

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

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

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

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

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

<precision> ::= <unsigned integer>

<scale> ::= <unsigned integer>

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

<boolean type> ::= BOOLEAN

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<field name> ::= <identifier>

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

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

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

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

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

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

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

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

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

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

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

<collection type constructor> ::= ARRAY

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

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

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

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

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

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

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

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

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

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

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

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

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

<mantissa> ::= <exact numeric literal>

<exponent> ::= <signed integer>

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

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

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

<introducer> ::= <underscore>

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

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

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

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

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

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

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

<bracketed comment> ::=
        <bracketed comment introducer>
        <bracketed comment contents>
        <bracketed comment terminator>

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

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

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

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

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

<bit> ::= 0 | 1

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

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

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

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

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

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

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

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

<years value> ::= <datetime value>

<datetime value> ::= <unsigned integer>

<months value> ::= <datetime value>

<days value> ::= <datetime value>

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

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

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

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

<hours value> ::= <datetime value>

<minutes value> ::= <datetime value>

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

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

<seconds fraction> ::= <unsigned integer>

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

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

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

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

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

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

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

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

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

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

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

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

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

<current date value function> ::= CURRENT_DATE

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

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

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

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

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

<null specification> ::= NULL

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

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

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

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

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

<unique specification> ::= UNIQUE | PRIMARY KEY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<set function type> ::= <computational operation>

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

<set quantifier> ::= DISTINCT | ALL

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

<scalar subquery> ::= <subquery>

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

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

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

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

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

<query name> ::= <identifier>

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

<search or cycle clause> ::=
        <search clause>
    |  <cycle clause>
    |  <search clause> <cycle clause>

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

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

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

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

<sort key> ::= <value expression>

<ordering specification> ::= ASC | DESC

<sequence column> ::= <column name>

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

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

<cycle column> ::= <column name>

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

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

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

<path column> ::= <column name>

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

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

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

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

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

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

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

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

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

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

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

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

<asterisked identifier> ::= <identifier>

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

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

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

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

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

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

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

<correlation name> ::= <identifier>

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

<derived table> ::= <table subquery>

<table subquery> ::= <subquery>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<case operand> ::= <value expression>

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

<when operand> ::= <value expression>

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

<result expression> ::= <value expression>

<else clause> ::= ELSE <result>

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

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

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

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

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

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

<subtype operand> ::= <value expression>

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

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

<dereference operator> ::= <right arrow>

<right arrow> ::= ->

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

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

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

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

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

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

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

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

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

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

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

<array element> ::= <value expression>

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

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

<concatenation operator> ::= ||

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

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

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

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

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

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

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

<method name> ::= <identifier>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<blob value function> ::=
        <blob substring function>
    |  <blob trim function>
    |  <blob overlay function>

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

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

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

<blob factor> ::= <blob primary>

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

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

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

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

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

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

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

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

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

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

<bit factor> ::= <bit primary>

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

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

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

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

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

<time zone field> ::= TIMEZONE_HOUR | TIMEZONE_MINUTE

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

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

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

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

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

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

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

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

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

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

<datetime term> ::= <datetime factor>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<row subquery> ::= <subquery>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<all> ::= ALL

<some> ::= SOME | ANY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<table commit action> ::= PRESERVE | DELETE

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

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

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

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

<local qualifier> ::= MODULE

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

<cursor scrollability> ::= SCROLL | NO SCROLL

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

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

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

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

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

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

<procedure name> ::= <identifier>

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

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

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

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

<locator indication> ::= AS LOCATOR

<status parameter> ::= SQLSTATE

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

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

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

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

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

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

<schema authorization identifier> ::= <authorization identifier>

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

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

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

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

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

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

<global or local> ::= GLOBAL | LOCAL

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

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

<supertable clause> ::= <supertable name>

<supertable name> ::= <table name>

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

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

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

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

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

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

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

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

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

<levels clause> ::= CASCADED | LOCAL

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<trigger name> ::= <schema qualified name>

<trigger action time> ::= BEFORE | AFTER

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

<trigger column list> ::= <column name list>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<member> ::= <attribute definition>

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

<attribute name> ::= <identifier>

<attribute default> ::= <default clause>

<instantiable clause> ::= INSTANTIABLE | NOT INSTANTIABLE

<finality> ::= FINAL | NOT FINAL

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

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

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

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

<cast to ref identifier> ::= <identifier>

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

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

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

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

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

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

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

<cast to distinct identifier> ::= <identifier>

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

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

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

<method specification> ::=
        <original method specification>
    |  <overriding method specification>

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

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

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

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

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

<SQL parameter name> ::= <identifier>

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

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

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

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

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

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

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

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

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

<parameter style> ::= SQL | GENERAL

<deterministic characteristic> ::= DETERMINISTIC | NOT DETERMINISTIC

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

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

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

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

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

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

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

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

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

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

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

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

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

<external routine name> ::= <identifier> | <character string literal>

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

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

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

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

<dispatch clause> ::= STATIC DISPATCH

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

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

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

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

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

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

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

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

<object name> ::=
        [ TABLE ] <table name>
    |  DOMAIN <domain name>
    |  COLLATION <collation name>
    |  CHARACTER SET <character set name>
    |  MODULE <module name>
    |  TRANSLATION <translation name>
    |  TYPE <user-defined type name>
    |  <specific routine designator>

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

<grantor> ::= CURRENT_USER | CURRENT_ROLE

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

<role granted> ::= <role name>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<transform group> ::=
        <group name>
        <left paren> <transform element list> <right paren>

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

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

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

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

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

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

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

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

<drop behavior> ::= CASCADE | RESTRICT

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

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

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

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

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

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

<drop column default clause> ::= DROP DEFAULT

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

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

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

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

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

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

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

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

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

<alter routine characteristic> ::=
        <language clause>
    |  <parameter style clause>
    |  <SQL-data access indication>
    |  <null-call clause>
    |  <dynamic result sets characteristic>
    |  NAME <external routine name>

<alter routine behaviour> ::= RESTRICT

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

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

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

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

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

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

<role revoked> ::= <role name>

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

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

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

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

<drop domain default clause> ::= DROP DEFAULT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<drop data type statement> ::=
        DROP TYPE <user-defined type name> <drop behavior>

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

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

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