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>