BNF Grammar for ISO/IEC 9075-2:2003 - Database Language SQL (SQL-2003) SQL/Foundation

 
Cross-Reference: rules
Cross-Reference: keywords

Derived from file sql-2003-2.bnf version 1.16 dated 2011/07/11 18:00:02
Generated on 2011-07-11 19:57:42+00:00 by file bnf2html.pl version 3.11 dated 2011/07/11 19:57:38

Information taken from the Final Committee Draft (FCD) of ISO/IEC 9075-2:2003. However, the page numbers and some section titles (9.14 through 9.23, for example) are from the final standard. This means there could be other as yet undiagnosed differences between the final standard and the notation in this document; you were warned!

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


Key SQL Statements and Fragments

  • ALTER DOMAIN <alter domain statement>
  • ALTER TABLE <alter table statement>
  • CLOSE cursor <close statement>
  • Column definition <column definition>
  • COMMIT WORK <commit statement>
  • CONNECT <connect statement>
  • CREATE ASSERTION <assertion definition>
  • CREATE CHARACTER SET <character set definition>
  • CREATE COLLATION <collation definition>
  • CREATE DOMAIN <domain definition>
  • CREATE FUNCTION <schema function>
  • CREATE PROCEDURE <schema procedure>
  • CREATE SCHEMA <schema definition>
  • CREATE TABLE <table definition>
  • CREATE TRANSLATION <translation definition>
  • CREATE TRIGGER <trigger definition>
  • CREATE VIEW <view definition>
  • Data type <data type>
  • DEALLOCATE PREPARE <deallocate prepared statement>
  • DECLARE cursor <declare cursor> <dynamic declare cursor>
  • DECLARE LOCAL TEMPORARY TABLE <temporary table declaration>
  • DELETE <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned>
  • DESCRIBE <describe statement>
  • DESCRIPTOR statements <system descriptor statement>
  • DISCONNECT <disconnect statement>
  • EXECUTE <execute statement>
  • EXECUTE IMMEDIATE <execute immediate statement>
  • FETCH cursor <fetch statement>
  • FROM clause <from clause>
  • GET DIAGNOSTICS <get diagnostics statement>
  • GRANT <grant statement>
  • GROUP BY clause <group by clause>
  • HAVING clause <having clause>
  • INSERT <insert statement>
  • Literals <literal>
  • Keywords <key word>
  • MERGE <merge statement>
  • OPEN cursor <open statement>
  • ORDER BY clause <order by clause>
  • PREPARE <prepare statement>
  • REVOKE <revoke statement>
  • ROLLBACK WORK <rollback statement>
  • SAVEPOINT <savepoint statement>
  • Search condition <search condition> <regular expression>
  • SELECT <query specification>
  • SET CATALOG <set catalog statement>
  • SET CONNECTION <set connection statement>
  • SET CONSTRAINTS <set constraints mode statement>
  • SET NAMES <set names statement>
  • SET SCHEMA <set schema statement>
  • SET SESSION AUTHORIZATION <set session user identifier statement>
  • SET TIME ZONE <set local time zone statement>
  • SET TRANSACTION <set transaction statement>
  • SQL Client MODULE <SQL-client module definition>
  • UPDATE <update statement: positioned> <update statement: searched> <dynamic update statement: positioned>
  • Value expression <value expression>
  • WHERE clause <where clause>

    Top


    5 Lexical Elements

    Basic definitions of characters used, tokens, symbols, etc. Most of this section would normally be handled within the lexical analyzer rather than in the grammar proper. Further, the original document does not quote the various single characters, which makes it hard to process automatically.

    5.1 <SQL terminal character> (p151)

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

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

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

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

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

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

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

    <space>    ::=   !! See the Syntax Rules.

    <double quote>    ::=   "

    <percent>    ::=   %

    <ampersand>    ::=   &

    <quote>    ::=   '

    <left paren>    ::=   (

    <right paren>    ::=   )

    <asterisk>    ::=   *

    <plus sign>    ::=   +

    <comma>    ::=   ,

    <minus sign>    ::=   -

    <period>    ::=   .

    <solidus>    ::=   /

    <colon>    ::=   :

    <semicolon>    ::=   ;

    <less than operator>    ::=   <

    <equals operator>    ::=   =

    <greater than operator>    ::=   >

    <question mark>    ::=   ?

    The trigraphs are new in SQL-2003.

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

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

    <left bracket>    ::=   [

    <left bracket trigraph>    ::=   ??(

    <right bracket>    ::=   ]

    <right bracket trigraph>    ::=   ??)

    <circumflex>    ::=   ^

    <underscore>    ::=   _

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

    <left brace>    ::=   {

    <right brace>    ::=   }

    Top


    5.2 <token> and <separator> (p134)

    Specifying lexical units (tokens and separators) that participate in SQL language.

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

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

    <regular identifier>    ::=   <identifier body>

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

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

    Previous standard said:

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

    <identifier start>    ::=   !! See the Syntax Rules.

    <identifier extend>    ::=   !! See the Syntax Rules.

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

    <multiplier>    ::=   K | M | G

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

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

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

    The productions for <Unicode delimited identifier> and so on are new in SQL-2003.

    <Unicode delimited identifier>    ::=
             U <ampersand> <double quote> <Unicode delimiter body> <double quote>
             <Unicode escape specifier>

    <Unicode escape specifier>    ::=   [ UESCAPE <quote> <Unicode escape character> <quote> ]

    <Unicode delimiter body>    ::=   <Unicode identifier part> ...

    <Unicode identifier part>    ::=   <delimited identifier part> | <Unicode escape value>

    <Unicode escape value>    ::=
             <Unicode 4 digit escape value>
         |     <Unicode 6 digit escape value>
         |     <Unicode character escape value>

    Syntax rule 20: <Unicode 4 digit escape value>'<Unicode escape character>+xyzw' is equivalent to the Unicode code point specified by U+xyzw.

    <Unicode 4 digit escape value>    ::=   <Unicode escape character> <hexit> <hexit> <hexit> <hexit>

    Syntax rule 21: <Unicode 6 digit escape value>'<Unicode escape character>+xyzwrs' is equivalent to the Unicode code point specified by U+xyzwrs.

    NOTE 64: The 6-hexit notation is derived by taking the UCS-4 notation defined by ISO/IEC 10646-1 and removing the leading two hexits, whose values are always 0 (zero).

    <Unicode 6 digit escape value>    ::=
             <Unicode escape character> <plus sign> <hexit> <hexit> <hexit> <hexit> <hexit> <hexit>

    Syntax rule 22: <Unicode character escape value> is equivalent to a single instance of <Unicode escape character>.

    <Unicode character escape value>    ::=   <Unicode escape character> <Unicode escape character>

    Syntax rule 15: <Unicode escape character> shall be a single character from the source language character set other than a <hexit>, <plus sign>, or <white space>.

    Syntax rule 16: If the source language character set contains <reverse solidus>, then let DEC be <reverse solidus>; otherwise, let DEC be an implementation-defined character from the source language character set that is not a <hexit>, <plus sign>, <double quote>, or <white space>.

    Syntax rule 17: If a <Unicode escape specifier> does not contain <Unicode escape character>, then "UESCAPE <quote>DEC<quote>" is implicit.

    Syntax rule 18: In a <Unicode escape value> there shall be no <separator> between the <Unicode escape character> and the first <hexit>, nor between any of the <hexit>s.

    <Unicode escape character>    ::=   !! See the Syntax Rules (15-18 above).

    Syntax rule 6: A <nondoublequote character> is any character of the source language character set other than a <double quote>.

    <nondoublequote character>    ::=   !! See the Syntax Rules.

    The rule for <doublequote symbol> in the standard uses two adjacent literal double quotes rather than referencing <double quote>; the reasons are not clear. It is annotated '!! two consecutive double quote characters'.

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

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

    The rules for <not equals operator> etc in the standard uses two adjacent literal characters rather than referencing <less than> and <greater than>; the reasons are not clear. Note that two characters must be adjacent with no intervening space, not a pair of characters separated by arbitrary white space.

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

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

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

    <concatenation operator>    ::=   <vertical bar> <vertical bar>

    <right arrow>    ::=   <minus sign> <greater than operator>

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

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

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

    The <bracketed comment> rule included '!! See the Syntax Rules'. This probably says something about the <slash> <asterisk> and <asterisk> <slash> needing to be adjacent characters rather than adjacent tokens.

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

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

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

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

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

    <newline>    ::=   !! See the Syntax Rules.

    There was a surprising amount of movement of keywords between the reserved and non-reserved word classes between SQL-99 and SQL-2003-2 FCD and again between SQL 2003-2 FCD and SQL 2003-2 IS. There is also room to think that much of the host language support moved out of Part 2 (SQL/Foundation).

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

    <non-reserved word>    ::=
             A
         |     ABS
         |     ABSOLUTE
         |     ACTION
         |     ADA
         |     ADMIN
         |     AFTER
         |     ALWAYS
         |     ASC
         |     ASSERTION
         |     ASSIGNMENT
         |     ATTRIBUTE
         |     ATTRIBUTES
         |     AVG
         |     BEFORE
         |     BERNOULLI
         |     BREADTH
         |     C
         |     CARDINALITY
         |     CASCADE
         |     CATALOG
         |     CATALOG_NAME
         |     CEIL
         |     CEILING
         |     CHAIN
         |     CHARACTERISTICS
         |     CHARACTERS
         |     CHARACTER_LENGTH
         |     CHARACTER_SET_CATALOG
         |     CHARACTER_SET_NAME
         |     CHARACTER_SET_SCHEMA
         |     CHAR_LENGTH
         |     CHECKED
         |     CLASS_ORIGIN
         |     COALESCE
         |     COBOL
         |     CODE_UNITS
         |     COLLATION
         |     COLLATION_CATALOG
         |     COLLATION_NAME
         |     COLLATION_SCHEMA
         |     COLLECT
         |     COLUMN_NAME
         |     COMMAND_FUNCTION
         |     COMMAND_FUNCTION_CODE
         |     COMMITTED
         |     CONDITION
         |     CONDITION_NUMBER
         |     CONNECTION_NAME
         |     CONSTRAINTS
         |     CONSTRAINT_CATALOG
         |     CONSTRAINT_NAME
         |     CONSTRAINT_SCHEMA
         |     CONSTRUCTORS
         |     CONTAINS
         |     CONVERT
         |     CORR
         |     COUNT
         |     COVAR_POP
         |     COVAR_SAMP
         |     CUME_DIST
         |     CURRENT_COLLATION
         |     CURSOR_NAME
         |     DATA
         |     DATETIME_INTERVAL_CODE
         |     DATETIME_INTERVAL_PRECISION
         |     DEFAULTS
         |     DEFERRABLE
         |     DEFERRED
         |     DEFINED
         |     DEFINER
         |     DEGREE
         |     DENSE_RANK
         |     DEPTH
         |     DERIVED
         |     DESC
         |     DESCRIPTOR
         |     DIAGNOSTICS
         |     DISPATCH
         |     DOMAIN
         |     DYNAMIC_FUNCTION
         |     DYNAMIC_FUNCTION_CODE
         |     EQUALS
         |     EVERY
         |     EXCEPTION
         |     EXCLUDE
         |     EXCLUDING
         |     EXP
         |     EXTRACT
         |     FINAL
         |     FIRST
         |     FLOOR
         |     FOLLOWING
         |     FORTRAN
         |     FOUND
         |     FUSION
         |     G
         |     GENERAL
         |     GO
         |     GOTO
         |     GRANTED
         |     HIERARCHY
         |     IMPLEMENTATION
         |     INCLUDING
         |     INCREMENT
         |     INITIALLY
         |     INSTANCE
         |     INSTANTIABLE
         |     INTERSECTION
         |     INVOKER
         |     ISOLATION
         |     K
         |     KEY
         |     KEY_MEMBER
         |     KEY_TYPE
         |     LAST
         |     LENGTH
         |     LEVEL
         |     LN
         |     LOCATOR
         |     LOWER
         |     M
         |     MAP
         |     MATCHED
         |     MAX
         |     MAXVALUE
         |     MESSAGE_LENGTH
         |     MESSAGE_OCTET_LENGTH
         |     MESSAGE_TEXT
         |     MIN
         |     MINVALUE
         |     MOD
         |     MORE
         |     MUMPS
         |     NAME
         |     NAMES
         |     NESTING
         |     NEXT
         |     NORMALIZE
         |     NORMALIZED
         |     NULLABLE
         |     NULLIF
         |     NULLS
         |     NUMBER
         |     OBJECT
         |     OCTETS
         |     OCTET_LENGTH
         |     OPTION
         |     OPTIONS
         |     ORDERING
         |     ORDINALITY
         |     OTHERS
         |     OVERLAY
         |     OVERRIDING
         |     PAD
         |     PARAMETER_MODE
         |     PARAMETER_NAME
         |     PARAMETER_ORDINAL_POSITION
         |     PARAMETER_SPECIFIC_CATALOG
         |     PARAMETER_SPECIFIC_NAME
         |     PARAMETER_SPECIFIC_SCHEMA
         |     PARTIAL
         |     PASCAL
         |     PATH
         |     PERCENTILE_CONT
         |     PERCENTILE_DISC
         |     PERCENT_RANK
         |     PLACING
         |     PLI
         |     POSITION
         |     POWER
         |     PRECEDING
         |     PRESERVE
         |     PRIOR
         |     PRIVILEGES
         |     PUBLIC
         |     RANK
         |     READ
         |     RELATIVE
         |     REPEATABLE
         |     RESTART
         |     RETURNED_CARDINALITY
         |     RETURNED_LENGTH
         |     RETURNED_OCTET_LENGTH
         |     RETURNED_SQLSTATE
         |     ROLE
         |     ROUTINE
         |     ROUTINE_CATALOG
         |     ROUTINE_NAME
         |     ROUTINE_SCHEMA
         |     ROW_COUNT
         |     ROW_NUMBER
         |     SCALE
         |     SCHEMA
         |     SCHEMA_NAME
         |     SCOPE_CATALOG
         |     SCOPE_NAME
         |     SCOPE_SCHEMA
         |     SECTION
         |     SECURITY
         |     SELF
         |     SEQUENCE
         |     SERIALIZABLE
         |     SERVER_NAME
         |     SESSION
         |     SETS
         |     SIMPLE
         |     SIZE
         |     SOURCE
         |     SPACE
         |     SPECIFIC_NAME
         |     SQRT
         |     STATE
         |     STATEMENT
         |     STDDEV_POP
         |     STDDEV_SAMP
         |     STRUCTURE
         |     STYLE
         |     SUBCLASS_ORIGIN
         |     SUBSTRING
         |     SUM
         |     TABLESAMPLE
         |     TABLE_NAME
         |     TEMPORARY
         |     TIES
         |     TOP_LEVEL_COUNT
         |     TRANSACTION
         |     TRANSACTIONS_COMMITTED
         |     TRANSACTIONS_ROLLED_BACK
         |     TRANSACTION_ACTIVE
         |     TRANSFORM
         |     TRANSFORMS
         |     TRANSLATE
         |     TRIGGER_CATALOG
         |     TRIGGER_NAME
         |     TRIGGER_SCHEMA
         |     TRIM
         |     TYPE
         |     UNBOUNDED
         |     UNCOMMITTED
         |     UNDER
         |     UNNAMED
         |     USAGE
         |     USER_DEFINED_TYPE_CATALOG
         |     USER_DEFINED_TYPE_CODE
         |     USER_DEFINED_TYPE_NAME
         |     USER_DEFINED_TYPE_SCHEMA
         |     VIEW
         |     WORK
         |     WRITE
         |     ZONE

    <reserved word>    ::=
             ADD
         |     ALL
         |     ALLOCATE
         |     ALTER
         |     AND
         |     ANY
         |     ARE
         |     ARRAY
         |     AS
         |     ASENSITIVE
         |     ASYMMETRIC
         |     AT
         |     ATOMIC
         |     AUTHORIZATION
         |     BEGIN
         |     BETWEEN
         |     BIGINT
         |     BINARY
         |     BLOB
         |     BOOLEAN
         |     BOTH
         |     BY
         |     CALL
         |     CALLED
         |     CASCADED
         |     CASE
         |     CAST
         |     CHAR
         |     CHARACTER
         |     CHECK
         |     CLOB
         |     CLOSE
         |     COLLATE
         |     COLUMN
         |     COMMIT
         |     CONNECT
         |     CONSTRAINT
         |     CONTINUE
         |     CORRESPONDING
         |     CREATE
         |     CROSS
         |     CUBE
         |     CURRENT
         |     CURRENT_DATE
         |     CURRENT_DEFAULT_TRANSFORM_GROUP
         |     CURRENT_PATH
         |     CURRENT_ROLE
         |     CURRENT_TIME
         |     CURRENT_TIMESTAMP
         |     CURRENT_TRANSFORM_GROUP_FOR_TYPE
         |     CURRENT_USER
         |     CURSOR
         |     CYCLE
         |     DATE
         |     DAY
         |     DEALLOCATE
         |     DEC
         |     DECIMAL
         |     DECLARE
         |     DEFAULT
         |     DELETE
         |     DEREF
         |     DESCRIBE
         |     DETERMINISTIC
         |     DISCONNECT
         |     DISTINCT
         |     DOUBLE
         |     DROP
         |     DYNAMIC
         |     EACH
         |     ELEMENT
         |     ELSE
         |     END
         |     END-EXEC
         |     ESCAPE
         |     EXCEPT
         |     EXEC
         |     EXECUTE
         |     EXISTS
         |     EXTERNAL
         |     FALSE
         |     FETCH
         |     FILTER
         |     FLOAT
         |     FOR
         |     FOREIGN
         |     FREE
         |     FROM
         |     FULL
         |     FUNCTION
         |     GET
         |     GLOBAL
         |     GRANT
         |     GROUP
         |     GROUPING
         |     HAVING
         |     HOLD
         |     HOUR
         |     IDENTITY
         |     IMMEDIATE
         |     IN
         |     INDICATOR
         |     INNER
         |     INOUT
         |     INPUT
         |     INSENSITIVE
         |     INSERT
         |     INT
         |     INTEGER
         |     INTERSECT
         |     INTERVAL
         |     INTO
         |     IS
         |     ISOLATION
         |     JOIN
         |     LANGUAGE
         |     LARGE
         |     LATERAL
         |     LEADING
         |     LEFT
         |     LIKE
         |     LOCAL
         |     LOCALTIME
         |     LOCALTIMESTAMP
         |     MATCH
         |     MEMBER
         |     MERGE
         |     METHOD
         |     MINUTE
         |     MODIFIES
         |     MODULE
         |     MONTH
         |     MULTISET
         |     NATIONAL
         |     NATURAL
         |     NCHAR
         |     NCLOB
         |     NEW
         |     NO
         |     NONE
         |     NOT
         |     NULL
         |     NUMERIC
         |     OF
         |     OLD
         |     ON
         |     ONLY
         |     OPEN
         |     OR
         |     ORDER
         |     OUT
         |     OUTER
         |     OUTPUT
         |     OVER
         |     OVERLAPS
         |     PARAMETER
         |     PARTITION
         |     PRECISION
         |     PREPARE
         |     PRIMARY
         |     PROCEDURE
         |     RANGE
         |     READS
         |     REAL
         |     RECURSIVE
         |     REF
         |     REFERENCES
         |     REFERENCING
         |     REGR_AVGX
         |     REGR_AVGY
         |     REGR_COUNT
         |     REGR_INTERCEPT
         |     REGR_R2
         |     REGR_SLOPE
         |     REGR_SXX
         |     REGR_SXY
         |     REGR_SYY
         |     RELEASE
         |     RESULT
         |     RETURN
         |     RETURNS
         |     REVOKE
         |     RIGHT
         |     ROLLBACK
         |     ROLLUP
         |     ROW
         |     ROWS
         |     SAVEPOINT
         |     SCROLL
         |     SEARCH
         |     SECOND
         |     SELECT
         |     SENSITIVE
         |     SESSION_USER
         |     SET
         |     SIMILAR
         |     SMALLINT
         |     SOME
         |     SPECIFIC
         |     SPECIFICTYPE
         |     SQL
         |     SQLEXCEPTION
         |     SQLSTATE
         |     SQLWARNING
         |     START
         |     STATIC
         |     SUBMULTISET
         |     SYMMETRIC
         |     SYSTEM
         |     SYSTEM_USER
         |     TABLE
         |     THEN
         |     TIME
         |     TIMESTAMP
         |     TIMEZONE_HOUR
         |     TIMEZONE_MINUTE
         |     TO
         |     TRAILING
         |     TRANSLATION
         |     TREAT
         |     TRIGGER
         |     TRUE
         |     UESCAPE
         |     UNION
         |     UNIQUE
         |     UNKNOWN
         |     UNNEST
         |     UPDATE
         |     UPPER
         |     USER
         |     USING
         |     VALUE
         |     VALUES
         |     VAR_POP
         |     VAR_SAMP
         |     VARCHAR
         |     VARYING
         |     WHEN
         |     WHENEVER
         |     WHERE
         |     WIDTH_BUCKET
         |     WINDOW
         |     WITH
         |     WITHIN
         |     WITHOUT
         |     YEAR

    Top


    5.3 <literal> (p143)

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

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

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

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

    <introducer>    ::=   <underscore>

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

    <nonquote character>    ::=   !! See the Syntax Rules.

    The <quote symbol> rule consists of two immediately adjacent <quote> marks with no spaces. As usual, this would be best handled in the lexical analyzer, not in the grammar.

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

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

    <Unicode character string literal>    ::=
             [ <introducer> <character set specification> ]
             U <ampersand> <quote> [ <Unicode representation> ... ] <quote>
             [ { <separator> <quote> [ <Unicode representation> ... ] <quote> }... ]
             [ ESCAPE <escape character> ]

    <Unicode representation>    ::=   <character representation> | <Unicode escape value>

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

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

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

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

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

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

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

    <mantissa>    ::=   <exact numeric literal>

    <exponent>    ::=   <signed integer>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <years value>    ::=   <datetime value>

    <months value>    ::=   <datetime value>

    <days value>    ::=   <datetime 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>

    <datetime value>    ::=   <unsigned integer>

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

    Top


    5.4 Names and identifiers (p151)

    <identifier>    ::=   <actual identifier>

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

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

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

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

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

    <catalog name>    ::=   <identifier>

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

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

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

    <qualified identifier>    ::=   <identifier>

    <column name>    ::=   <identifier>

    <correlation name>    ::=   <identifier>

    <query name>    ::=   <identifier>

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

    <procedure name>    ::=   <identifier>

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

    <method name>    ::=   <identifier>

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

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

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

    <local qualifier>    ::=   MODULE

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

    <SQL parameter name>    ::=   <identifier>

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

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

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

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

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

    <transliteration name>    ::=   <schema qualified name>

    <transcoding name>    ::=   <schema qualified name>

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

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

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

    <attribute name>    ::=   <identifier>

    <field name>    ::=   <identifier>

    <savepoint name>    ::=   <identifier>

    <sequence generator name>    ::=   <schema qualified name>

    <role name>    ::=   <identifier>

    <user identifier>    ::=   <identifier>

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

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

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

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

    <statement name>    ::=   <identifier>

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

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

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

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

    <scope option>    ::=   GLOBAL | LOCAL

    <window name>    ::=   <identifier>

    Top


    6 Scalar expressions

    6.1 <data type> (p161)

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

    <predefined type>    ::=
             <character string type> [ CHARACTER SET <character set specification> ] [ <collate clause> ]
         |     <national character string type> [ <collate clause> ]
         |     <binary large object 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> ]

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

    <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> ]
         |     SMALLINT
         |     INTEGER
         |     INT
         |     BIGINT

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

    <length>    ::=   <unsigned integer>

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

    <char length units>    ::=   CHARACTERS | CODE_UNITS | OCTETS

    <precision>    ::=   <unsigned integer>

    <scale>    ::=   <unsigned integer>

    <boolean type>    ::=   BOOLEAN

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

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

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

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

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

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

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

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

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

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

    <referenced type>    ::=   <path-resolved user-defined type name>

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

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

    <collection type>    ::=   <array type> | <multiset type>

    <array type>    ::=   <data type> ARRAY [ <left bracket or trigraph> <unsigned integer> <right bracket or trigraph> ]

    <multiset type>    ::=   <data type> MULTISET

    Top


    6.2 <field definition> (p173)

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

    Top


    6.3 <value expression primary> (p174)

    <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>
         |     <window function>
         |     <scalar subquery>
         |     <case expression>
         |     <cast specification>
         |     <field reference>
         |     <subtype treatment>
         |     <method invocation>
         |     <static method invocation>
         |     <new specification>
         |     <attribute or method reference>
         |     <reference resolution>
         |     <collection value constructor>
         |     <array element reference>
         |     <multiset element reference>
         |     <routine invocation>
         |     <next value expression>

    Top


    6.4 <value specification> and <target specification> (p176)

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

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

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

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

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

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

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

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

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

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

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

    <target array element specification>    ::=
             <target array reference> <left bracket or trigraph> <simple value specification> <right bracket or trigraph>

    <target array reference>    ::=   <SQL parameter reference> | <column reference>

    <current collation specification>    ::=   CURRENT_COLLATION <left paren> <string value expression> <right paren>

    Top


    6.5 <contextually typed value specification> (p181)

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

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

    <null specification>    ::=   NULL

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

    <default specification>    ::=   DEFAULT

    Top


    6.6 <identifier chain> (p183)

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

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

    Top


    6.7 <column reference> (p187)

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

    Top


    6.8 <SQL parameter reference> (p190)

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

    Top


    6.9 <set function specification> (p191)

    <set function specification>    ::=   <aggregate function> | <grouping operation>

    <grouping operation>    ::=   GROUPING <left paren> <column reference> [ { <comma> <column reference> }... ] <right paren>

    Top


    6.10 <window function> (p193)

    <window function>    ::=   <window function type> OVER <window name or specification>

    <window function type>    ::=
             <rank function type> <left paren> <right paren>
         |     ROW_NUMBER <left paren> <right paren>
         |     <aggregate function>

    <rank function type>    ::=   RANK | DENSE_RANK | PERCENT_RANK | CUME_DIST

    <window name or specification>    ::=   <window name> | <in-line window specification>

    <in-line window specification>    ::=   <window specification>

    Top


    6.11 <case expression> (p197)

    <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

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

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

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

    <else clause>    ::=   ELSE <result>

    <case operand>    ::=   <row value predicand> | <overlaps predicate part>

    <when operand>    ::=
             <row value predicand>
         |     <comparison predicate part 2>
         |     <between predicate part 2>
         |     <in predicate part 2>
         |     <character like predicate part 2>
         |     <octet like predicate part 2>
         |     <similar predicate part 2>
         |     <null predicate part 2>
         |     <quantified comparison predicate part 2>
         |     <match predicate part 2>
         |     <overlaps predicate part 2>
         |     <distinct predicate part 2>
         |     <member predicate part 2>
         |     <submultiset predicate part 2>
         |     <set predicate part 2>
         |     <type predicate part 2>

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

    <result expression>    ::=   <value expression>

    Top


    6.12 <cast specification> (p200)

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

    Top


    6.13 <next value expression> (p216)

    <next value expression>    ::=   NEXT VALUE FOR <sequence generator name>

    Top


    6.14 <field reference> (p218)

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

    Top


    6.15 <subtype treatment> (p219)

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

    <subtype operand>    ::=   <value expression>

    <target subtype>    ::=
             <path-resolved user-defined type name>
         |     <reference type>

    Top


    6.16 <method invocation> (p221)

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

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

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

    <method selection>    ::=   <routine invocation>

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

    Top


    6.17 <static method invocation> (p223)

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

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

    Top


    6.18 <new specification> (p225)

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

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

    Top


    6.19 <attribute or method reference> (p227)

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

    <dereference operator>    ::=   <right arrow>

    Top


    6.20 <dereference operation> (p229)

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

    Top


    6.21 <method reference> (p230)

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

    Top


    6.22 <reference resolution> (p232)

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

    Top


    6.23 <array element reference> (p234)

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

    Top


    6.24 <multiset element reference> (p235)

    <multiset element reference>    ::=
             ELEMENT <left paren> <multset value expression> <right paren>

    6.25 <value expression> (p236)

    Specify a value.

    <value expression>    ::=
             <common value expression>
         |     <boolean value expression>
         |     <row value expression>

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

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

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

    <collection value expression>    ::=   <array value expression> | <multiset value expression>

    <collection value constructor>    ::=   <array value constructor> | <multiset value constructor>

    6.26 <numeric value expression> (p240)

    Specify a numeric value.

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

    6.27 <numeric value function> (p242)

    Specify a function yielding a value of type numeric.

    <numeric value function>    ::=
             <position expression>
         |     <extract expression>
         |     <length expression>
         |     <cardinality expression>
         |     <absolute value expression>
         |     <modulus expression>
         |     <natural logarithm>
         |     <exponential function>
         |     <power function>
         |     <square root>
         |     <floor function>
         |     <ceiling function>
         |     <width bucket function>

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

    <string position expression>    ::=
             POSITION <left paren> <string value expression> IN <string value expression> [ USING <char length units> ] <right paren>

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

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

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

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

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

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

    <time zone field>    ::=   TIMEZONE_HOUR | TIMEZONE_MINUTE

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

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

    <natural logarithm>    ::=   LN <left paren> <numeric value expression> <right paren>

    <exponential function>    ::=   EXP <left paren> <numeric value expression> <right paren>

    <power function>    ::=   POWER <left paren> <numeric value expression base> <comma> <numeric value expression exponent> <right paren>

    <numeric value expression base>    ::=   <numeric value expression>

    <numeric value expression exponent>    ::=   <numeric value expression>

    <square root>    ::=   SQRT <left paren> <numeric value expression> <right paren>

    <floor function>    ::=   FLOOR <left paren> <numeric value expression> <right paren>

    <ceiling function>    ::=   { CEIL | CEILING } <left paren> <numeric value expression> <right paren>

    <width bucket function>    ::=   WIDTH_BUCKET <left paren> <width bucket operand> <comma> <width bucket bound 1> <comma> <width bucket bound 2> <comma> <width bucket count> <right paren>

    <width bucket operand>    ::=   <numeric value expression>

    <width bucket bound 1>    ::=   <numeric value expression>

    <width bucket bound 2>    ::=   <numeric value expression>

    <width bucket count>    ::=   <numeric value expression>

    6.28 <string value expression> (p251)

    Specify a character string value or a binary string value.

    <string value expression>    ::=   <character 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>

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

    <blob factor>    ::=   <blob primary>

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

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

    6.29 <string value function> (p255)

    Specify a function yielding a value of type character string or binary string.

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

    <character value function>    ::=
             <character substring function>
         |     <regular expression substring function>
         |     <fold>
         |     <transcoding>
         |     <character transliteration>
         |     <trim function>
         |     <character overlay function>
         |     <normalize function>
         |     <specific type method>

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

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

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

    <transcoding>    ::=   CONVERT <left paren> <character value expression> USING <transcoding name> <right paren>

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

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

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

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

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

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

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

    <normalize function>    ::=   NORMALIZE <left paren> <character value expression> <right paren>

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

    <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 trim function>    ::=   TRIM <left paren> <blob trim operands> <right paren>

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

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

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

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

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

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

    6.30 <datetime value expression> (p266)

    Specify a datetime value.

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

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

    6.31 <datetime value function> (p269)

    Specify a function yielding a value of type datetime.

    <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 local time value function>    ::=   LOCALTIME [ <left paren> <time precision> <right paren> ]

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

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

    6.32 <interval value expression> (p271)

    Specify an interval value.

    <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 term>    ::=
             <interval factor>
         |     <interval term 2> <asterisk> <factor>
         |     <interval term 2> <solidus> <factor>
         |     <term> <asterisk> <interval factor>

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

    <interval primary>    ::=
             <value expression primary> [ <interval qualifier> ]
         |     <interval value function>

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

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

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

    6.33 <interval value function> (p276)

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

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

    6.34 <boolean value expression> (p277)

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

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

    <boolean primary>    ::=   <predicate> | <boolean predicand>

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

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

    6.35 <array value expression> (p284)

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

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

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

    <array factor>    ::=   <value expression primary>

    6.36 <array value constructor> (p284)

    <array value constructor>    ::=
             <array value constructor by enumeration>
         |     <array value constructor by query>

    <array value constructor by enumeration>    ::=
             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 value constructor by query>    ::=
             ARRAY <left paren> <query expression> [ <order by clause> ] <right paren>

    6.37 <multiset value expression> (p286)

    <multiset value expression>    ::=
             <multiset term>
         |     <multiset value expression> MULTISET UNION [ ALL | DISTINCT ] <multiset term>
         |     <multiset value expression> MULTISET EXCEPT [ ALL | DISTINCT ] <multiset term>

    <multiset term>    ::=
             <multiset primary>
         |     <multiset term> MULTISET INTERSECT [ ALL | DISTINCT ] <multiset primary>

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

    6.38 <multiset value function> (p289)

    <multiset value function>    ::=   <multiset set function>

    <multiset set function>    ::=   SET <left paren> <multiset value expression> <right paren>

    6.39 <multiset value constructor> (p290)

    <multiset value constructor>    ::=
             <multiset value constructor by enumeration>
         |     <multiset value constructor by query>
         |     <table value constructor by query>

    <multiset value constructor by enumeration>    ::=   MULTISET <left bracket or trigraph> <multiset element list> <right bracket or trigraph>

    <multiset element list>    ::=   <multiset element> [ { <comma> <multiset element> } ]

    <multiset element>    ::=   <value expression>

    <multiset value constructor by query>    ::=   MULTISET <left paren> <query expression> <right paren>

    <table value constructor by query>    ::=   TABLE <left paren> <query expression> <right paren>

    Top


    7 Query expressions

    7.1 <row value constructor> (p293)

    Specify a value or list of values to be constructed into a row or partial row.

    <row value constructor>    ::=
             <common value expression>
         |     <boolean value expression>
         |     <explicit row value constructor>

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

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

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

    <contextually typed row value constructor>    ::=
             <common value expression>
         |     <boolean value expression>
         |     <contextually typed value specification>
         |     <left paren> <contextually typed row value constructor element> <comma> <contextually typed row value constructor element list> <right paren>
         |     ROW <left paren> <contextually typed row value constructor element list> <right paren>

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

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

    <row value constructor predicand>    ::=
             <common value expression>
         |     <boolean predicand>
         |     <explicit row value constructor>

    7.2 <row value expression> (p296)

    Specify a row value.

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

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

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

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

    <row value special case>    ::=   <nonparenthesized value expression primary>

    7.3 <table value constructor> (p298)

    Specify a set of <row value expression>s to be constructed into a table.

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

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

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

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

    7.4 <table expression> (p300)

    Specify a table or a grouped table.

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

    7.5 <from clause> (p301)

    Specify a table derived from one or more tables.

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

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

    7.6 <table reference> (p303)

    Reference a table.

    <table reference>    ::=   <table primary or joined table> [ <sample clause> ]

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

    <sample clause>    ::=
             TABLESAMPLE <sample method> <left paren> <sample percentage> <right paren> [ <repeatable clause> ]

    <sample method>    ::=   BERNOULLI | SYSTEM

    <repeatable clause>    ::=   REPEATABLE <left paren> <repeat argument> <right paren>

    <sample percentage>    ::=   <numeric value expression>

    <repeat argument>    ::=   <numeric value expression>

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

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

    <lateral derived table>    ::=   LATERAL <table subquery>

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

    <table function derived table>    ::=   TABLE <left paren> <collection value expression> <right paren>

    <derived table>    ::=   <table subquery>

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

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

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

    7.7 <joined table> (p312)

    Specify a table derived from a Cartesian product, inner or outer join, or union join.

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

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

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

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

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

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

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

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

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

    7.8 <where clause> (p319)

    Specify a table derived by the application of a <search condition> to the result of the preceding <from clause>.

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

    7.9 <group by clause> (p320)

    Specify a grouped table derived by the application of the <group by clause> to the result of the previously specified clause.

    <group by clause>    ::=   GROUP BY [ <set quantifier> ] <grouping element list>

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

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

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

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

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

    <rollup list>    ::=   ROLLUP <left paren> <ordinary grouping set list> <right paren>

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

    <cube list>    ::=   CUBE <left paren> <ordinary grouping set 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>
         |     <empty grouping set>

    <empty grouping set>    ::=   <left paren> <right paren>

    7.10 <having clause> (p329)

    Specify a grouped table derived by the elimination of groups that do not satisfy a <search condition>.

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

    7.11 <window clause> (p331)

    Specify one or more window definitions.

    <window clause>    ::=   WINDOW <window definition list>

    <window definition list>    ::=   <window definition> [ { <comma> <window definition> }... ]

    <window definition>    ::=   <new window name> AS <window specification>

    <new window name>    ::=   <window name>

    <window specification>    ::=   <left paren> <window specification details> <right paren>

    <window specification details>    ::=
             [ <existing window name> ] [ <window partition clause> ] [ <window order clause> ] [ <window frame clause> ]

    <existing window name>    ::=   <window name>

    <window partition clause>    ::=   PARTITION BY <window partition column reference list>

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

    <window partition column reference>    ::=   <column reference> [ <collate clause> ]

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

    <window frame clause>    ::=   <window frame units> <window frame extent> [ <window frame exclusion> ]

    <window frame units>    ::=   ROWS | RANGE

    <window frame extent>    ::=   <window frame start> | <window frame between>

    <window frame start>    ::=   UNBOUNDED PRECEDING | <window frame preceding> | CURRENT ROW

    <window frame preceding>    ::=   <unsigned value specification> PRECEDING

    <window frame between>    ::=   BETWEEN <window frame bound 1> AND <window frame bound 2>

    <window frame bound 1>    ::=   <window frame bound>

    <window frame bound 2>    ::=   <window frame bound>

    <window frame bound>    ::=
             <window frame start>
         |     UNBOUNDED FOLLOWING
         |     <window frame following>

    <window frame following>    ::=   <unsigned value specification> FOLLOWING

    <window frame exclusion>    ::=
             EXCLUDE CURRENT ROW
         |     EXCLUDE GROUP
         |     EXCLUDE TIES
         |     EXCLUDE NO OTHERS

    7.12 <query specification> (p341)

    Specify a table derived from the result of a <table expression>.

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

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

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

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

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

    <asterisked identifier>    ::=   <identifier>

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

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

    <all fields reference>    ::=   <value expression primary> <period> <asterisk> [ AS <left paren> <all fields column name list> <right paren> ]

    <all fields column name list>    ::=   <column name list>

    7.13 <query expression> (p350)

    Specify a table.

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

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

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

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

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

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

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

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

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

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

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

    7.14 <search or cycle clause> (p363)

    Specify the generation of ordering and cycle detection information in the result of recursive query expressions.

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

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

    <path column>    ::=   <column name>

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

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

    7.15 <subquery> (p368)

    Specify a scalar value, a row, or a table derived from a <query expression>.

    <scalar subquery>    ::=   <subquery>

    <row subquery>    ::=   <subquery>

    <table subquery>    ::=   <subquery>

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

    Top


    8 Predicates

    8.1 <predicate> (p371)

    Specify a condition that can be evaluated to give a boolean value.

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

    8.2 <comparison predicate> (p373)

    Specify a comparison of two row values.

    <comparison predicate>    ::=   <row value predicand> <comparison predicate part 2>

    <comparison predicate part 2>    ::=   <comp op> <row value predicand>

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

    8.3 <between predicate> (p380)

    Specify a range comparison.

    <between predicate>    ::=   <row value predicand> <between predicate part 2>

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

    8.4 <in predicate> (p381)

    Specify a quantified comparison.

    <in predicate>    ::=   <row value predicand> <in predicate part 2>

    <in predicate part 2>    ::=   [ 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> }... ]

    8.5 <like predicate> (p383)

    Specify a pattern-match comparison.

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

    <character like predicate>    ::=   <row value predicand> <character like predicate part 2>

    <character like predicate part 2>    ::=   [ NOT ] LIKE <character pattern> [ ESCAPE <escape character> ]

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

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

    <octet like predicate>    ::=   <row value predicand> <octet like predicate part 2>

    <octet like predicate part 2>    ::=   [ NOT ] LIKE <octet pattern> [ ESCAPE <escape octet> ]

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

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

    8.6 <similar predicate> (p389)

    Specify a character string similarity by means of a regular expression.

    <similar predicate>    ::=   <row value predicand> <similar predicate part 2>

    <similar predicate part 2>    ::=   [ 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> <question mark>
         |     <regular primary> <repeat factor>

    <repeat factor>    ::=   <left brace> <low value> [ <upper limit> ] <right brace>

    <upper limit>    ::=   <comma> [ <high value> ]

    <low value>    ::=   <unsigned integer>

    <high value>    ::=   <unsigned integer>

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

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

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

    <escaped character>    ::=   !! See the Syntax Rules.

    <regular character set>    ::=
             <underscore>
         |     <left bracket> <character enumeration> ... <right bracket>
         |     <left bracket> <circumflex> <character enumeration> ... <right bracket>
         |     <left bracket> <character enumeration include> ... <circumflex> <character enumeration exclude> ... <right bracket>

    <character enumeration include>    ::=   <character enumeration>

    <character enumeration exclude>    ::=   <character enumeration>

    <character enumeration>    ::=
             <character specifier>
         |     <character specifier> <minus sign> <character specifier>
         |     <left bracket> <colon> <regular character set identifier> <colon> <right bracket>

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

    8.7 <null predicate> (p395)

    Specify a test for a null value.

    <null predicate>    ::=   <row value predicand> <null predicate part 2>

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

    8.8 <quantified comparison predicate> (p397)

    Specify a quantified comparison.

    <quantified comparison predicate>    ::=   <row value predicand> <quantified comparison predicate part 2>

    <quantified comparison predicate part 2>    ::=   <comp op> <quantifier> <table subquery>

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

    <all>    ::=   ALL

    <some>    ::=   SOME | ANY

    8.9 <exists predicate> (p399)

    Specify a test for a non-empty set.

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

    8.10 <unique predicate> (p400)

    Specify a test for the absence of duplicate rows

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

    8.11 <normalized predicate> (p401)

    Determine whether a character string value is normalized.

    <normalized predicate>    ::=   <string value expression> IS [ NOT ] NORMALIZED

    8.12 <match predicate> (p402)

    Specify a test for matching rows.

    <match predicate>    ::=   <row value predicand> <match predicate part 2>

    <match predicate part 2>    ::=   MATCH [ UNIQUE ] [ SIMPLE | PARTIAL | FULL ] <table subquery>

    8.13 <overlaps predicate> (p405)

    Specify a test for an overlap between two datetime periods.

    <overlaps predicate>    ::=   <overlaps predicate part 1> <overlaps predicate part 2>

    <overlaps predicate part 1>    ::=   <row value predicand 1>

    <overlaps predicate part 2>    ::=   OVERLAPS <row value predicand 2>

    <row value predicand 1>    ::=   <row value predicand>

    <row value predicand 2>    ::=   <row value predicand>

    8.14 <distinct predicate> (p407)

    Specify a test of whether two row values are distinct

    <distinct predicate>    ::=   <row value predicand 3> <distinct predicate part 2>

    <distinct predicate part 2>    ::=   IS DISTINCT FROM <row value predicand 4>

    <row value predicand 3>    ::=   <row value predicand>

    <row value predicand 4>    ::=   <row value predicand>

    8.15 <member predicate> (p409)

    Specify a test of whether a value is a member of a multiset.

    <member predicate>    ::=   <row value predicand> <member predicate part 2>

    <member predicate part 2>    ::=   [ NOT ] MEMBER [ OF ] <multiset value expression>

    8.16 <submultiset predicate> (p411)

    Specify a test of whether a multiset is a submultiset of another multiset.

    <submultiset predicate>    ::=   <row value predicand> <submultiset predicate part 2>

    <submultiset predicate part 2>    ::=   [ NOT ] SUBMULTISET [ OF ] <multiset value expression>

    8.17 <set predicate> (p413)

    Specify a test of whether a multiset is a set (that is, does not contain any duplicates).

    <set predicate>    ::=   <row value predicand> <set predicate part 2>

    <set predicate part 2>    ::=   IS [ NOT ] A SET

    8.18 <type predicate> (p414)

    Specify a type test.

    <type predicate>    ::=   <row value predicand> <type predicate part 2>

    <type predicate part 2>    ::=   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>    ::=   <path-resolved user-defined type name>

    <exclusive user-defined type specification>    ::=   ONLY <path-resolved user-defined type name>

    8.19 <search condition> (p416)

    Specify a condition that is True , False , or Unknown , depending on the value of a <boolean value expression>.

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

    Top


    9 Additional common rules

    9.1 Retrieval assignment (p417)

    9.2 Store assignment (p422)

    9.3 Data types of results of aggregations (p427)

    9.4 Subject routine determination (p430)

    9.5 Type precedence list determination (p431)

    9.6 Host parameter mode determination (p434)

    9.7 Type name determination (p436)

    9.8 Determination of identical values (p438)

    9.9 Equality operations (p440)

    9.10 Grouping operations (p443)

    9.11 Multiset element grouping operations (p445)

    9.12 Ordering operations (p447)

    9.13 Collation determination (p449)

    9.14 Execution of array-returning functions (p450)

    9.15 Execution of multiset-returning functions (p453)

    9.16 Data type identity (p454)

    9.17 Determination of a from-sql function (p456)

    9.18 Determination of a from-sql function for an overriding method (p457)

    9.19 Determination of a to-sql function (p458)

    9.20 Determination of a to-sql function for an overriding method (p459)

    9.21 Generation of the next value of a sequence generator (p460)

    9.22 Creation of a sequence generator (p461)

    9.23 Altering a sequence generator (p463)

    Top


    10 Additional common elements

    10.1 <interval qualifier> (p465)

    Specify the precision of an interval data type.

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

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

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

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

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

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

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

    10.2 <language clause> (p469)

    Specify a standard programming language.

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

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

    Table 14 -- Standard programming languages

    Language keyword Relevant standard
    ADAISO/IEC 8652
    CISO/IEC 9899
    COBOLISO 1989
    FORTRANISO 1539
    MUMPSISO/IEC 11756
    PASCALISO/IEC 7185 and ISO/IEC 10206
    PLIISO 6160
    SQLISO/IEC 9075

    10.3 <path specification> (p471)

    Specify an order for searching for an SQL-invoked routine.

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

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

    10.4 <routine invocation> (p472)

    Invoke an SQL-invoked routine.

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

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

    <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 <path-resolved user-defined type name>

    10.5 <character set specification> (p495)

    Identify a character set.

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

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

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

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

    10.6 <specific routine designator> (p497)

    Specify an SQL-invoked routine.

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

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

    <member name>    ::=   <member name alternatives> [ <data type list> ]

    <member name alternatives>    ::=   <schema qualified routine name> | <method name>

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

    10.7 <collate clause> (p500)

    Specify a default collating sequence.

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

    10.8 <constraint name definition> and <constraint characteristics> (p501)

    Specify the name of a constraint and its characteristics.

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

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

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

    10.9 <aggregate function> (p503)

    Specify a value computed from a collection of rows.

    <aggregate function>    ::=
             COUNT <left paren> <asterisk> <right paren> [ <filter clause> ]
         |     <general set function> [ <filter clause> ]
         |     <binary set function> [ <filter clause> ]
         |     <ordered set function> [ <filter clause> ]

    <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
         |     STDDEV_POP | STDDEV_SAMP | VAR_SAMP | VAR_POP
         |     COLLECT | FUSION | INTERSECTION

    <set quantifier>    ::=   DISTINCT | ALL

    <filter clause>    ::=   FILTER <left paren> WHERE <search condition> <right paren>

    <binary set function>    ::=   <binary set function type> <left paren> <dependent variable expression> <comma> <independent variable expression> <right paren>

    <binary set function type>    ::=
             COVAR_POP | COVAR_SAMP | CORR | REGR_SLOPE
         |     REGR_INTERCEPT | REGR_COUNT | REGR_R2 | REGR_AVGX | REGR_AVGY
         |     REGR_SXX | REGR_SYY | REGR_SXY

    <dependent variable expression>    ::=   <numeric value expression>

    <independent variable expression>    ::=   <numeric value expression>

    <ordered set function>    ::=   <hypothetical set function> | <inverse distribution function>

    <hypothetical set function>    ::=   <rank function type> <left paren> <hypothetical set function value expression list> <right paren> <within group specification>

    <within group specification>    ::=   WITHIN GROUP <left paren> ORDER BY <sort specification list> <right paren>

    <hypothetical set function value expression list>    ::=   <value expression> [ { <comma> <value expression> }... ]

    <inverse distribution function>    ::=   <inverse distribution function type> <left paren> <inverse distribution function argument> <right paren> <within group specification>

    <inverse distribution function argument>    ::=   <numeric value expression>

    <inverse distribution function type>    ::=   PERCENTILE_CONT | PERCENTILE_DISC

    10.10 <sort specification list> (p515)

    Specify a sort order.

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

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

    <sort key>    ::=   <value expression>

    <ordering specification>    ::=   ASC | DESC

    <null ordering>    ::=   NULLS FIRST | NULLS LAST

    Top


    11 Schema definition and manipulation

    11.1 <schema definition> (p517)

    Define a schema.

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

    <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 name clause>    ::=
             <schema name>
         |     AUTHORIZATION <schema authorization identifier>
         |     <schema name> AUTHORIZATION <schema authorization identifier>

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

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

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

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

    11.2 <drop schema statement> (p520)

    Destroy a schema.

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

    <drop behavior>    ::=   CASCADE | RESTRICT

    11.3 <table definition> (p523)

    Define a persistent base table, a created local temporary table, or a global temporary table.

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

    <table contents source>    ::=
             <table element list>
         |     OF <path-resolved user-defined type name> [ <subtable clause> ] [ <table element list> ]
         |     <as subquery clause>

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

    <global or local>    ::=   GLOBAL | LOCAL

    <table commit action>    ::=   PRESERVE | DELETE

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

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

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

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

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

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

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

    <supertable clause>    ::=   <supertable name>

    <supertable name>    ::=   <table name>

    <like clause>    ::=   LIKE <table name> [ <like options> ]

    <like options>    ::=   <identity option> | <column default option>

    <identity option>    ::=   INCLUDING IDENTITY | EXCLUDING IDENTITY

    <column default option>    ::=   INCLUDING DEFAULTS | EXCLUDING DEFAULTS

    <as subquery clause>    ::=   [ <left paren> <column name list> <right paren> ] AS <subquery> <with or without data>

    <with or without data>    ::=   WITH NO DATA | WITH DATA

    11.4 <column definition> (p534)

    Define a column of a base table.

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

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

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

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

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

    <identity column specification>    ::=
             GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY
             [ <left paren> <common sequence generator options> <right paren> ]

    <generation clause>    ::=   <generation rule> AS <generation expression>

    <generation rule>    ::=   GENERATED ALWAYS

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

    11.5 <default clause> (p539)

    Specify the default for a column, domain, or attribute.

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

    11.6 <table constraint definition> (p543)

    Specify an integrity constraint.

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

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

    11.7 <unique constraint definition> (p545)

    Specify a uniqueness constraint for a table.

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

    <unique specification>    ::=   UNIQUE | PRIMARY KEY

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

    11.8 <referential constraint definition> (p547)

    Specify a referential constraint.

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

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

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

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

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

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

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

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

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

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

    11.9 <check constraint definition> (p567)

    Specify a condition for the SQL-data.

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

    11.10 <alter table statement> (p569)

    Change the definition of a table.

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

    11.11 <add column definition> (p570)

    Add a column to a table.

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

    11.12 <alter column definition> (p572)

    Change a column and its 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>
         |     <alter identity column specification>

    11.13 <set column default clause> (p573)

    Set the default clause for a column.

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

    11.14 <drop column default clause> (p574)

    Drop the default clause from a column.

    <drop column default clause>    ::=   DROP DEFAULT

    11.15 <add column scope clause> (p575)

    Add a non-empty scope for an existing column of data type REF in a base table.

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

    11.16 <drop column scope clause> (p576)

    Drop the scope from an existing column of data type REF in a base table.

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

    11.17 <alter identity column specification> (p578)

    Change the options specified for an identity column.

    <alter identity column specification>    ::=   <alter identity column option> ...

    <alter identity column option>    ::=
             <alter sequence generator restart option>
         |     SET <basic sequence generator option>

    11.18 <drop column definition> (p579)

    Destroy a column of a base table.

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

    11.19 <add table constraint definition> (p581)

    Add a constraint to a table.

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

    11.20 <drop table constraint definition> (p582)

    Destroy a constraint on a table.

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

    11.21 <drop table statement> (p585)

    Destroy a table.

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

    11.22 <view definition> (p588)

    Define a viewed table.

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

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

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

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

    <view element>    ::=   <self-referencing column specification> | <view column option>

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

    <levels clause>    ::=   CASCADED | LOCAL

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

    11.23 <drop view statement> (p598)

    Destroy a view.

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

    11.24 <domain definition> (p601)

    Define a domain.

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

    11.25 <alter domain statement> (p603)

    Change a domain and its definition.

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

    11.26 <set domain default clause> (p604)

    Set the default value in a domain.

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

    11.27 <drop domain default clause> (p605)

    Remove the default clause of a domain.

    <drop domain default clause>    ::=   DROP DEFAULT

    11.28 <add domain constraint definition> (p606)

    Add a constraint to a domain.

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

    11.29 <drop domain constraint definition> (p607)

    Destroy a constraint on a domain.

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

    11.30 <drop domain statement> (p608)

    Destroy a domain.

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

    11.31 <character set definition> (p610)

    Define a character set.

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

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

    11.32 <drop character set statement> (p612)

    Destroy a character set.

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

    11.33 <collation definition> (p614)

    Define a collating sequence.

    <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

    11.34 <drop collation statement> (p616)

    Destroy a collating sequence.

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

    11.35 <transliteration definition> (p618)

    Define a character transliteration.

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

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

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

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

    <existing transliteration name>    ::=   <transliteration name>

    <transliteration routine>    ::=   <specific routine designator>

    11.36 <drop transliteration statement> (p621)

    Destroy a character transliteration.

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

    11.37 <assertion definition> (p623)

    Specify an integrity constraint.

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

    11.38 <drop assertion statement> (p625)

    Destroy an assertion.

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

    11.39 <trigger definition> (p627)

    Define triggered SQL-statements.

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

    <trigger action time>    ::=   BEFORE | AFTER

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

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

    <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

    <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 table alias>    ::=   <identifier>

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

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

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

    11.40 <drop trigger statement> (p631)

    Destroy a trigger.

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

    11.41 <user-defined type definition> (p632)

    Define a user-defined type.

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

    <user-defined type body>    ::=
             <schema-resolved user-defined type name> [ <subtype clause> ]
             [ AS <representation> ] [ <user-defined type option list> ] [ <method specification list> ]

    <user-defined type option list>    ::=   <user-defined type option> [ <user-defined type option> ... ]

    <user-defined type option>    ::=
             <instantiable clause>
         |     <finality>
         |     <reference type specification>
         |     <ref cast option>
         |     <cast option>

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

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

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

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

    <member>    ::=   <attribute definition>

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

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

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

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

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

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

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

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

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

    11.42 <attribute definition> (p648)

    Define an attribute of a structured type.

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

    <attribute default>    ::=   <default clause>

    11.43 <alter type statement> (p650)

    Change the definition of a user-defined type.

    <alter type statement>    ::= ALTER TYPE <schema-resolved 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>

    11.44 <add attribute definition> (p651)

    Add an attribute to a user-defined type.

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

    11.45 <drop attribute definition> (p653)

    Destroy an attribute of a user-defined type.

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

    11.46 <add original method specification> (p655)

    Add an original method specification to a user-defined type.

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

    11.47 <add overriding method specification> (p661)

    Add an overriding method specification to a user-defined type.

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

    11.48 <drop method specification> (p666)

    Remove a method specification from a user-defined type.

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

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

    11.49 <drop data type statement> (p670)

    Destroy a user-defined type.

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

    11.50 <SQL-invoked routine> (p673)

    Define an SQL-invoked routine.

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

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

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

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

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

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

    <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

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

    <locator indication>    ::=   AS LOCATOR

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

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

    <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>
         |     <savepoint level indication>

    <savepoint level indication>    ::=   NEW SAVEPOINT LEVEL | OLD SAVEPOINT LEVEL

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

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

    <dispatch clause>    ::=   STATIC DISPATCH

    <returns clause>    ::=   RETURNS <returns type>

    <returns type>    ::=
             <returns data type> [ <result cast> ]
         |     <returns table type>

    <returns table type>    ::=   TABLE <table function column list>

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

    <table function column list element>    ::=   <column name> <data type>

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

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

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

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

    <SQL routine spec>    ::=   [ <rights clause> ] <SQL routine body>

    <rights clause>    ::=   SQL SECURITY INVOKER | SQL SECURITY DEFINER

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

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

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

    <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

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

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

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

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

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

    11.51 <alter routine statement> (p698)

    Alter a characteristic of an SQL-invoked routine.

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

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

    11.52 <drop routine statement> (p701)

    Destroy an SQL-invoked routine.

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

    11.53 <user-defined cast definition> (p703)

    Define a user-defined cast.

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

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

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

    <target data type>    ::=   <data type>

    11.54 <drop user-defined cast statement> (p705)

    Destroy a user-defined cast.

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

    11.55 <user-defined ordering definition> (p707)

    Define a user-defined ordering for a user-defined type.

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

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

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

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

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

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

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

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

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

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

    11.56 <drop user-defined ordering statement> (p710)

    Destroy a user-defined ordering method.

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

    11.57 <transform definition> (p712)

    Define one or more transform functions for a user-defined type.

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

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

    <group name>    ::=   <identifier>

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

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

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

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

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

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

    11.58 <alter transform statement> (p715)

    Change the definition of one or more transform groups.

    <alter transform statement>    ::=
             ALTER { TRANSFORM | TRANSFORMS } FOR <schema-resolved user-defined type name> <alter group> ...

    <alter group>    ::=   <group name> <left paren> <alter transform action list> <right paren>

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

    <alter transform action>    ::=   <add transform element list> | <drop transform element list>

    11.59 <add transform element list> (p717)

    Add a transform element (<to sql> and/or <from sql>) to an existing transform group.

    <add transform element list>    ::=   ADD <left paren> <transform element list> <right paren>

    11.60 <drop transform element list> (p719)

    Remove a transform element (<to sql> and/or <from sql>) from a transform group.

    <drop transform element list>    ::=   DROP <left paren> <transform kind> [ <comma> <transform kind> ] <drop behavior> <right paren>

    <transform kind>    ::=   TO SQL | FROM SQL

    11.61 <drop transform statement> (p721)

    Remove one or more transform functions associated with a transform.

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

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

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

    11.62 <sequence generator definition> (p724)

    Define an external sequence generator.

    <sequence generator definition>    ::=   CREATE SEQUENCE <sequence generator name> [ <sequence generator options> ]

    <sequence generator options>    ::=   <sequence generator option> ...

    <sequence generator option>    ::=   <sequence generator data type option> | <common sequence generator options>

    <common sequence generator options>    ::=   <common sequence generator option> ...

    <common sequence generator option>    ::=   <sequence generator start with option> | <basic sequence generator option>

    <basic sequence generator option>    ::=
             <sequence generator increment by option>
         |     <sequence generator maxvalue option>
         |     <sequence generator minvalue option>
         |     <sequence generator cycle option>

    <sequence generator data type option>    ::=   AS <data type>

    <sequence generator start with option>    ::=   START WITH <sequence generator start value>

    <sequence generator start value>    ::=   <signed numeric literal>

    <sequence generator increment by option>    ::=   INCREMENT BY <sequence generator increment>

    <sequence generator increment>    ::=   <signed numeric literal>

    <sequence generator maxvalue option>    ::=
             MAXVALUE <sequence generator max value>
         |     NO MAXVALUE

    <sequence generator max value>    ::=   <signed numeric literal>

    <sequence generator minvalue option>    ::=   MINVALUE <sequence generator min value> | NO MINVALUE

    <sequence generator min value>    ::=   <signed numeric literal>

    <sequence generator cycle option>    ::=   CYCLE | NO CYCLE

    11.63 <alter sequence generator statement> (p726)

    Change the definition of an external sequence generator.

    <alter sequence generator statement>    ::=
             ALTER SEQUENCE <sequence generator name> <alter sequence generator options>

    <alter sequence generator options>    ::=   <alter sequence generator option> ...

    <alter sequence generator option>    ::=
             <alter sequence generator restart option>
         |     <basic sequence generator option>

    <alter sequence generator restart option>    ::=   RESTART WITH <sequence generator restart value>

    <sequence generator restart value>    ::=   <signed numeric literal>

    11.64 <drop sequence generator statement> (p727)

    Destroy an external sequence generator.

    <drop sequence generator statement>    ::=   DROP SEQUENCE <sequence generator name> <drop behavior>

    Top


    12 Access control

    12.1 <grant statement> (p729)

    Define privileges and role authorizations.

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

    12.2 <grant privilege statement> (p734)

    Define privileges.

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

    12.3 <privileges> (p737)

    Specify privileges.

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

    <object name>    ::=
             [ TABLE ] <table name>
         |     DOMAIN <domain name>
         |     COLLATION <collation name>
         |     CHARACTER SET <character set name>
         |     TRANSLATION <transliteration name>
         |     TYPE <schema-resolved user-defined type name>
         |     SEQUENCE <sequence generator name>
         |     <specific routine designator>

    <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 method list>    ::=   <specific routine designator> [ { <comma> <specific routine designator> }... ]

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

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

    <grantor>    ::=   CURRENT_USER | CURRENT_ROLE

    12.4 <role definition> (p741)

    Define a role.

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

    12.5 <grant role statement> (p742)

    Define role authorizations.

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

    <role granted>    ::=   <role name>

    12.6 <drop role statement> (p744)

    Destroy a role.

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

    12.7 <revoke statement> (p745)

    Destroy privileges and role authorizations.

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

    Top


    13 SQL-client modules

    13.1 <SQL-client module definition> (p763)

    Define an SQL-client module.

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

    <module authorization clause>    ::=
             SCHEMA <schema name>
         |     AUTHORIZATION <module authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]
         |     SCHEMA <schema name> AUTHORIZATION <module authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]

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

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

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

    <module collations>    ::=   <module collation specification> ...

    <module collation specification>    ::=   COLLATION <collation name> [ FOR <character set specification list> ]

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

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

    13.2 <module name clause> (p768)

    Name an SQL-client module.

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

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

    13.3 <externally-invoked procedure> (p769)

    Define an externally-invoked procedure.

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

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

    <status parameter>    ::=   SQLSTATE

    13.4 Calls to an <externally-invoked procedure> (p772)

    13.5 <SQL procedure statement> (p788)

    Define all of the SQL-statements that are <SQL procedure statement>s.

    <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>
         |     <transliteration definition>
         |     <assertion definition>
         |     <trigger definition>
         |     <user-defined type definition>
         |     <user-defined cast definition>
         |     <user-defined ordering definition>
         |     <transform definition>
         |     <sequence generator definition>

    <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 transliteration statement>
         |     <drop assertion statement>
         |     <drop trigger statement>
         |     <alter type statement>
         |     <drop data type statement>
         |     <drop user-defined ordering statement>
         |     <alter transform statement>
         |     <drop transform statement> | <alter sequence generator statement>
         |     <drop sequence generator statement>

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

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

    <SQL control statement>    ::=
             <call statement>
         |     <return statement>

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

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

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

    <SQL diagnostics statement>    ::=   <get diagnostics statement>

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

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

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

    13.6 Data type correspondences (p796)

    Table 16 -- Data type correspondences for C
    SQL Data Type C Data Type
    SQLSTATE char, with length 6
    CHARACTER (L)3 char, with length (L+1)*k1
    CHARACTER VARYING (L)3 char, with length (L+1)*k1
    CHARACTER LARGE OBJECT(L)
    struct {
    long hvn3_reserved
    unsigned long hvn2_length
    char3 hvn2_data[L];
    } hvn2
    
    BINARY LARGE OBJECT(L)
     struct {
    long hvn2_reserved
    unsigned long hvn2_length
    char hvn2_data[L];
    } hvn2
    
    NUMERIC(P,S) None
    DECIMAL(P,S) None
    SMALLINT pointer to short
    INTEGER pointer to long
    BIGINT pointer to long long
    FLOAT(P) None
    REAL pointer to float
    DOUBLE PRECISION pointer to double
    BOOLEAN pointer to long
    DATE None
    TIME(T) None
    TIMESTAMP(T) None
    INTERVAL(Q) None
    user-defined type None
    REF char, with length N
    ROW None
    ARRAY None
    MULTISET None

    1 For character set UTF16, as well as other implementation-defined character sets in which a code unit occupies two octets, k is the length in units of C unsigned short of the character encoded using the greatest number of such units in the character set; for character set UTF32, as well as other implementation-defined character sets in which a code unit occupies four octets, k is four; for other character sets, k is the length in units of C char of the character encoded using the greatest number of such units in the character set.
    2 hvn is the name of the host variable defined to correspond to the SQL data type
    3 For character set UTF16, as well as other implementation-defined character sets in which a code unit occupies two octets, char or unsigned char should be replaced with unsigned short; for character set UTF32, as well as other implementation-defined character sets in which a code unit occupies four octets, char or unsigned char should be replaced with unsigned int. Otherwise, char or unsigned char should be used.

    Top


    14 Data manipulation

    14.1 <declare cursor> (p807)

    Define a cursor.

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

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

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

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

    14.2 <open statement> (p813)

    Open a cursor.

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

    14.3 <fetch statement> (p815)

    Position a cursor on a specified row of a table and retrieve values from that row.

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

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

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

    14.4 <close statement> (p820)

    Close a cursor.

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

    14.5 <select statement: single row> (p822)

    Retrieve values from a specified row of a table.

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

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

    14.6 <delete statement: positioned> (p826)

    Delete a row of a table.

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

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

    14.7 <delete statement: searched> (p829)

    Delete rows of a table.

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

    14.8 <insert statement> (p832)

    Create new rows in a table.

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

    <insertion target>    ::=   <table name>

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

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

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

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

    <from default>    ::=   DEFAULT VALUES

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

    14.9 <merge statement> (p837)

    Conditionally update rows of a table, or insert new rows into a table, or both.

    <merge statement>    ::=
             MERGE INTO <target table> [ [ AS ] <merge correlation name> ]
             USING <table reference> ON <search condition> <merge operation specification>

    <merge correlation name>    ::=   <correlation name>

    <merge operation specification>    ::=   <merge when clause> ...

    <merge when clause>    ::=   <merge when matched clause> | <merge when not matched clause>

    <merge when matched clause>    ::=   WHEN MATCHED THEN <merge update specification>

    <merge when not matched clause>    ::=   WHEN NOT MATCHED THEN <merge insert specification>

    <merge update specification>    ::=   UPDATE SET <set clause list>

    <merge insert specification>    ::=
             INSERT [ <left paren> <insert column list> <right paren> ]
             [ <override clause> ] VALUES <merge insert value list>

    <merge insert value list>    ::=
             <left paren> <merge insert value element> [ { <comma> <merge insert value element> }... ] <right paren>

    <merge insert value element>    ::=   <value expression> | <contextually typed value specification>

    14.10 <update statement: positioned> (p844)

    Update a row of a table.

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

    14.11 <update statement: searched> (p847)

    Update rows of a table.

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

    14.12 <set clause list> (p851)

    Specify a list of updates.

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

    <set clause>    ::=
             <multiple column assignment>
         |     <set target> <equals operator> <update source>

    <set target>    ::=   <update target> | <mutated set clause>

    <multiple column assignment>    ::=   <set target list> <equals operator> <assigned row>

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

    <assigned row>    ::=   <contextually typed row value expression>

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

    <object column>    ::=   <column name>

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

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

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

    14.13 <temporary table declaration> (p856)

    Declare a declared local temporary table.

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

    14.14 <free locator statement> (p858)

    Remove the association between a locator variable and the value that is represented by that locator.

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

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

    14.15 <hold locator statement> (p859)

    Mark a locator variable as being holdable.

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

    14.16 Effect of deleting rows from base tables (p860)

    14.17 Effect of deleting some rows from a derived table (p862)

    14.18 Effect of deleting some rows from a viewed table (p864)

    14.19 Effect of inserting tables into base tables (p865)

    14.20 Effect of inserting a table into a derived table (p867)

    14.21 Effect of inserting a table into a viewed table (p869)

    14.22 Effect of replacing rows in base tables (p871)

    14.23 Effect of replacing some rows in a derived table (p874)

    14.24 Effect of replacing some rows in a viewed table (p877)

    14.25 Execution of BEFORE triggers (p879)

    14.26 Execution of AFTER triggers (p880)

    14.27 Execution of triggers (p881)

    Top


    15 Control statements

    15.1 <call statement> (p883)

    Invoke an SQL-invoked routine.

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

    15.2 <return statement> (p884)

    Return a value from an SQL function.

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

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

    Top


    16 Transaction management

    16.1 <start transaction statement> (p885)

    Start an SQL-transaction and set its characteristics.

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

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

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

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

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

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

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

    16.2 <set transaction statement> (p888)

    Set the characteristics of the next SQL-transaction for the SQL-agent. NOTE 402 - This statement has no effect on any SQL-transactions subsequent to the next SQL-transaction.

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

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

    16.3 <set constraints mode statement> (p890)

    If an SQL-transaction is currently active, then set the constraint mode for that SQL-transaction in the current SQL-session. If no SQL-transaction is currently active, then set the constraint mode for the next SQL-transaction in the current SQL-session for the SQL-agent. NOTE 404 This statement has no effect on any SQL-transactions subsequent to this SQL-transaction.

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

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

    16.4 <savepoint statement> (p892)

    Establish a savepoint.

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

    <savepoint specifier>    ::=   <savepoint name>

    16.5 <release savepoint statement> (p893)

    Destroy a savepoint.

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

    16.6 <commit statement> (p894)

    Terminate the current SQL-transaction with commit.

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

    16.7 <rollback statement> (p896)

    Terminate the current SQL-transaction with rollback, or rollback all actions affecting SQL-data and/or schemas since the establishment of a savepoint.

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

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

    Top


    17 Connection management

    17.1 <connect statement> (p899)

    Establish an SQL-session.

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

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

    17.2 <set connection statement> (p902)

    Select an SQL-connection from the available SQL-connections.

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

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

    17.3 <disconnect statement> (p904)

    Terminate an SQL-connection.

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

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

    Top


    18 Session management

    18.1 <set session characteristics statement> (p907)

    Set one or more characteristics for the current SQL-session.

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

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

    <session characteristic>    ::=   <transaction characteristics>

    18.2 <set session user identifier statement> (p908)

    Set the SQL-session user identifier and the current user identifier of the current SQL-session context.

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

    18.3 <set role statement> (p909)

    Set the current role name for the current SQL-session context.

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

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

    18.4 <set local time zone statement> (p911)

    Set the default local time zone displacement for the current SQL-session.

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

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

    18.5 <set catalog statement> (p912)

    Set the default catalog name for unqualified <schema name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

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

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

    18.6 <set schema statement> (p913)

    Set the default schema name for unqualified <schema qualified name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

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

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

    18.7 <set names statement> (p915)

    Set the default character set name for <character string literal>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s that are invoked directly.

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

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

    18.8 <set path statement> (p916)

    Set the SQL-path used to determine the subject routine of <routine invocation>s with unqualified <routine name>s in <preparable statement>s that are prepared in the current SQL-session by an <execute immediate statement> or a <prepare statement> and in <direct SQL statement>s, respectively, that are invoked directly. The SQL-path remains the current SQL-path of the SQLsession until another SQL-path is successfully set.

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

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

    18.9 <set transform group statement> (p917)

    Set the group name that identifies the group of transform functions for mapping values of userdefined types to predefined data types.

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

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

    18.10 <set session collation statement> (p918)

    Set the SQL-session collation of the SQL-session for one or more character sets. An SQL-session collation remains effective until another SQL-session collation for the same character set is successfully set.

    <set session collation statement>    ::=
             SET COLLATION <collation specification> [ FOR <character set specification list> ]
         |     SET NO COLLATION [ FOR <character set specification list> ]

    <character set specification list>    ::=   <character set specification> [ , <character set specification> ... ]

    <collation specification>    ::=   <value specification>

    Top


    19 Dynamic SQL

    19.1 Description of SQL descriptor areas (p921)

    19.2 <allocate descriptor statement> (p931)

    Allocate an SQL descriptor area.

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

    <occurrences>    ::=   <simple value specification>

    19.3 <deallocate descriptor statement> (p933)

    Deallocate an SQL descriptor area.

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

    19.4 <get descriptor statement> (p934)

    Get information from an SQL descriptor area.

    <get descriptor statement>    ::=   GET [ SQL ] DESCRIPTOR <descriptor name> <get descriptor information>

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

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

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

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

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

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

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

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

    19.5 <set descriptor statement> (p937)

    Set information in an SQL descriptor area.

    <set descriptor statement>    ::=   SET [ SQL ] DESCRIPTOR <descriptor name> <set descriptor information>

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

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

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

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

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

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

    19.6 <prepare statement> (p941)

    Prepare a statement for execution.

    <prepare statement>    ::=
             PREPARE <SQL statement name> [ <attributes specification> ] FROM <SQL statement variable>

    <attributes specification>    ::=   ATTRIBUTES <attributes variable>

    <attributes variable>    ::=   <simple value specification>

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

    <preparable statement>    ::=
             <preparable SQL data statement>
         |     <preparable SQL schema statement>
         |     <preparable SQL transaction statement>
         |     <preparable SQL control statement>
         |     <preparable SQL session statement>
         |     <preparable implementation-defined statement>

    <preparable SQL data statement>    ::=
             <delete statement: searched>
         |     <dynamic single row select statement>
         |     <insert statement>
         |     <dynamic select statement>
         |     <update statement: searched>
         |     <merge statement>
         |     <preparable dynamic delete statement: positioned>
         |     <preparable dynamic update statement: positioned>

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

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

    <preparable SQL control statement>    ::=   <SQL control statement>

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

    <dynamic select statement>    ::=   <cursor specification>

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

    19.7 <cursor attributes> (p953)

    Specify a list of cursor attributes.

    <cursor attributes>    ::=   <cursor attribute> ...

    <cursor attribute>    ::=
             <cursor sensitivity>
         |     <cursor scrollability>
         |     <cursor holdability>
         |     <cursor returnability>

    19.8 <deallocate prepared statement> (p954)

    Deallocate SQL-statements that have been prepared with a <prepare statement>.

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

    19.9 <describe statement> (p955)

    Obtain information about the <select list> columns or <dynamic parameter specification>s contained in a prepared statement or about the columns of the result set associated with a cursor.

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

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

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

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

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

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

    19.10 <input using clause> (p961)

    Supply input values for an <SQL dynamic statement>.

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

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

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

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

    19.11 <output using clause> (p965)

    Supply output variables for an <SQL dynamic statement>.

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

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

    <into argument>    ::=   <target specification>

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

    19.12 <execute statement> (p970)

    Associate input SQL parameters and output targets with a prepared statement and execute the statement.

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

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

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

    19.13 <execute immediate statement> (p972)

    Dynamically prepare and execute a preparable statement.

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

    19.14 <dynamic declare cursor> (p973)

    Declare a cursor to be associated with a <statement name>, which may in turn be associated with a <cursor specification>.

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

    19.15 <allocate cursor statement> (p974)

    Define a cursor based on a prepared statement for a <cursor specification> or assign a cursor to the ordered set of result sets returned from an SQL-invoked procedure.

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

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

    <statement cursor>    ::=
             [ <cursor sensitivity> ] [ <cursor scrollability> ] CURSOR
             [ <cursor holdability> ] [ <cursor returnability> ] FOR <extended statement name>

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

    19.16 <dynamic open statement> (p976)

    Associate input dynamic parameters with a <cursor specification> and open the cursor.

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

    19.17 <dynamic fetch statement> (p977)

    Fetch a row for a cursor declared with a <dynamic declare cursor>.

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

    19.18 <dynamic single row select statement> (p978)

    Retrieve values from a dynamically-specified row of a table.

    <dynamic single row select statement>    ::=   <query specification>

    19.19 <dynamic close statement> (p979)

    Close a cursor.

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

    19.20 <dynamic delete statement: positioned> (p980)

    Delete a row of a table.

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

    19.21 <dynamic update statement: positioned> (p982)

    Update a row of a table.

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

    19.22 <preparable dynamic delete statement: positioned> (p984)

    Delete a row of a table through a dynamic cursor.

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

    19.23 <preparable dynamic update statement: positioned> (p986)

    Update a row of a table through a dynamic cursor.

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

    Top


    20 Embedded SQL

    20.1 <embedded SQL host program> (p989)

    Specify an <embedded SQL host program>.

    <embedded SQL host program>    ::=
             <embedded SQL Ada program>
         |     <embedded SQL C program>
         |     <embedded SQL COBOL program>
         |     <embedded SQL Fortran program>
         |     <embedded SQL MUMPS program>
         |     <embedded SQL Pascal program>
         |     <embedded SQL PL/I program>

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

    <statement or declaration>    ::=
             <declare cursor>
         |     <dynamic declare cursor>
         |     <temporary table declaration>
         |     <embedded authorization declaration>
         |     <embedded path specification>
         |     <embedded transform group specification>
         |     <embedded collation specification>
         |     <embedded exception declaration>
         |     <handler declaration>
         |     <SQL procedure statement>

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

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

    <embedded authorization declaration>    ::=   DECLARE <embedded authorization clause>

    <embedded authorization clause>    ::=
             SCHEMA <schema name>
         |     AUTHORIZATION <embedded authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]
         |     SCHEMA <schema name> AUTHORIZATION <embedded authorization identifier> [ FOR STATIC { ONLY | AND DYNAMIC } ]

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

    <embedded path specification>    ::=   <path specification>

    <embedded transform group specification>    ::=   <transform group specification>

    <embedded collation specification>    ::=   <module collations>

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

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

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

    <embedded SQL end declare>    ::=   <SQL prefix> END DECLARE SECTION [ <SQL terminator> ]

    <embedded SQL MUMPS declare>    ::=
             <SQL prefix> BEGIN DECLARE SECTION [ <embedded character set declaration> ]
             [ <host variable definition> ... ] END DECLARE SECTION <SQL terminator>

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

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

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

    20.2 <embedded exception declaration> (p1001)

    Specify the action to be taken when an SQL-statement causes a specific class of condition to be raised.

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

    <condition>    ::=   <SQL condition>

    <SQL condition>    ::=
             <major category>
         |     SQLSTATE ( <SQLSTATE class value> [ , <SQLSTATE subclass value> ] )
         |     CONSTRAINT <constraint name>

    <major category>    ::=   SQLEXCEPTION | SQLWARNING | NOT FOUND

    <SQLSTATE class value>    ::=   <SQLSTATE char> <SQLSTATE char> !! See the Syntax Rules.

    <SQLSTATE subclass value>    ::=   <SQLSTATE char> <SQLSTATE char> <SQLSTATE char> !! See the Syntax Rules.

    <SQLSTATE char>    ::=   <simple Latin upper case letter> | <digit>

    <condition action>    ::=   CONTINUE | <go to>

    <go to>    ::=   { GOTO | GO TO } <goto target>

    <goto target>    ::=
             <host label identifier>
         |     <unsigned integer>
         |     <host PL/I label variable>

    <host label identifier>    ::=   !! See the Syntax Rules.

    <host PL/I label variable>    ::=   !! See the Syntax Rules.

    20.3 <embedded SQL Ada program> (p1005)

    Specify an <embedded SQL Ada program>.

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

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

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

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

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

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

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

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

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

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

    <Ada CLOB locator variable>    ::=   SQL TYPE IS CLOB AS LOCATOR

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

    <Ada BLOB locator variable>    ::=   SQL TYPE IS BLOB AS LOCATOR

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

    <Ada user-defined type locator variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

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

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

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

    20.4 <embedded SQL C program> (p1011)

    Specify an <embedded SQL C program>.

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

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

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

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

    <C class modifier>    ::=   const | volatile

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

    <C character variable>    ::=
             <C character type> [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> <C array specification> [ <C initial value> ]
             [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] }... ]

    <C character type>    ::=   char | unsigned char | unsigned short

    <C array specification>    ::=   <left bracket> <length> <right bracket>

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

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

    <C VARCHAR variable>    ::=
             VARCHAR [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> <C array specification> [ <C initial value> ]
             [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] }... ]

    <C NCHAR variable>    ::=
             NCHAR [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> <C array specification> [ <C initial value> ]
             [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] } ... ]

    <C NCHAR VARYING variable>    ::=
             NCHAR VARYING [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> <C array specification> [ <C initial value> ]
             [ { <comma> <C host identifier> <C array specification> [ <C initial value> ] } ... ]

    <C CLOB variable>    ::=
             SQL TYPE IS CLOB <left paren> <large object length> <right paren>
             [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] }... ]

    <C NCLOB variable>    ::=
             SQL TYPE IS NCLOB <left paren> <large object length> <right paren>
             [ CHARACTER SET [ IS ] <character set specification> ]
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] }... ]

    <C user-defined type variable>    ::=
             SQL TYPE IS <path-resolved user-defined type name> AS <predefined type>
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C BLOB variable>    ::=
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C CLOB locator variable>    ::=
             SQL TYPE IS CLOB AS LOCATOR
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C BLOB locator variable>    ::=
             SQL TYPE IS BLOB AS LOCATOR
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C array locator variable>    ::=
             SQL TYPE IS <array type> AS LOCATOR
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C multiset locator variable>    ::=
             SQL TYPE IS <multiset type> AS LOCATOR
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] } ... ]

    <C user-defined type locator variable>    ::=
             SQL TYPE IS
             <path-resolved user-defined type name> AS LOCATOR
             <C host identifier> [ <C initial value> ]
             [ { <comma> <C host identifier> [ <C initial value> ] }... ]

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

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

    20.5 <embedded SQL COBOL program> (p1019)

    Specify an <embedded SQL COBOL program>.

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

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

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

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

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

    <COBOL character type>    ::=
             [ CHARACTER SET [ IS ] <character set specification> ]
             { PIC | PICTURE } [ IS ] { X [ <left paren> <length> <right paren> ] }...

    <COBOL national character type>    ::=
             [ CHARACTER SET [ IS ] <character set specification> ]
             { PIC | PICTURE } [ IS ] { N [ <left paren> <length> <right paren> ] }...

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

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

    <COBOL BLOB variable>    ::=
             [ USAGE [ IS ] ]
             SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <COBOL user-defined type variable>    ::=
             [ USAGE [ IS ] ] SQL TYPE IS <path-resolved user-defined type name> AS <predefined type>

    <COBOL CLOB locator variable>    ::=
             [ USAGE [ IS ] ] SQL TYPE IS CLOB AS LOCATOR

    <COBOL BLOB locator variable>    ::=
             [ USAGE [ IS ] ] SQL TYPE IS BLOB AS LOCATOR

    <COBOL array locator variable>    ::=
         [ USAGE [ IS ] ] SQL TYPE IS <array type> AS LOCATOR

    <COBOL multiset locator variable>    ::=
         [ USAGE [ IS ] ] SQL TYPE IS <multiset type> AS LOCATOR

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

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

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

    <COBOL nines specification>    ::=
             <COBOL nines> [ V [ <COBOL nines> ] ]
         |     V <COBOL nines>

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

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

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

    20.6 <embedded SQL Fortran program> (p1025)

    Specify an <embedded SQL Fortran program>.

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

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

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

    <Fortran type specification>    ::=
             CHARACTER [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
         |     CHARACTER KIND = n [ <asterisk> <length> ] [ CHARACTER SET [ IS ] <character set specification> ]
         |     INTEGER
         |     REAL
         |     DOUBLE PRECISION
         |     LOGICAL
         |     <Fortran derived type specification>

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

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

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

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

    <Fortran CLOB locator variable>    ::=   SQL TYPE IS CLOB AS LOCATOR

    <Fortran BLOB locator variable>    ::=   SQL TYPE IS BLOB AS LOCATOR

    <Fortran user-defined type locator variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

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

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

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

    20.7 <embedded SQL MUMPS program> (p1030)

    Specify an <embedded SQL MUMPS program>.

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

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

    <MUMPS character variable>    ::=
             VARCHAR <MUMPS host identifier> <MUMPS length specification>
             [ { <comma> <MUMPS host identifier> <MUMPS length specification> }... ]

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

    <MUMPS length specification>    ::=   <left paren> <length> <right paren>

    <MUMPS numeric variable>    ::=   <MUMPS type specification> <MUMPS host identifier> [ { <comma> <MUMPS host identifier> }... ]

    <MUMPS type specification>    ::=
             INT
         |     DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
         |     REAL

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

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

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

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

    <MUMPS CLOB locator variable>    ::=   SQL TYPE IS CLOB AS LOCATOR

    <MUMPS BLOB locator variable>    ::=   SQL TYPE IS BLOB AS LOCATOR

    <MUMPS user-defined type locator variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

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

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

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

    20.8 <embedded SQL Pascal program> (p1035)

    Specify an <embedded SQL Pascal program>.

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

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

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

    <Pascal type specification>    ::=
             PACKED ARRAY <left bracket> 1 <double period> <length> <right bracket> OF CHAR
             [ CHARACTER SET [ IS ] <character set specification> ]
         |     INTEGER
         |     REAL
         |     CHAR [ CHARACTER SET [ IS ] <character set specification> ]
         |     BOOLEAN
         |     <Pascal derived type specification>

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

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

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

    <Pascal CLOB locator variable>    ::=   SQL TYPE IS CLOB AS LOCATOR

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

    <Pascal BLOB locator variable>    ::=   SQL TYPE IS BLOB AS LOCATOR

    <Pascal user-defined type locator variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

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

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

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

    20.9 <embedded SQL PL/I program> (p1040)

    Specify an <embedded SQL PL/I program>.

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

    <PL/I variable definition>    ::=
             { DCL | DECLARE } { <PL/I host identifier>
         |     <left paren> <PL/I host identifier> [ { <comma> <PL/I host identifier> }... ] <right paren> }
             <PL/I type specification> [ <character representation> ... ] <semicolon>

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

    <PL/I type specification>    ::=
             { CHAR | CHARACTER } [ VARYING ] <left paren> <length> <right paren> [ CHARACTER SET [ IS ] <character set specification> ]
         |     <PL/I type fixed decimal> <left paren> <precision> [ <comma> <scale> ] <right paren>
         |     <PL/I type fixed binary> [ <left paren> <precision> <right paren> ]
         |     <PL/I type float binary> <left paren> <precision> <right paren>
         |     <PL/I derived type specification>

    <PL/I derived type specification>    ::=
             <PL/I CLOB variable>
         |     <PL/I BLOB variable>
         |     <PL/I user-defined type variable>
         |     <PL/I CLOB locator variable>
         |     <PL/I BLOB locator variable>
         |     <PL/I user-defined type locator variable>
         |     <PL/I array locator variable>
         |     <PL/I multiset locator variable>
         |     <PL/I REF variable>

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

    <PL/I BLOB variable>    ::=   SQL TYPE IS BLOB <left paren> <large object length> <right paren>

    <PL/I user-defined type variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS <predefined type>

    <PL/I CLOB locator variable>    ::=   SQL TYPE IS CLOB AS LOCATOR

    <PL/I BLOB locator variable>    ::=   SQL TYPE IS BLOB AS LOCATOR

    <PL/I user-defined type locator variable>    ::=   SQL TYPE IS <path-resolved user-defined type name> AS LOCATOR

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

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

    <PL/I REF variable>    ::=   SQL TYPE IS <reference type>

    <PL/I type fixed decimal>    ::=
             { DEC | DECIMAL } FIXED
         |     FIXED { DEC | DECIMAL }

    <PL/I type fixed binary>    ::=
             { BIN | BINARY } FIXED
         |     FIXED { BIN | BINARY }

    <PL/I type float binary>    ::=
             { BIN | BINARY } FLOAT
         |     FLOAT { BIN | BINARY }

    Top


    21 Direct invocation of SQL

    21.1 <direct SQL statement> (p1047)

    Specify direct execution of SQL.

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

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

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

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

    21.2 <direct select statement: multiple rows> (p1051)

    Specify a statement to retrieve multiple rows from a specified table.

    <direct select statement: multiple rows>    ::=   <cursor specification>

    Top


    22 Diagnostics management

    22.1 <get diagnostics statement> (p1053)

    Get exception or completion condition information from a diagnostics area.

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

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

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

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

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

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

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

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

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

    22.2 Pushing and popping the diagnostics area stack (p1068)

    Top


    23 Status codes

    23.1 SQLSTATE (p1069)

    The character string value returned in an SQLSTATE parameter comprises a 2-character class value followed by a 3-character subclass value, each with an implementation-defined character set that has a one-octet character encoding form and is restricted to <digit>s and <simple Latin upper case letter>s. Table 31, 'SQLSTATE class and subclass values', specifies the class value for each condition and the subclass value or values for each class value.

    Class values that begin with one of the <digit>s '0', '1', '2', '3', or '4' or one of the <simple Latin upper case letter>s 'A', 'B', 'C', 'D', 'E', 'F', 'G', or 'H' are returned only for conditions defined in ISO/IEC 9075 or in any other International Standard. The range of such class values are called standard-defined classes. Some such class codes are reserved for use by specific International Standards, as specified elsewhere in this Clause. Subclass values associated with such classes that also begin with one of those 13 characters are returned only for conditions defined in ISO/IEC 9075 or some other International Standard. The range of such class values are called standard-defined classes. Subclass values associated with such classes that begin with one of the <digit>s '5', '6', '7', '8', or '9' or one of the <simple Latin upper case letter>s 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z' are reserved for implementation-specified conditions and are called implementation-defined subclasses.

    Class values that begin with one of the <digit>s '5', '6', '7', '8', or '9' or one of the <simple Latin upper case letter>s 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z' are reserved for implementation-specified exception conditions and are called implementation-defined classes. All subclass values except '000', which means no subclass, associated with such classes are reserved for implementation-specified conditions and are called implementation-defined subclasses. An implementation-defined completion condition shall be indicated by returning an implementation-defined subclass in conjunction with one of the classes successful completion, warning, or no data.

    The 'Category' column has the following meanings: 'S' means that the class value given corresponds to successful completion and is a completion condition; 'W' means that the class value given corresponds to a successful completion but with a warning and is a completion condition; 'N' means that the class value given corresponds to a no-data situation and is a completion condition; 'X' means that the class value given corresponds to an exception condition.

    Table 31 - SQLSTATE class and subclass values

    Category Condition Class Subcondition Subclass
    X ambiguous cursor name 3C (no subclass) 000
    X attempt to assign to non-updatable column 0U (no subclass) 000
    X attempt to assign to ordering column 0V (no subclass) 000
    X cardinality violation 21 (no subclass) 000
    X connection exception 08 (no subclass) 000
          connection does not exist 003
          connection failure 006
          connection name in use 002
          SQL-client unable to establish SQL-connection 001
          SQL-server rejected establishment of SQL-connection 004
          transaction resolution unknown 007
    X cursor sensitivity exception 36 (no subclass) 000
          request failed 002
          request rejected 001
    X data exception 22 (no subclass) 000
          array data, right truncation 02F
          array element error 02E
          character not in repertoire 021
          datetime field overflow 008
          division by zero 012
          error in assignment 005
          escape character conflict 00B
          indicator overflow 022
          interval field overflow 015
          invalid argument for natural logarithm 01E
          invalid argument for power function 01F
          invalid argument for width bucket function 01G
          invalid character value for cast 018
          invalid datetime format 007
          invalid escape character 019
          invalid escape octet 00D
          invalid escape sequence 025
          invalid indicator parameter value 010
          invalid interval format 006
          invalid parameter value 023
          invalid preceding or following size in window function 013
          invalid regular expression 01B
          invalid repeat argument in a sample clause 02G
          invalid sample size 02H
          invalid time zone displacement value 009
          invalid use of escape character 00C
          most specific type mismatch 00G
          noncharacter in UCS string 029
          null value substituted for mutator subject parameter 02D
          null row not permitted in table 01C
          null value in array target 00E
          null value, no indicator parameter 002
          null value not allowed 004
          numeric value out of range 003
          sequence generator limit exceeded 00H
          string data, length mismatch 026
          string data, right truncation 001
          substring error 011
          trim error 027
          unterminated C string 024
          zero-length character string 00F
    X dependent privilege descriptors still exist 2B (no subclass) 000
    X diagnostics exception 0Z (no subclass) 000
          maximum number of stacked diagnostics areas exceeded 001
    X dynamic SQL error 07 (no subclass) 000
          cursor specification cannot be executed 003
          data type transform function violation 00B
          invalid DATA target 00D
          invalid DATETIME_INTERVAL_CODE 00F
          invalid descriptor count 008
          invalid descriptor index 009
          invalid LEVEL value 00E
          prepared statement not a cursor specification 005
          restricted data type attribute violation 006
          undefined DATA value 00C
          using clause does not match dynamic parameter specifications 001
          using clause does not match target specifications 002
          using clause required for dynamic parameters 004
          using clause required for result fields 007
    X external routine exception 38 (no subclass) 000
          containing SQL not permitted 001
          modifying SQL-data not permitted 002
          prohibited SQL-statement attempted 003
          reading SQL-data not permitted 004
    X external routine invocation exception 39 (no subclass) 000
          invalid SQLSTATE returned 001
          null value not allowed 004
    X feature not supported 0A (no subclass) 000
          multiple server transactions 001
    X integrity constraint violation 23 (no subclass) 000
          restrict violation 001
    X invalid authorization specification 28 (no subclass) 000
    X invalid catalog name 3D (no subclass) 000
    X invalid character set name 2C (no subclass) 000
    X invalid condition number 35 (no subclass) 000
    X invalid connection name 2E (no subclass) 000
    X invalid cursor name 34 (no subclass) 000
    X invalid cursor state 24 (no subclass) 000
    X invalid grantor 0L (no subclass) 000
    X invalid role specification 0P (no subclass) 000
    X invalid schema name 3F (no subclass) 000
    X invalid schema name list specification 0E (no subclass) 000
    X invalid session collation specification 2H (no subclass) 000
    X invalid SQL descriptor name 33 (no subclass) 000
    X invalid SQL-invoked procedure reference 0M (no subclass) 000
    X invalid SQL statement name 26 (no subclass) 000
    X invalid SQL statement identifier 30 (no subclass) 000
    X invalid target type specification 0D (no subclass) 000
    X invalid transaction initiation 0B (no subclass) 000
    X invalid transaction state 25 (no subclass) 000
          active SQL-transaction 001
          branch transaction already active 002
          held cursor requires same isolation level 008
          inappropriate access mode for branch transaction 003
          inappropriate isolation level for branch transaction 004
          no active SQL-transaction for branch transaction 005
          read-only SQL-transaction 006
          schema and data statement mixing not supported 007
    X invalid transaction termination 2D (no subclass) 000
    X invalid transform group name specification 0S (no subclass) 000
    X locator exception 0F (no subclass) 000
          invalid specification 001
    N no data 02 (no subclass) 000
          no additional dynamic result sets returned 001
    X prohibited statement encountered during trigger execution 0W (no subclass) 000
    X Remote Database Access HZ (See Table 32, 'SQLSTATE class codes for RDA', for the definition of protocol subconditions and subclass code values)  
    X savepoint exception 3B (no subclass) 000
          invalid specification 001
          too many 002
    X SQL routine exception 2F (no subclass) 000
          function executed no return statement 005
          modifying SQL-data not permitted 002
          prohibited SQL-statement attempted 003
          reading SQL-data not permitted 004
    S successful completion 00 (no subclass) 000
    X syntax error or access rule violation 42 (no subclass) 000
    X target table disagrees with cursor specification 0T (no subclass) 000
    X transaction rollback 40 (no subclass) 000
          integrity constraint violation 002
          serialization failure 001
          statement completion unknown 003
          triggered action exception 004
    X triggered action exception 09 (no subclass) 000
    X triggered data change violation 27 (no subclass) 000
    W warning 01 (no subclass) 000
          additional result sets returned 00D
          array data, right truncation 02F
          attempt to return too many result sets 00E
          cursor operation conflict 001
          default value too long for information schema 00B
          disconnect error 002
          dynamic result sets returned 00C
          external routine warning (the value of xx to be chosen by the author of the external routine) Hxx
          insufficient item descriptor areas 005
          null value eliminated in set function 003
          privilege not granted 007
          privilege not revoked 006
          query expression too long for information schema 00A
          search condition too long for information schema 009
          statement too long for information schema 008
          string data, right truncation 004
    X with check option violation 44 (no subclass) 000

    Top


    24 Conformance

    24.1 General Conformance Requirements (p1079)

    Table 33 - Implied feature relationships

    Feature ID Feature Description Implied Feature ID Implied Feature Description
    B032 Extended dynamic SQL B031 Basic dynamic SQL
    B034 Dynamic specification of cursor attributes B031 Basic dynamic SQL
    F381 Extended schema manipulation F491 Constraint management
    F451 Character set definition F461 Named character sets
    F711 ALTER domain F251 Domain support
    F801 Full set function F441 Extended set function support
    S024 Enhanced structured types S023 Basic structured types
    S041 Basic reference types S023 Basic structured types
    S041 Basic reference types S051 Create table of type
    S043 Enhanced reference types S041 Basic reference types
    S051 Create table of type S023 Basic structured types
    S081 Subtables S023 Basic structured types
    S081 Subtables S051 Create table of type
    S092 Arrays of user-defined types S091 Basic array support
    S094 Arrays of reference types S041 Basic reference types
    S094 Arrays of reference types S091 Basic array support
    S095 Array constructors by query S091 Basic array support
    S096 Optional array bounds S091 Basic array support
    S111 ONLY in query expressions S023 Basic structured types
    S111 ONLY in query expressions S051 Create table of type
    S201 SQL-invoked routines on arrays S091 Basic array support
    S202 SQL-invoked routines on multisets S271 Basic multiset support
    S231 Structured type locators S023 Basic structured types
    S232 Array locators S091 Basic array support
    S233 Multiset locators S271 Basic multiset support
    S242 Alter transform statement S241 Transform functions
    S272 Multisets of user-defined types S271 Basic multiset support
    S274 Multisets of reference types S041 Basic reference types
    S274 Multisets of reference types S271 Basic multiset support
    S275 Advanced multiset support S271 Basic multiset support
    T042 Extended LOB data type support T041 Basic LOB data type support
    T061 UCS Support F461 Named character sets
    T071 BIGINT data type E001-01 INTEGER and SMALLINT data types (including all spellings)
    T131 Recursive query T121 WITH (excluding RECURSIVE) in query expression
    T173 Extended LIKE clause in table definition T171 LIKE clause in table definition
    T212 Enhanced trigger capability T211 Basic trigger capability
    T332 Extended roles T331 Basic roles
    T511 Transaction counts F121 Basic diagnostics management
    T571 Array-returning external SQL-invoked functions S091 Basic array support
    T571 Array-returning external SQL-invoked functions S201 SQL-invoked routines on arrays
    T572 Multiset-returning external SQLinvoked functions S202 SQL-invoked routines on multisets
    T572 Multiset-returning external SQLinvoked functions S271 Basic multiset support
    T612 Advanced OLAP operations T611 Elementary OLAP operations

    Top


    END OF SQL-2003 Part 2 (SQL/Foundation) GRAMMAR

    Notes on Automatically Converting the SQL Grammar to a YACC Grammar

    Automatic translation of this grammar is non-trivial for a number of reasons. One is that the grammar has a number of actions '!! See the Syntax Rules' which cannot be translated automatically. Another is that the grammar contains rules that are usually better handled by the lexical analyzer than the grammar proper. Then there are incomplete rules such as those which reference parts 6 to 10 (they are not defined; indeed, part 7, which was going to be SQL/Temporal, is in complete abeyance), and the packages (almost completely undefined in the grammar). It is not clear whether these can be ignored, or annotated out of the way.

    Another complication is automatically generating rules to deal with optional components and repetitive components in the grammar. Square brackets do not contain alternative non-terminals; all those expressions are contained within curly brackets within the square brackets. However, some square brackets do contain alternative terminals. Curly brackets contain and group mandatory elements. However, they are usually used in conjunction with the 'one or more times' repeater ellipsis '...' mark.

    Top


    END OF SQL 2003-2 (SQL/FOUNDATION) GRAMMAR



    Cross-Reference Table: Rules

    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    Rule (non-terminal) Rules using it
    absolute value expression <numeric value function>
    action <object privileges>
    actual identifier <identifier>
    Ada array locator variable <Ada derived type specification>
    Ada assignment operator <Ada initial value>
    Ada BLOB locator variable <Ada derived type specification>
    Ada BLOB variable <Ada derived type specification>
    Ada CLOB locator variable <Ada derived type specification>
    Ada CLOB variable <Ada derived type specification>
    Ada derived type specification <Ada type specification>
    Ada host identifier <Ada variable definition> <host identifier>
    Ada initial value <Ada variable definition>
    Ada multiset locator variable <Ada derived type specification>
    Ada qualified type specification <Ada type specification>
    Ada REF variable <Ada derived type specification>
    Ada type specification <Ada variable definition>
    Ada unqualified type specification <Ada type specification>
    Ada user-defined type locator variable <Ada derived type specification>
    Ada user-defined type variable <Ada derived type specification>
    Ada variable definition <host variable definition>
    add attribute definition <alter type action>
    add column definition <alter table action>
    add column scope clause <alter column action>
    add domain constraint definition <alter domain action>
    add original method specification <alter type action>
    add overriding method specification <alter type action>
    add table constraint definition <alter table action>
    add transform element list <alter transform action>
    aggregate function <set function specification> <window function type>
    all <quantifier>
    all fields column name list <all fields reference>
    all fields reference <qualified asterisk>
    allocate cursor statement <SQL dynamic data statement>
    allocate descriptor statement <system descriptor statement>
    alter column action <alter column definition>
    alter column definition <alter table action>
    alter domain action <alter domain statement>
    alter domain statement <SQL schema manipulation statement>
    alter group <alter transform statement>
    alter identity column option <alter identity column specification>
    alter identity column specification <alter column action>
    alter routine behavior <alter routine statement>
    alter routine characteristic <alter routine characteristics>
    alter routine characteristics <alter routine statement>
    alter routine statement <SQL schema manipulation statement>
    alter sequence generator option <alter sequence generator options>
    alter sequence generator options <alter sequence generator statement>
    alter sequence generator restart option <alter identity column option> <alter sequence generator option>
    alter sequence generator statement <SQL schema manipulation statement>
    alter table action <alter table statement>
    alter table statement <SQL schema manipulation statement>
    alter transform action <alter transform action list>
    alter transform action list <alter group>
    alter transform statement <SQL schema manipulation statement>
    alter type statement <SQL schema manipulation statement>
    ampersand <SQL prefix> <SQL special character> <Unicode character string literal> <Unicode delimited identifier>
    approximate numeric literal <unsigned numeric literal>
    approximate numeric type <numeric type>
    array concatenation <array value expression>
    array element <array element list>
    array element list <array value constructor by enumeration>
    array element reference <nonparenthesized value expression primary>
    array factor <array concatenation> <array value expression>
    array type <Ada array locator variable> <C array locator variable> <COBOL array locator variable> <collection type> <Fortran array locator variable> <MUMPS array locator variable> <Pascal array locator variable> <PL/I array locator variable>
    array value constructor <collection value constructor>
    array value constructor by enumeration <array value constructor>
    array value constructor by query <array value constructor>
    array value expression <array element reference> <array value expression 1> <collection value expression>
    array value expression 1 <array concatenation>
    as clause <derived column>
    as subquery clause <table contents source>
    assertion definition <schema element> <SQL schema definition statement>
    assigned row <multiple column assignment>
    asterisk <aggregate function> <all fields reference> <bracketed comment introducer> <bracketed comment terminator> <Fortran type specification> <interval term> <qualified asterisk> <regular factor> <select list> <SQL special character> <term>
    asterisked identifier <asterisked identifier chain>
    asterisked identifier chain <qualified asterisk>
    attribute default <attribute definition>
    attribute definition <add attribute definition> <member>
    attribute name <attribute definition> <dereference operation> <drop attribute definition> <list of attributes>
    attribute or method reference <nonparenthesized value expression primary>
    attributes specification <prepare statement>
    attributes variable <attributes specification>
    authorization identifier <grantee> <module authorization identifier> <schema authorization identifier>
    basic identifier chain <column reference> <SQL parameter reference>
    basic sequence generator option <alter identity column option> <alter sequence generator option> <common sequence generator option>
    between predicate <predicate>
    between predicate part 2 <between predicate> <when operand>
    binary large object string type <predefined type>
    binary set function <aggregate function>
    binary set function type <binary set function>
    binary string literal <general literal>
    bit string literal <nondelimiter token>
    blob concatenation <blob value expression>
    blob factor <blob concatenation> <blob value expression>
    blob overlay function <blob value function>
    blob position expression <position expression>
    blob primary <blob factor>
    blob substring function <blob value function>
    blob trim function <blob value function>
    blob trim operands <blob trim function>
    blob trim source <blob trim operands>
    blob value expression <blob concatenation> <blob overlay function> <blob position expression> <blob substring function> <blob trim source> <escape octet> <octet pattern> <string value expression> <trim octet>
    blob value function <string value function>
    boolean factor <boolean term>
    boolean literal <general literal>
    boolean predicand <boolean primary> <row value constructor predicand>
    boolean primary <boolean test>
    boolean term <boolean term> <boolean value expression>
    boolean test <boolean factor>
    boolean type <predefined type>
    boolean value expression <boolean value expression> <contextually typed row value constructor> <parenthesized boolean value expression> <row value constructor> <search condition> <value expression>
    bracketed comment <comment>
    bracketed comment contents <bracketed comment>
    bracketed comment introducer <bracketed comment>
    bracketed comment terminator <bracketed comment>
    C array locator variable <C derived variable>
    C array specification <C character variable> <C NCHAR variable> <C NCHAR VARYING variable> <C VARCHAR variable>
    C BLOB locator variable <C derived variable>
    C BLOB variable <C derived variable>
    C character type <C character variable>
    C character variable <C variable specification>
    C class modifier <C variable definition>
    C CLOB locator variable <C derived variable>
    C CLOB variable <C derived variable>
    C derived variable <C variable specification>
    C host identifier <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable> <host identifier>
    C initial value <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable>
    C multiset locator variable <C derived variable>
    C NCHAR variable <C derived variable>
    C NCHAR VARYING variable <C derived variable>
    C NCLOB variable <C derived variable>
    C numeric variable <C variable specification>
    C REF variable <C derived variable>
    C storage class <C variable definition>
    C user-defined type locator variable <C derived variable>
    C user-defined type variable <C derived variable>
    C VARCHAR variable <C derived variable>
    C variable definition <host variable definition>
    C variable specification <C variable definition>
    call statement <SQL control statement>
    cardinality expression <numeric value function>
    case abbreviation <case expression>
    case expression <nonparenthesized value expression primary>
    case operand <simple case>
    case specification <case expression>
    cast function <user-defined cast definition>
    cast operand <cast specification>
    cast option <user-defined type option>
    cast specification <nonparenthesized value expression primary>
    cast target <cast specification>
    cast to distinct <cast option>
    cast to distinct identifier <cast to distinct>
    cast to ref <ref cast option>
    cast to ref identifier <cast to ref>
    cast to source <cast option>
    cast to source identifier <cast to source>
    cast to type <ref cast option>
    cast to type identifier <cast to type>
    catalog name <schema name>
    catalog name characteristic <set catalog statement>
    ceiling function <numeric value function>
    char length expression <length expression>
    char length units <char length expression> <character overlay function> <character substring function> <large object length> <string position expression>
    character enumeration <character enumeration exclude> <character enumeration include> <regular character set>
    character enumeration exclude <regular character set>
    character enumeration include <regular character set>
    character factor <character value expression> <concatenation>
    character like predicate <like predicate>
    character like predicate part 2 <character like predicate> <when operand>
    character overlay function <character value function>
    character pattern <character like predicate part 2>
    character primary <character factor>
    character representation <Ada initial value> <C initial value> <character string literal> <COBOL variable definition> <national character string literal> <PL/I variable definition> <Unicode representation>
    character set definition <schema element> <SQL schema definition statement>
    character set name <character set definition> <drop character set statement> <implementation-defined character set name> <object name> <standard character set name> <user-defined character set name>
    character set name characteristic <set names statement>
    character set source <character set definition>
    character set specification <Ada CLOB variable> <Ada qualified type specification> <C character variable> <C CLOB variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C VARCHAR variable> <character set source> <character set specification list> <character string literal> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <collation definition> <embedded character set declaration> <Fortran CLOB variable> <Fortran type specification> <module character set specification> <MUMPS CLOB variable> <Pascal CLOB variable> <Pascal type specification> <PL/I CLOB variable> <PL/I type specification> <predefined type> <schema character set specification> <source character set specification> <target character set specification> <Unicode character string literal>
    character set specification list <module collation specification> <set session collation statement>
    character specifier <character enumeration> <regular primary>
    character string literal <delimiter token> <external routine name> <general literal>
    character string type <predefined type>
    character substring function <character value function>
    character transliteration <character value function>
    character value expression <character overlay function> <character pattern> <character substring function> <character transliteration> <concatenation> <escape character> <fold> <normalize function> <regular expression substring function> <similar pattern> <string value expression> <transcoding> <trim character> <trim source>
    character value function <string value function>
    check constraint definition <column constraint> <domain constraint> <table constraint>
    circumflex <regular character set> <SQL special character>
    close statement <SQL data statement>
    COBOL array locator variable <COBOL derived type specification>
    COBOL binary integer <COBOL integer type>
    COBOL BLOB locator variable <COBOL derived type specification>
    COBOL BLOB variable <COBOL derived type specification>
    COBOL character type <COBOL type specification>
    COBOL CLOB locator variable <COBOL derived type specification>
    COBOL CLOB variable <COBOL derived type specification>
    COBOL derived type specification <COBOL type specification>
    COBOL host identifier <COBOL variable definition> <host identifier>
    COBOL integer type <COBOL type specification>
    COBOL multiset locator variable <COBOL derived type specification>
    COBOL national character type <COBOL type specification>
    COBOL NCLOB variable <COBOL derived type specification>
    COBOL nines <COBOL binary integer> <COBOL nines specification>
    COBOL nines specification <COBOL numeric type>
    COBOL numeric type <COBOL type specification>
    COBOL REF variable <COBOL derived type specification>
    COBOL type specification <COBOL variable definition>
    COBOL user-defined type locator variable <COBOL derived type specification>
    COBOL user-defined type variable <COBOL derived type specification>
    COBOL variable definition <host variable definition>
    collate clause <attribute definition> <character factor> <character set definition> <column definition> <domain definition> <grouping column reference> <predefined type> <window partition column reference>
    collation definition <schema element> <SQL schema definition statement>
    collation name <collate clause> <collation definition> <drop collation statement> <existing collation name> <module collation specification> <object name>
    collation specification <set session collation statement>
    collection derived table <table primary>
    collection type <data type>
    collection value constructor <nonparenthesized value expression primary>
    collection value expression <cardinality expression> <collection derived table> <common value expression> <table function derived table>
    colon <Ada assignment operator> <Ada variable definition> <character enumeration> <day-time interval> <double colon> <embedded variable name> <host parameter name> <Pascal variable definition> <SQL special character> <time interval> <time value> <time zone interval>
    column constraint <column constraint definition>
    column constraint definition <column definition> <column option list>
    column default option <like options>
    column definition <add column definition> <table element>
    column name <alter column definition> <as clause> <column definition> <column name list> <column options> <column reference> <cycle column> <cycle mark column> <drop column definition> <object column> <path column> <self-referencing column name> <sequence column> <table function column list element> <view column option>
    column name list <all fields column name list> <as subquery clause> <corresponding column list> <derived column list> <insert column list> <join column list> <privilege column list> <reference column list> <trigger column list> <unique column list> <updatability clause> <view column list> <with column list>
    column option list <column options>
    column options <table element>
    column reference <grouping column reference> <grouping operation> <nonparenthesized value expression primary> <simple target specification> <target array reference> <target specification> <window partition column reference>
    comma <Ada variable definition> <alter transform action list> <array element list> <binary set function> <C array locator variable> <C BLOB locator variable> <C BLOB variable> <C character variable> <C CLOB locator variable> <C CLOB variable> <C multiset locator variable> <C NCHAR variable> <C NCHAR VARYING variable> <C NCLOB variable> <C numeric variable> <C user-defined type locator variable> <C user-defined type variable> <C VARCHAR variable> <case abbreviation> <character set specification list> <column name list> <condition information> <constraint name list> <contextually typed row value constructor> <contextually typed row value constructor element list> <contextually typed row value expression list> <cycle column list> <data type list> <drop transform element list> <exact numeric type> <explicit row value constructor> <fetch target list> <Fortran variable definition> <free locator statement> <get descriptor information> <grant privilege statement> <grant role statement> <grouping column reference list> <grouping element list> <grouping operation> <grouping set list> <hold locator statement> <host parameter declaration list> <hypothetical set function value expression list> <in value list> <into arguments> <list of attributes> <member list> <merge insert value list> <method specification list> <modulus expression> <multiple group specification> <multiset element list> <MUMPS character variable> <MUMPS numeric variable> <MUMPS type specification> <object privileges> <ordinary grouping set list> <Pascal variable definition> <PL/I type specification> <PL/I variable definition> <power function> <privilege method list> <revoke privilege statement> <revoke role statement> <row type body> <row value constructor element list> <row value expression list> <schema name list> <select list> <select target list> <session characteristic list> <set clause list> <set descriptor information> <set target list> <single datetime field> <sort specification list> <SQL argument list> <SQL parameter declaration list> <SQL special character> <start transaction statement> <statement information> <table element list> <table function column list> <table reference list> <transaction characteristics> <transform element list> <type list> <upper limit> <using arguments> <view element list> <width bucket function> <window definition list> <window partition column reference list> <with list>
    comment <separator>
    comment character <bracketed comment contents> <simple comment>
    commit statement <SQL transaction statement>
    common sequence generator option <common sequence generator options>
    common sequence generator options <identity column specification> <sequence generator option>
    common value expression <contextually typed row value constructor> <row value constructor> <row value constructor predicand> <value expression>
    comp op <comparison predicate part 2> <quantified comparison predicate part 2>
    comparison predicate <predicate>
    comparison predicate part 2 <comparison predicate> <when operand>
    computational operation <set function type>
    concatenation <character value expression>
    concatenation operator <array concatenation> <blob concatenation> <concatenation> <delimiter token>
    condition <embedded exception declaration>
    condition action <embedded exception declaration>
    condition information <SQL diagnostics information>
    condition information item <condition information>
    condition information item name <condition information item>
    condition number <condition information>
    connect statement <SQL connection statement>
    connection name <connection object> <connection target>
    connection object <disconnect object> <set connection statement>
    connection target <connect statement>
    connection user name <connection target>
    constraint characteristics <assertion definition> <column constraint definition> <domain constraint> <table constraint definition>
    constraint check time <constraint characteristics>
    constraint name <assertion definition> <constraint name definition> <constraint name list> <drop assertion statement> <drop domain constraint definition> <drop table constraint definition> <SQL condition>
    constraint name definition <column constraint definition> <domain constraint> <table constraint definition>
    constraint name list <set constraints mode statement>
    contextually typed row value constructor <contextually typed row value expression>
    contextually typed row value constructor element <contextually typed row value constructor> <contextually typed row value constructor element list>
    contextually typed row value constructor element list <contextually typed row value constructor>
    contextually typed row value expression <assigned row> <contextually typed row value expression list>
    contextually typed row value expression list <contextually typed table value constructor>
    contextually typed table value constructor <from constructor>
    contextually typed value specification <contextually typed row value constructor> <contextually typed row value constructor element> <merge insert value element> <update source>
    correlation name <merge correlation name> <new values correlation name> <old values correlation name> <table primary>
    corresponding column list <corresponding spec>
    corresponding spec <non-join query expression> <non-join query term>
    cross join <joined table>
    cube list <grouping element> <grouping set>
    current collation specification <general value specification>
    current date value function <datetime value function>
    current local time value function <datetime value function>
    current local timestamp value function <datetime value function>
    current time value function <datetime value function>
    current timestamp value function <datetime value function>
    cursor attribute <cursor attributes>
    cursor holdability <cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
    cursor intent <allocate cursor statement>
    cursor name <close statement> <declare cursor> <delete statement: positioned> <dynamic cursor name> <dynamic declare cursor> <fetch statement> <open statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned>
    cursor returnability <cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
    cursor scrollability <cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
    cursor sensitivity <cursor attribute> <declare cursor> <dynamic declare cursor> <statement cursor>
    cursor specification <declare cursor> <direct select statement: multiple rows> <dynamic select statement>
    cycle clause <search or cycle clause>
    cycle column <cycle column list>
    cycle column list <cycle clause>
    cycle mark column <cycle clause>
    cycle mark value <cycle clause>
    data type <array type> <attribute definition> <cast target> <column definition> <data type list> <domain definition> <field definition> <generalized invocation> <host parameter data type> <multiset type> <parameter type> <result cast from type> <returns data type> <sequence generator data type option> <source data type> <table function column list element> <target data type>
    data type list <member name> <specific method specification designator>
    date literal <datetime literal>
    date string <date literal> <delimiter token>
    date value <unquoted date string>
    datetime factor <datetime term>
    datetime literal <general literal>
    datetime primary <datetime factor>
    datetime term <datetime value expression> <interval value expression>
    datetime type <predefined type>
    datetime value <days value> <hours value> <minutes value> <months value> <years value>
    datetime value expression <common value expression> <datetime value expression> <extract source> <interval value expression>
    datetime value function <datetime primary> <default option>
    day-time interval <day-time literal>
    day-time literal <unquoted interval string>
    days value <date value> <day-time interval>
    deallocate descriptor statement <system descriptor statement>
    deallocate prepared statement <SQL dynamic statement>
    declare cursor <module contents> <statement or declaration>
    default clause <attribute default> <column definition> <column option list> <domain definition> <set column default clause> <set domain default clause>
    default option <default clause>
    default specification <contextually typed value specification>
    delete rule <referential triggered action>
    delete statement: positioned <SQL data change statement>
    delete statement: searched <direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
    delimited identifier <actual identifier> <delimiter token>
    delimited identifier body <delimited identifier>
    delimited identifier part <delimited identifier body> <Unicode identifier part>
    delimiter token <token>
    dependent variable expression <binary set function>
    dereference operator <attribute or method reference> <dereference operation> <method reference>
    derived column <select sublist>
    derived column list <table primary>
    derived representation <reference type specification>
    derived table <table primary>
    describe input statement <describe statement>
    describe output statement <describe statement>
    describe statement <SQL dynamic statement>
    described object <describe output statement>
    descriptor item name <get item information> <set item information>
    descriptor name <allocate descriptor statement> <deallocate descriptor statement> <get descriptor statement> <into descriptor> <set descriptor statement> <using descriptor>
    deterministic characteristic <method characteristic> <routine characteristic>
    diagnostics size <transaction mode>
    digit <hexit> <large object length token> <SQL language character> <SQL language identifier part> <SQLSTATE char>
    direct implementation-defined statement <directly executable statement>
    direct invocation <method invocation>
    direct select statement: multiple rows <direct SQL data statement>
    direct SQL data statement <directly executable statement>
    directly executable statement <direct SQL statement>
    disconnect object <disconnect statement>
    disconnect statement <SQL connection statement>
    dispatch clause <function specification>
    distinct predicate <predicate>
    distinct predicate part 2 <distinct predicate> <when operand>
    domain constraint <add domain constraint definition> <domain definition>
    domain definition <schema element> <SQL schema definition statement>
    domain name <alter domain statement> <cast target> <column definition> <domain definition> <drop domain statement> <object name>
    double colon <delimiter token> <static method invocation>
    double period <Ada qualified type specification> <Ada unqualified type specification> <delimiter token> <Pascal type specification>
    double quote <delimited identifier> <doublequote symbol> <SQL special character> <Unicode delimited identifier>
    doublequote symbol <delimited identifier part>
    drop assertion statement <SQL schema manipulation statement>
    drop attribute definition <alter type action>
    drop behavior <drop collation statement> <drop column definition> <drop column scope clause> <drop data type statement> <drop domain statement> <drop routine statement> <drop schema statement> <drop sequence generator statement> <drop table constraint definition> <drop table statement> <drop transform element list> <drop transform statement> <drop user-defined cast statement> <drop user-defined ordering statement> <drop view statement> <revoke privilege statement> <revoke role statement>
    drop character set statement <SQL schema manipulation statement>
    drop collation statement <SQL schema manipulation statement>
    drop column default clause <alter column action>
    drop column definition <alter table action>
    drop column scope clause <alter column action>
    drop data type statement <SQL schema manipulation statement>
    drop domain constraint definition <alter domain action>
    drop domain default clause <alter domain action>
    drop domain statement <SQL schema manipulation statement>
    drop method specification <alter type action>
    drop role statement <SQL schema manipulation statement>
    drop routine statement <SQL schema manipulation statement>
    drop schema statement <SQL schema manipulation statement>
    drop sequence generator statement <SQL schema manipulation statement>
    drop table constraint definition <alter table action>
    drop table statement <SQL schema manipulation statement>
    drop transform element list <alter transform action>
    drop transform statement <SQL schema manipulation statement>
    drop transliteration statement <SQL schema manipulation statement>
    drop trigger statement <SQL schema manipulation statement>
    drop user-defined cast statement <SQL schema manipulation statement>
    drop user-defined ordering statement <SQL schema manipulation statement>
    drop view statement <SQL schema manipulation statement>
    dynamic close statement <SQL dynamic data statement>
    dynamic cursor name <dynamic close statement> <dynamic delete statement: positioned> <dynamic fetch statement> <dynamic open statement> <dynamic update statement: positioned>
    dynamic declare cursor <module contents> <statement or declaration>
    dynamic delete statement: positioned <SQL dynamic data statement>
    dynamic fetch statement <SQL dynamic data statement>
    dynamic open statement <SQL dynamic data statement>
    dynamic parameter specification <general value specification> <target specification>
    dynamic result sets characteristic <alter routine characteristic> <routine characteristic>
    dynamic select statement <preparable SQL data statement>
    dynamic single row select statement <preparable SQL data statement>
    dynamic update statement: positioned <SQL dynamic data statement>
    else clause <searched case> <simple case>
    embedded authorization clause <embedded authorization declaration>
    embedded authorization declaration <statement or declaration>
    embedded authorization identifier <embedded authorization clause>
    embedded character set declaration <embedded SQL declare section> <embedded SQL MUMPS declare>
    embedded collation specification <statement or declaration>
    embedded exception declaration <statement or declaration>
    embedded path specification <statement or declaration>
    embedded SQL Ada program <embedded SQL host program>
    embedded SQL begin declare <embedded SQL declare section>
    embedded SQL C program <embedded SQL host program>
    embedded SQL COBOL program <embedded SQL host program>
    embedded SQL end declare <embedded SQL declare section>
    embedded SQL Fortran program <embedded SQL host program>
    embedded SQL MUMPS declare <embedded SQL declare section>
    embedded SQL MUMPS program <embedded SQL host program>
    embedded SQL Pascal program <embedded SQL host program>
    embedded SQL PL/I program <embedded SQL host program>
    embedded transform group specification <statement or declaration>
    embedded variable name <embedded variable specification> <indicator variable> <locator reference> <simple target specification> <simple value specification>
    embedded variable specification <general value specification> <target specification>
    empty grouping set <grouping element> <grouping set>
    empty specification <implicitly typed value specification>
    end field <interval qualifier>
    equals operator <Ada assignment operator> <C initial value> <comp op> <condition information item> <get header information> <get item information> <greater than or equals operator> <less than or equals operator> <multiple column assignment> <set clause> <set header information> <set item information> <SQL special character> <statement information item>
    equals ordering form <ordering form>
    escape character <binary string literal> <character like predicate part 2> <regular expression substring function> <similar predicate part 2> <Unicode character string literal>
    escape octet <octet like predicate part 2>
    escaped character <character specifier>
    exact numeric literal <mantissa> <unsigned numeric literal>
    exact numeric type <numeric type>
    exclusive user-defined type specification <user-defined type specification>
    execute immediate statement <SQL dynamic statement>
    execute statement <SQL dynamic statement>
    existing collation name <collation definition>
    existing transliteration name <transliteration source>
    existing window name <window specification details>
    exists predicate <predicate>
    explicit row value constructor <row value constructor> <row value constructor predicand> <row value expression>
    explicit table <simple table>
    exponent <approximate numeric literal>
    exponential function <numeric value function>
    extended cursor name <allocate cursor statement> <described object> <dynamic cursor name>
    extended statement name <SQL statement name> <statement cursor>
    external body reference <routine body>
    external routine name <alter routine characteristic> <external body reference>
    external security clause <external body reference>
    externally-invoked procedure <module contents>
    extract expression <numeric value function>
    extract field <extract expression>
    extract source <extract expression>
    factor <interval term> <term>
    fetch orientation <dynamic fetch statement> <fetch statement>
    fetch statement <SQL data statement>
    fetch target list <fetch statement>
    field definition <row type body>
    field name <field definition> <field reference>
    field reference <nonparenthesized value expression primary>
    filter clause <aggregate function>
    finality <user-defined type option>
    floor function <numeric value function>
    fold <character value function>
    Fortran array locator variable <Fortran derived type specification>
    Fortran BLOB locator variable <Fortran derived type specification>
    Fortran BLOB variable <Fortran derived type specification>
    Fortran CLOB locator variable <Fortran derived type specification>
    Fortran CLOB variable <Fortran derived type specification>
    Fortran derived type specification <Fortran type specification>
    Fortran host identifier <Fortran variable definition> <host identifier>
    Fortran multiset locator variable <Fortran derived type specification>
    Fortran REF variable <Fortran derived type specification>
    Fortran type specification <Fortran variable definition>
    Fortran user-defined type locator variable <Fortran derived type specification>
    Fortran user-defined type variable <Fortran derived type specification>
    Fortran variable definition <host variable definition>
    free locator statement <SQL data statement>
    from clause <table expression>
    from constructor <insert columns and source>
    from default <insert columns and source>
    from sql <transform element>
    from sql function <from sql>
    from subquery <insert columns and source>
    full ordering form <ordering form>
    function specification <SQL-invoked function>
    general literal <literal> <unsigned literal>
    general set function <aggregate function>
    general value specification <unsigned value specification> <using argument> <value specification>
    generalized expression <SQL argument>
    generalized invocation <method invocation>
    generation clause <column definition>
    generation expression <generation clause>
    generation rule <generation clause>
    get descriptor information <get descriptor statement>
    get descriptor statement <system descriptor statement>
    get diagnostics statement <SQL diagnostics statement>
    get header information <get descriptor information>
    get item information <get descriptor information>
    global or local <table scope>
    go to <condition action>
    goto target <go to>
    grant privilege statement <grant statement>
    grant role statement <grant statement>
    grant statement <schema element> <SQL schema definition statement>
    grantee <grant privilege statement> <grant role statement> <revoke privilege statement> <revoke role statement>
    grantor <grant privilege statement> <grant role statement> <revoke privilege statement> <revoke role statement> <role definition>
    greater than operator <comp op> <greater than or equals operator> <not equals operator> <right arrow> <SQL special character>
    greater than or equals operator <comp op> <delimiter token>
    group by clause <table expression>
    group name <alter group> <group specification> <single group specification> <transform group> <transform group element>
    group specification <multiple group specification>
    grouping column reference <grouping column reference list> <ordinary grouping set>
    grouping column reference list <ordinary grouping set>
    grouping element <grouping element list>
    grouping element list <group by clause>
    grouping operation <set function specification>
    grouping set <grouping set list>
    grouping set list <grouping sets specification>
    grouping sets specification <grouping element> <grouping set>
    handler declaration <statement or declaration>
    having clause <table expression>
    header item name <get header information> <set header information>
    hex string literal <nondelimiter token>
    hexit <binary string literal> <Unicode 4 digit escape value> <Unicode 6 digit escape value>
    high value <upper limit>
    hold locator statement <SQL data statement>
    host identifier <embedded variable name>
    host label identifier <goto target>
    host parameter data type <host parameter declaration>
    host parameter declaration <host parameter declaration list>
    host parameter declaration list <externally-invoked procedure>
    host parameter name <host parameter declaration> <host parameter specification> <indicator parameter> <locator reference> <simple value specification>
    host parameter specification <general value specification> <simple target specification> <target specification>
    host PL/I label variable <goto target>
    host variable definition <embedded SQL declare section> <embedded SQL MUMPS declare>
    hours value <day-time interval> <time interval> <time value> <time zone interval>
    hypothetical set function <ordered set function>
    hypothetical set function value expression list <hypothetical set function>
    identifier <asterisked identifier> <attribute name> <cast to distinct identifier> <cast to ref identifier> <cast to source identifier> <cast to type identifier> <catalog name> <column name> <correlation name> <external routine name> <field name> <group name> <host parameter name> <identifier chain> <method name> <new values table alias> <old values table alias> <procedure name> <qualified identifier> <query name> <regular character set identifier> <role name> <savepoint name> <SQL parameter name> <SQL-client module name> <statement name> <user identifier> <window name>
    identifier body <regular identifier>
    identifier chain <basic identifier chain>
    identifier extend <identifier part>
    identifier part <identifier body>
    identifier start <identifier body> <identifier part>
    identity column specification <column definition>
    identity option <like options>
    ideographic character <identifier start>
    implementation-defined character set name <character set specification>
    implicitly typed value specification <cast operand> <contextually typed value specification> <default option>
    in predicate <predicate>
    in predicate part 2 <in predicate> <when operand>
    in predicate value <in predicate part 2>
    in value list <in predicate value>
    in-line window specification <window name or specification>
    inclusive user-defined type specification <user-defined type specification>
    independent variable expression <binary set function>
    indicator parameter <host parameter specification>
    indicator variable <embedded variable specification>
    initial alphabetic character <identifier start>
    input using clause <dynamic open statement> <parameter using clause>
    insert column list <from constructor> <from subquery> <merge insert specification>
    insert columns and source <insert statement>
    insert statement <direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
    insertion target <insert statement>
    instantiable clause <user-defined type option>
    interval absolute value function <interval value function>
    interval factor <interval term>
    interval fractional seconds precision <end field> <single datetime field>
    interval leading field precision <single datetime field> <start field>
    interval literal <general literal>
    interval primary <interval factor> <time zone specifier>
    interval qualifier <interval literal> <interval primary> <interval type> <interval value expression>
    interval string <delimiter token> <interval literal>
    interval term <datetime value expression> <interval term 1> <interval term 2> <interval value expression>
    interval term 1 <interval value expression>
    interval term 2 <interval term>
    interval type <predefined type>
    interval value expression <common value expression> <datetime value expression> <extract source> <interval absolute value function> <interval value expression 1> <set time zone value>
    interval value expression 1 <interval value expression>
    interval value function <interval primary>
    into argument <into arguments>
    into arguments <output using clause>
    into descriptor <output using clause>
    introducer <character string literal> <Unicode character string literal>
    inverse distribution function <ordered set function>
    inverse distribution function argument <inverse distribution function>
    inverse distribution function type <inverse distribution function>
    isolation level <transaction mode>
    item number <get descriptor information> <set descriptor information>
    join column list <named columns join>
    join condition <join specification>
    join specification <qualified join>
    join type <natural join> <qualified join>
    joined table <query expression body> <query primary> <query term> <table primary> <table primary or joined table>
    key word <nondelimiter token>
    language clause <alter routine characteristic> <method characteristic> <routine characteristic> <SQL-client module definition>
    language name <language clause>
    large object length <Ada BLOB variable> <Ada CLOB variable> <binary large object string type> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <character string type> <COBOL BLOB variable> <COBOL CLOB variable> <COBOL NCLOB variable> <Fortran BLOB variable> <Fortran CLOB variable> <MUMPS BLOB variable> <MUMPS CLOB variable> <national character string type> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable>
    large object length token <large object length> <nondelimiter token>
    lateral derived table <table primary>
    left brace <repeat factor> <SQL special character>
    left bracket <C array specification> <character enumeration> <left bracket or trigraph> <Pascal type specification> <regular character set> <SQL special character>
    left bracket or trigraph <array element reference> <array type> <array value constructor by enumeration> <empty specification> <multiset value constructor by enumeration> <target array element specification> <update target>
    left bracket trigraph <delimiter token> <left bracket or trigraph>
    left paren <absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <add transform element list> <aggregate function> <all fields reference> <alter group> <approximate numeric type> <array value constructor by query> <as subquery clause> <assertion definition> <binary large object string type> <binary set function> <blob overlay function> <blob position expression> <blob substring function> <blob trim function> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <cardinality expression> <case abbreviation> <cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <ceiling function> <char length expression> <character overlay function> <character string type> <character substring function> <character transliteration> <check constraint definition> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <COBOL nines> <collection derived table> <contextually typed row value constructor> <corresponding spec> <cube list> <current collation specification> <current local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop transform element list> <drop user-defined cast statement> <empty grouping set> <end field> <exact numeric type> <explicit row value constructor> <exponential function> <extract expression> <filter clause> <floor function> <fold> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <generation expression> <grouping operation> <grouping sets specification> <host parameter declaration list> <hypothetical set function> <identity column specification> <in predicate value> <interval absolute value function> <interval value expression> <inverse distribution function> <list of attributes> <member list> <merge insert specification> <merge insert value list> <modulus expression> <multiset element reference> <multiset set function> <multiset value constructor by query> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <named columns join> <national character string type> <natural logarithm> <non-join query primary> <normalize function> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <power function> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <repeatable clause> <rollup list> <row type body> <sample clause> <set target list> <single datetime field> <SQL argument list> <SQL parameter declaration list> <SQL prefix> <SQL special character> <square root> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table function column list> <table function derived table> <table primary> <table value constructor by query> <target table> <transcoding> <transform group> <triggered action> <trim function> <type predicate part 2> <unique constraint definition> <user-defined cast definition> <view element list> <width bucket function> <window function type> <window specification> <with list element> <within group specification>
    length <Ada qualified type specification> <Ada unqualified type specification> <C array specification> <character string type> <COBOL character type> <COBOL national character type> <COBOL nines> <Fortran type specification> <MUMPS length specification> <national character string type> <Pascal type specification> <PL/I type specification>
    length expression <numeric value function>
    less than operator <comp op> <less than or equals operator> <not equals operator> <SQL special character>
    less than or equals operator <comp op> <delimiter token>
    level of isolation <isolation level>
    levels clause <view definition>
    like clause <table element>
    like options <like clause>
    like predicate <predicate>
    list of attributes <derived representation>
    literal <default option> <simple value specification> <value specification>
    local or schema qualified name <table name>
    local or schema qualifier <local or schema qualified name>
    local qualified name <cursor name>
    local qualifier <local qualified name>
    locator indication <host parameter data type> <parameter type> <result cast from type> <returns data type>
    locator reference <free locator statement> <hold locator statement>
    low value <repeat factor>
    major category <SQL condition>
    mantissa <approximate numeric literal>
    map category <ordering category>
    map function specification <map category>
    match predicate <predicate>
    match predicate part 2 <match predicate> <when operand>
    match type <references specification>
    maximum dynamic result sets <dynamic result sets characteristic>
    member <member list>
    member list <representation>
    member name <specific routine designator>
    member name alternatives <member name>
    member predicate <predicate>
    member predicate part 2 <member predicate> <when operand>
    merge correlation name <merge statement>
    merge insert specification <merge when not matched clause>
    merge insert value element <merge insert value list>
    merge insert value list <merge insert specification>
    merge operation specification <merge statement>
    merge statement <direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
    merge update specification <merge when matched clause>
    merge when clause <merge operation specification>
    merge when matched clause <merge when clause>
    merge when not matched clause <merge when clause>
    method characteristic <method characteristics>
    method characteristics <original method specification>
    method invocation <new invocation> <nonparenthesized value expression primary>
    method name <direct invocation> <generalized invocation> <member name alternatives> <method reference> <method specification designator> <mutated set clause> <partial method specification> <specific method specification designator> <static method invocation>
    method specification <method specification list>
    method specification designator <SQL-invoked function>
    method specification list <user-defined type body>
    minus sign <character enumeration> <date value> <datetime value expression> <interval value expression> <numeric value expression> <right arrow> <sign> <simple comment introducer> <SQL special character> <year-month literal>
    minutes value <day-time interval> <time interval> <time value> <time zone interval>
    module authorization clause <SQL-client module definition>
    module authorization identifier <embedded authorization identifier> <module authorization clause>
    module character set specification <module name clause>
    module collation <SQL-client module definition>
    module collation specification <module collations>
    module collations <embedded collation specification>
    module contents <SQL-client module definition>
    module name clause <SQL-client module definition>
    module path specification <SQL-client module definition>
    module transform group specification <SQL-client module definition>
    modulus expression <numeric value function>
    months value <date value> <year-month literal>
    multiple column assignment <set clause>
    multiple group specification <transform group specification>
    multiplier <large object length> <large object length token> <nondelimiter token>
    multiset element <multiset element list>
    multiset element list <multiset value constructor by enumeration>
    multiset element reference <nonparenthesized value expression primary>
    multiset primary <multiset term>
    multiset set function <multiset value function>
    multiset term <multiset term> <multiset value expression>
    multiset type <Ada multiset locator variable> <C multiset locator variable> <COBOL multiset locator variable> <collection type> <Fortran multiset locator variable> <MUMPS multiset locator variable> <Pascal multiset locator variable> <PL/I multiset locator variable>
    multiset value constructor <collection value constructor>
    multiset value constructor by enumeration <multiset value constructor>
    multiset value constructor by query <multiset value constructor>
    multiset value expression <collection value expression> <member predicate part 2> <multiset set function> <multiset value expression> <submultiset predicate part 2>
    multiset value function <multiset primary>
    multset value expression <multiset element reference>
    MUMPS array locator variable <MUMPS derived type specification>
    MUMPS BLOB locator variable <MUMPS derived type specification>
    MUMPS BLOB variable <MUMPS derived type specification>
    MUMPS character variable <MUMPS variable definition>
    MUMPS CLOB locator variable <MUMPS derived type specification>
    MUMPS CLOB variable <MUMPS derived type specification>
    MUMPS derived type specification <MUMPS variable definition>
    MUMPS host identifier <host identifier> <MUMPS character variable> <MUMPS numeric variable>
    MUMPS length specification <MUMPS character variable>
    MUMPS multiset locator variable <MUMPS derived type specification>
    MUMPS numeric variable <MUMPS variable definition>
    MUMPS REF variable <MUMPS derived type specification>
    MUMPS type specification <MUMPS numeric variable>
    MUMPS user-defined type locator variable <MUMPS derived type specification>
    MUMPS user-defined type variable <MUMPS derived type specification>
    MUMPS variable definition <host variable definition>
    mutated set clause <mutated target> <set target>
    mutated target <mutated set clause>
    named columns join <join specification>
    national character string literal <general literal> <nondelimiter token>
    national character string type <predefined type>
    natural join <joined table>
    natural logarithm <numeric value function>
    nesting option <describe input statement> <describe output statement>
    new specification <nonparenthesized value expression primary>
    new values correlation name <old or new values alias>
    new values table alias <old or new values alias>
    new window name <window definition>
    newline <simple comment>
    next value expression <nonparenthesized value expression primary>
    non-cycle mark value <cycle clause>
    non-escaped character <character specifier>
    non-join query expression <non-join query primary> <query expression body>
    non-join query primary <non-join query term> <query primary>
    non-join query term <non-join query expression> <query term>
    non-reserved word <key word>
    non-second primary datetime field <end field> <primary datetime field> <single datetime field> <start field>
    nondelimiter token <token>
    nondoublequote character <delimited identifier part>
    nonparenthesized value expression primary <boolean predicand> <row value special case> <value expression primary>
    nonquote character <character representation> <comment character>
    normalize function <character value function>
    normalized predicate <predicate>
    not equals operator <comp op> <delimiter token>
    null ordering <sort specification>
    null predicate <predicate>
    null predicate part 2 <null predicate> <when operand>
    null specification <implicitly typed value specification>
    null-call clause <alter routine characteristic> <method characteristic> <routine characteristic>
    number of conditions <diagnostics size>
    numeric primary <factor>
    numeric type <predefined type>
    numeric value expression <absolute value expression> <array element reference> <ceiling function> <common value expression> <dependent variable expression> <exponential function> <floor function> <independent variable expression> <inverse distribution function argument> <natural logarithm> <numeric value expression> <numeric value expression base> <numeric value expression exponent> <repeat argument> <sample percentage> <square root> <start position> <string length> <width bucket bound 1> <width bucket bound 2> <width bucket count> <width bucket operand>
    numeric value expression base <power function>
    numeric value expression dividend <modulus expression>
    numeric value expression divisor <modulus expression>
    numeric value expression exponent <power function>
    numeric value function <numeric primary>
    object column <mutated target> <update target>
    object name <privileges>
    object privileges <privileges>
    occurrences <allocate descriptor statement>
    octet length expression <length expression>
    octet like predicate <like predicate>
    octet like predicate part 2 <octet like predicate> <when operand>
    octet pattern <octet like predicate part 2>
    old or new values alias <old or new values alias list>
    old or new values alias list <trigger definition>
    old values correlation name <old or new values alias>
    old values table alias <old or new values alias>
    only spec <table primary>
    open statement <SQL data statement>
    order by clause <array value constructor by query> <cursor specification>
    ordered set function <aggregate function>
    ordering category <equals ordering form> <full ordering form>
    ordering form <user-defined ordering definition>
    ordering specification <sort specification>
    ordinary grouping set <grouping element> <grouping set> <ordinary grouping set list>
    ordinary grouping set list <cube list> <rollup list>
    original method specification <add original method specification> <method specification>
    outer join type <join type>
    output using clause <dynamic fetch statement> <result using clause>
    overlaps predicate <predicate>
    overlaps predicate part <case operand>
    overlaps predicate part 1 <overlaps predicate>
    overlaps predicate part 2 <overlaps predicate> <when operand>
    override clause <from constructor> <from subquery> <merge insert specification>
    overriding method specification <add overriding method specification> <method specification>
    pad characteristic <collation definition>
    parameter mode <SQL parameter declaration>
    parameter style <parameter style clause>
    parameter style clause <alter routine characteristic> <external body reference> <method characteristic> <routine characteristic>
    parameter type <SQL parameter declaration>
    parameter using clause <execute statement>
    parenthesized boolean value expression <boolean predicand>
    parenthesized value expression <value expression primary>
    partial method specification <original method specification> <overriding method specification>
    Pascal array locator variable <Pascal derived type specification>
    Pascal BLOB locator variable <Pascal derived type specification>
    Pascal BLOB variable <Pascal derived type specification>
    Pascal CLOB locator variable <Pascal derived type specification>
    Pascal CLOB variable <Pascal derived type specification>
    Pascal derived type specification <Pascal type specification>
    Pascal host identifier <host identifier> <Pascal variable definition>
    Pascal multiset locator variable <Pascal derived type specification>
    Pascal REF variable <Pascal derived type specification>
    Pascal type specification <Pascal variable definition>
    Pascal user-defined type locator variable <Pascal derived type specification>
    Pascal user-defined type variable <Pascal derived type specification>
    Pascal variable definition <host variable definition>
    path column <cycle clause>
    path specification <embedded path specification> <module path specification> <schema path specification>
    path-resolved user-defined type name <Ada user-defined type locator variable> <Ada user-defined type variable> <C user-defined type locator variable> <C user-defined type variable> <COBOL user-defined type locator variable> <COBOL user-defined type variable> <data type> <exclusive user-defined type specification> <Fortran user-defined type locator variable> <Fortran user-defined type variable> <general value specification> <generalized expression> <group specification> <inclusive user-defined type specification> <MUMPS user-defined type locator variable> <MUMPS user-defined type variable> <Pascal user-defined type locator variable> <Pascal user-defined type variable> <PL/I user-defined type locator variable> <PL/I user-defined type variable> <referenceable view specification> <referenced type> <static method invocation> <supertype name> <table contents source> <target subtype> <transform group characteristic>
    percent <regular primary> <SQL special character>
    period <Ada qualified type specification> <all fields reference> <asterisked identifier chain> <character set name> <COBOL variable definition> <column reference> <direct invocation> <double period> <exact numeric literal> <field reference> <generalized invocation> <identifier chain> <local or schema qualified name> <local qualified name> <mutated set clause> <qualified asterisk> <routine name> <schema name> <schema qualified name> <schema qualified type name> <seconds value> <specific method name> <specific type method> <SQL special character>
    PL/I array locator variable <PL/I derived type specification>
    PL/I BLOB locator variable <PL/I derived type specification>
    PL/I BLOB variable <PL/I derived type specification>
    PL/I CLOB locator variable <PL/I derived type specification>
    PL/I CLOB variable <PL/I derived type specification>
    PL/I derived type specification <PL/I type specification>
    PL/I host identifier <host identifier> <PL/I variable definition>
    PL/I multiset locator variable <PL/I derived type specification>
    PL/I REF variable <PL/I derived type specification>
    PL/I type fixed binary <PL/I type specification>
    PL/I type fixed decimal <PL/I type specification>
    PL/I type float binary <PL/I type specification>
    PL/I type specification <PL/I variable definition>
    PL/I user-defined type locator variable <PL/I derived type specification>
    PL/I user-defined type variable <PL/I derived type specification>
    PL/I variable definition <host variable definition>
    plus sign <datetime value expression> <interval value expression> <numeric value expression> <regular factor> <sign> <SQL special character> <Unicode 6 digit escape value>
    position expression <numeric value function>
    power function <numeric value function>
    precision <approximate numeric type> <exact numeric type> <MUMPS type specification> <PL/I type specification>
    predefined type <Ada user-defined type variable> <C user-defined type variable> <COBOL user-defined type variable> <data type> <Fortran user-defined type variable> <MUMPS user-defined type variable> <Pascal user-defined type variable> <PL/I user-defined type variable> <representation> <user-defined representation>
    predicate <boolean primary>
    preparable dynamic delete statement: positioned <preparable SQL data statement>
    preparable dynamic update statement: positioned <preparable SQL data statement>
    preparable implementation-defined statement <preparable statement>
    preparable SQL control statement <preparable statement>
    preparable SQL data statement <preparable statement>
    preparable SQL schema statement <preparable statement>
    preparable SQL session statement <preparable statement>
    preparable SQL transaction statement <preparable statement>
    prepare statement <SQL dynamic statement>
    primary datetime field <extract field>
    privilege column list <action>
    privilege method list <action>
    privileges <grant privilege statement> <revoke privilege statement>
    procedure name <externally-invoked procedure>
    qualified asterisk <select sublist>
    qualified identifier <attribute or method reference> <column reference> <local or schema qualified name> <local qualified name> <routine name> <schema qualified name> <schema qualified type name> <specific method name>
    qualified join <joined table>
    quantified comparison predicate <predicate>
    quantified comparison predicate part 2 <quantified comparison predicate> <when operand>
    quantifier <quantified comparison predicate part 2>
    query expression <array value constructor by query> <cursor specification> <from subquery> <multiset value constructor by query> <subquery> <table value constructor by query> <view definition> <with list element>
    query expression body <non-join query expression> <query expression>
    query name <table or query name> <with list element>
    query primary <non-join query term>
    query specification <dynamic single row select statement> <simple table>
    query term <non-join query expression> <non-join query term>
    question mark <dynamic parameter specification> <regular factor> <SQL special character>
    quote <binary string literal> <character string literal> <comment character> <date string> <interval string> <national character string literal> <quote symbol> <SQL special character> <time string> <timestamp string> <Unicode character string literal> <Unicode escape specifier>
    quote symbol <character representation>
    rank function type <hypothetical set function> <window function type>
    recursive search order <search clause>
    ref cast option <user-defined type option>
    reference column list <referenced table and columns> <referencing columns>
    reference generation <self-referencing column specification>
    reference resolution <nonparenthesized value expression primary>
    reference scope check <attribute definition> <column definition> <field definition>
    reference scope check action <reference scope check>
    reference type <Ada REF variable> <C REF variable> <COBOL REF variable> <data type> <Fortran REF variable> <MUMPS REF variable> <Pascal REF variable> <PL/I REF variable> <target subtype>
    reference type specification <user-defined type option>
    reference value expression <common value expression> <dereference operation> <reference resolution>
    referenceable view specification <view specification>
    referenced table and columns <references specification>
    referenced type <reference type>
    references specification <column constraint> <referential constraint definition>
    referencing columns <referential constraint definition>
    referential action <delete rule> <reference scope check action> <update rule>
    referential constraint definition <table constraint>
    referential triggered action <references specification>
    regular character set <regular primary>
    regular character set identifier <character enumeration>
    regular expression <regular expression> <regular primary>
    regular expression substring function <character value function>
    regular factor <regular term>
    regular identifier <actual identifier> <nondelimiter token>
    regular primary <regular factor>
    regular term <regular expression> <regular term>
    regular view specification <view specification>
    relative category <ordering category>
    relative function specification <relative category>
    release savepoint statement <SQL transaction statement>
    repeat argument <repeatable clause>
    repeat factor <regular factor>
    repeatable clause <sample clause>
    representation <user-defined type body>
    reserved word <key word>
    result <else clause> <searched when clause> <simple when clause>
    result cast <returns type>
    result cast from type <result cast>
    result expression <result>
    result set cursor <cursor intent>
    result using clause <execute statement>
    return statement <SQL control statement>
    return value <return statement>
    returns clause <function specification> <method specification designator> <partial method specification>
    returns data type <returns type>
    returns table type <returns type>
    returns type <returns clause>
    revoke option extension <revoke privilege statement>
    revoke privilege statement <revoke statement>
    revoke role statement <revoke statement>
    revoke statement <SQL schema manipulation statement>
    right arrow <delimiter token> <dereference operator>
    right brace <repeat factor> <SQL special character>
    right bracket <C array specification> <character enumeration> <Pascal type specification> <regular character set> <right bracket or trigraph> <SQL special character>
    right bracket or trigraph <array element reference> <array type> <array value constructor by enumeration> <empty specification> <multiset value constructor by enumeration> <target array element specification> <update target>
    right bracket trigraph <delimiter token> <right bracket or trigraph>
    right paren <absolute value expression> <action> <Ada BLOB variable> <Ada CLOB variable> <Ada qualified type specification> <Ada unqualified type specification> <add transform element list> <aggregate function> <all fields reference> <alter group> <approximate numeric type> <array value constructor by query> <as subquery clause> <assertion definition> <binary large object string type> <binary set function> <blob overlay function> <blob position expression> <blob substring function> <blob trim function> <C BLOB variable> <C CLOB variable> <C NCLOB variable> <cardinality expression> <case abbreviation> <cast specification> <cast to distinct> <cast to ref> <cast to source> <cast to type> <ceiling function> <char length expression> <character overlay function> <character string type> <character substring function> <character transliteration> <check constraint definition> <COBOL BLOB variable> <COBOL character type> <COBOL CLOB variable> <COBOL national character type> <COBOL NCLOB variable> <COBOL nines> <collection derived table> <contextually typed row value constructor> <corresponding spec> <cube list> <current collation specification> <current local time value function> <current local timestamp value function> <current time value function> <current timestamp value function> <data type list> <datetime type> <drop transform element list> <drop user-defined cast statement> <empty grouping set> <end field> <exact numeric type> <explicit row value constructor> <exponential function> <extract expression> <filter clause> <floor function> <fold> <Fortran BLOB variable> <Fortran CLOB variable> <from constructor> <from subquery> <general set function> <generalized invocation> <generation expression> <grouping operation> <grouping sets specification> <host parameter declaration list> <hypothetical set function> <identity column specification> <in predicate value> <interval absolute value function> <interval value expression> <inverse distribution function> <list of attributes> <member list> <merge insert specification> <merge insert value list> <modulus expression> <multiset element reference> <multiset set function> <multiset value constructor by query> <MUMPS BLOB variable> <MUMPS CLOB variable> <MUMPS length specification> <MUMPS type specification> <named columns join> <national character string type> <natural logarithm> <non-join query primary> <normalize function> <octet length expression> <only spec> <ordinary grouping set> <parenthesized boolean value expression> <parenthesized value expression> <Pascal BLOB variable> <Pascal CLOB variable> <PL/I BLOB variable> <PL/I CLOB variable> <PL/I type specification> <PL/I variable definition> <power function> <reference resolution> <reference type> <referenced table and columns> <referential constraint definition> <regular expression substring function> <regular primary> <regular view specification> <repeatable clause> <rollup list> <row type body> <sample clause> <set target list> <single datetime field> <SQL argument list> <SQL parameter declaration list> <SQL special character> <SQL terminator> <square root> <start field> <string position expression> <subquery> <subtype treatment> <table element list> <table function column list> <table function derived table> <table primary> <table value constructor by query> <target table> <transcoding> <transform group> <triggered action> <trim function> <type predicate part 2> <unique constraint definition> <user-defined cast definition> <view element list> <width bucket function> <window function type> <window specification> <with list element> <within group specification>
    rights clause <SQL routine spec>
    role definition <schema element> <SQL schema definition statement>
    role granted <grant role statement>
    role name <authorization identifier> <drop role statement> <role definition> <role granted> <role revoked>
    role revoked <revoke role statement>
    role specification <set role statement>
    rollback statement <SQL transaction statement>
    rollup list <grouping element> <grouping set>
    routine body <SQL-invoked function> <SQL-invoked procedure>
    routine characteristic <routine characteristics>
    routine characteristics <function specification> <SQL-invoked procedure>
    routine invocation <call statement> <constructor method selection> <method selection> <new invocation> <new specification> <nonparenthesized value expression primary> <static method selection>
    routine name <routine invocation>
    routine type <specific routine designator>
    row subquery <explicit row value constructor>
    row type <data type>
    row type body <row type>
    row value constructor <table row value expression>
    row value constructor element <explicit row value constructor> <row value constructor element list>
    row value constructor element list <explicit row value constructor>
    row value constructor predicand <row value predicand>
    row value expression <in value list> <value expression>
    row value expression list <table value constructor>
    row value predicand <between predicate> <between predicate part 2> <case operand> <character like predicate> <comparison predicate> <comparison predicate part 2> <in predicate> <match predicate> <member predicate> <null predicate> <octet like predicate> <quantified comparison predicate> <row value predicand 1> <row value predicand 2> <row value predicand 3> <row value predicand 4> <set predicate> <similar predicate> <submultiset predicate> <type predicate> <when operand>
    row value predicand 1 <overlaps predicate part 1>
    row value predicand 2 <overlaps predicate part 2>
    row value predicand 3 <distinct predicate>
    row value predicand 4 <distinct predicate part 2>
    row value special case <contextually typed row value expression> <row value expression> <row value predicand> <table row value expression>
    sample clause <table reference>
    sample method <sample clause>
    sample percentage <sample clause>
    savepoint clause <rollback statement>
    savepoint level indication <routine characteristic>
    savepoint name <savepoint specifier>
    savepoint specifier <release savepoint statement> <savepoint clause> <savepoint statement>
    savepoint statement <SQL transaction statement>
    scalar subquery <nonparenthesized value expression primary>
    scale <exact numeric type> <MUMPS type specification> <PL/I type specification>
    schema authorization identifier <schema name clause>
    schema character set or path <schema definition>
    schema character set specification <schema character set or path>
    schema definition <SQL schema definition statement>
    schema element <schema definition>
    schema function <schema routine>
    schema name <character set name> <drop schema statement> <embedded authorization clause> <local or schema qualifier> <module authorization clause> <routine name> <schema name clause> <schema name list> <schema qualified name> <schema qualified type name> <specific method name>
    schema name characteristic <set schema statement>
    schema name clause <schema definition>
    schema name list <path specification>
    schema path specification <schema character set or path>
    schema procedure <schema routine>
    schema qualified name <collation name> <constraint name> <domain name> <schema qualified routine name> <sequence generator name> <specific name> <transcoding name> <transliteration name> <trigger name>
    schema qualified routine name <function specification> <member name alternatives> <SQL-invoked procedure>
    schema qualified type name <user-defined type name>
    schema routine <schema element> <SQL-invoked routine>
    schema-resolved user-defined type name <alter transform statement> <drop data type statement> <drop transform statement> <drop user-defined ordering statement> <method specification designator> <object name> <specific routine designator> <transform definition> <user-defined ordering definition> <user-defined type body>
    scope clause <add column scope clause> <column option list> <reference type> <view column option>
    scope option <descriptor name> <extended cursor name> <extended statement name> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned>
    search clause <search or cycle clause>
    search condition <assertion definition> <check constraint definition> <delete statement: searched> <filter clause> <having clause> <join condition> <merge statement> <searched when clause> <triggered action> <update statement: searched> <where clause>
    search or cycle clause <with list element>
    searched case <case specification>
    searched when clause <searched case>
    seconds fraction <seconds value>
    seconds integer value <seconds value>
    seconds value <day-time interval> <time interval> <time value>
    select list <query specification> <select statement: single row>
    select statement: single row <SQL data statement>
    select sublist <select list>
    select target list <select statement: single row>
    self-referencing column name <self-referencing column specification>
    self-referencing column specification <table element> <view element>
    semicolon <C variable definition> <direct SQL statement> <externally-invoked procedure> <MUMPS variable definition> <Pascal variable definition> <PL/I variable definition> <SQL special character> <SQL terminator> <triggered SQL statement>
    separator <binary string literal> <bracketed comment contents> <character string literal> <national character string literal> <Unicode character string literal>
    sequence column <search clause>
    sequence generator cycle option <basic sequence generator option>
    sequence generator data type option <sequence generator option>
    sequence generator definition <schema element> <SQL schema definition statement>
    sequence generator increment <sequence generator increment by option>
    sequence generator increment by option <basic sequence generator option>
    sequence generator max value <sequence generator maxvalue option>
    sequence generator maxvalue option <basic sequence generator option>
    sequence generator min value <sequence generator minvalue option>
    sequence generator minvalue option <basic sequence generator option>
    sequence generator name <alter sequence generator statement> <drop sequence generator statement> <next value expression> <object name> <sequence generator definition>
    sequence generator option <sequence generator options>
    sequence generator options <sequence generator definition>
    sequence generator restart value <alter sequence generator restart option>
    sequence generator start value <sequence generator start with option>
    sequence generator start with option <common sequence generator option>
    session characteristic <session characteristic list>
    session characteristic list <set session characteristics statement>
    set catalog statement <SQL session statement>
    set clause <set clause list>
    set clause list <dynamic update statement: positioned> <merge update specification> <preparable dynamic update statement: positioned> <update statement: positioned> <update statement: searched>
    set column default clause <alter column action>
    set connection statement <SQL connection statement>
    set constraints mode statement <SQL transaction statement>
    set descriptor information <set descriptor statement>
    set descriptor statement <system descriptor statement>
    set domain default clause <alter domain action>
    set function specification <nonparenthesized value expression primary>
    set function type <general set function>
    set header information <set descriptor information>
    set item information <set descriptor information>
    set local time zone statement <SQL session statement>
    set names statement <SQL session statement>
    set path statement <SQL session statement>
    set predicate <predicate>
    set predicate part 2 <set predicate> <when operand>
    set quantifier <general set function> <group by clause> <query specification> <select statement: single row>
    set role statement <SQL session statement>
    set schema statement <SQL session statement>
    set session characteristics statement <SQL session statement>
    set session collation statement <SQL session statement>
    set session user identifier statement <SQL session statement>
    set target <set clause> <set target list>
    set target list <multiple column assignment>
    set time zone value <set local time zone statement>
    set transaction statement <SQL transaction statement>
    set transform group statement <SQL session statement>
    sign <factor> <interval factor> <interval literal> <signed integer> <signed numeric literal> <time zone interval> <unquoted interval string>
    signed integer <exponent>
    signed numeric literal <literal> <sequence generator increment> <sequence generator max value> <sequence generator min value> <sequence generator restart value> <sequence generator start value>
    similar pattern <similar predicate part 2>
    similar predicate <predicate>
    similar predicate part 2 <similar predicate> <when operand>
    simple case <case specification>
    simple comment <comment>
    simple comment introducer <simple comment>
    simple Latin letter <SQL language character> <SQL language identifier part> <SQL language identifier start>
    simple Latin lower case letter <simple Latin letter>
    simple Latin upper case letter <simple Latin letter> <SQLSTATE char>
    simple table <non-join query primary>
    simple target specification <condition information item> <simple target specification 1> <simple target specification 2> <statement information item>
    simple target specification 1 <get header information>
    simple target specification 2 <get item information>
    simple value specification <attributes variable> <condition number> <connection name> <connection user name> <descriptor name> <extended cursor name> <extended statement name> <fetch orientation> <item number> <number of conditions> <occurrences> <simple value specification 1> <simple value specification 2> <SQL statement variable> <SQL-server name> <target array element specification> <update target>
    simple value specification 1 <set header information>
    simple value specification 2 <set item information>
    simple when clause <simple case>
    single datetime field <interval qualifier>
    single group specification <transform group specification>
    slash <bracketed comment introducer> <bracketed comment terminator>
    solidus <interval term> <SQL special character> <term>
    some <quantifier>
    sort key <sort specification>
    sort specification <sort specification list>
    sort specification list <order by clause> <recursive search order> <window order clause> <within group specification>
    source character set specification <transliteration definition>
    source data type <drop user-defined cast statement> <user-defined cast definition>
    space <day-time interval> <SQL special character> <unquoted timestamp string>
    specific method name <method specification designator> <partial method specification>
    specific method specification designator <drop method specification>
    specific name <routine characteristic> <specific routine designator> <state category>
    specific routine designator <alter routine statement> <cast function> <drop routine statement> <from sql function> <map function specification> <object name> <privilege method list> <relative function specification> <result set cursor> <to sql function> <transliteration routine>
    specific type method <character value function>
    SQL argument <SQL argument list>
    SQL argument list <attribute or method reference> <direct invocation> <generalized invocation> <method reference> <routine invocation> <static method invocation>
    SQL condition <condition>
    SQL connection statement <directly executable statement> <SQL executable statement>
    SQL control statement <preparable SQL control statement> <SQL executable statement>
    SQL data change statement <SQL data statement>
    SQL data statement <SQL executable statement>
    SQL diagnostics information <get diagnostics statement>
    SQL diagnostics statement <SQL executable statement>
    SQL dynamic data statement <SQL dynamic statement>
    SQL dynamic statement <SQL executable statement>
    SQL executable statement <SQL procedure statement>
    SQL language character <SQL terminal character>
    SQL language identifier <character set name>
    SQL language identifier part <SQL language identifier>
    SQL language identifier start <SQL language identifier>
    SQL parameter declaration <SQL parameter declaration list>
    SQL parameter declaration list <function specification> <method specification designator> <partial method specification> <SQL-invoked procedure>
    SQL parameter name <SQL parameter declaration>
    SQL parameter reference <general value specification> <simple target specification> <simple value specification> <target array reference> <target specification>
    SQL prefix <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
    SQL procedure statement <externally-invoked procedure> <SQL routine body> <statement or declaration> <triggered SQL statement>
    SQL routine body <SQL routine spec>
    SQL routine spec <routine body>
    SQL schema definition statement <SQL schema statement>
    SQL schema manipulation statement <SQL schema statement>
    SQL schema statement <directly executable statement> <preparable SQL schema statement> <SQL executable statement>
    SQL session statement <directly executable statement> <preparable SQL session statement> <SQL executable statement>
    SQL special character <delimiter token> <SQL language character>
    SQL statement name <deallocate prepared statement> <describe input statement> <described object> <execute statement> <prepare statement>
    SQL statement variable <execute immediate statement> <prepare statement>
    SQL terminator <embedded SQL begin declare> <embedded SQL end declare> <embedded SQL MUMPS declare> <embedded SQL statement>
    SQL transaction statement <directly executable statement> <preparable SQL transaction statement> <SQL executable statement>
    SQL-client module name <module name clause>
    SQL-data access indication <alter routine characteristic> <method characteristic> <routine characteristic>
    SQL-invoked function <schema function>
    SQL-invoked procedure <schema procedure>
    SQL-invoked routine <SQL schema definition statement>
    SQL-path characteristic <set path statement>
    SQL-server name <connection target>
    SQLSTATE class value <SQL condition>
    SQLSTATE subclass value <SQL condition>
    square root <numeric value function>
    standard character set name <character set specification>
    start field <interval qualifier>
    start position <blob overlay function> <blob substring function> <character overlay function> <character substring function>
    start transaction statement <SQL transaction statement>
    state category <ordering category>
    statement cursor <cursor intent>
    statement information <SQL diagnostics information>
    statement information item <statement information>
    statement information item name <statement information item>
    statement name <dynamic declare cursor> <SQL statement name>
    statement or declaration <embedded SQL statement>
    static method invocation <nonparenthesized value expression primary>
    status parameter <host parameter declaration>
    string length <blob overlay function> <blob substring function> <character overlay function> <character substring function>
    string position expression <position expression>
    string value expression <char length expression> <common value expression> <current collation specification> <normalized predicate> <octet length expression> <string position expression>
    string value function <blob primary> <character primary>
    submultiset predicate <predicate>
    submultiset predicate part 2 <submultiset predicate> <when operand>
    subquery <as subquery clause> <row subquery> <scalar subquery> <table subquery>
    subtable clause <table contents source>
    subtype clause <user-defined type body>
    subtype operand <subtype treatment>
    subtype treatment <nonparenthesized value expression primary>
    subview clause <referenceable view specification>
    supertable clause <subtable clause>
    supertable name <supertable clause>
    supertype name <subtype clause>
    system descriptor statement <SQL dynamic statement>
    system-generated representation <reference type specification>
    table commit action <table definition> <temporary table declaration>
    table constraint <table constraint definition>
    table constraint definition <add table constraint definition> <table element>
    table contents source <table definition>
    table definition <schema element> <SQL schema definition statement>
    table element <table element list>
    table element list <table contents source> <temporary table declaration>
    table expression <query specification> <select statement: single row>
    table function column list <returns table type>
    table function column list element <table function column list>
    table function derived table <table primary>
    table name <alter table statement> <drop table statement> <drop view statement> <insertion target> <like clause> <object name> <referenced table and columns> <scope clause> <subview clause> <supertable name> <table definition> <table or query name> <target table> <temporary table declaration> <trigger definition> <view definition>
    table or query name <explicit table> <only spec> <table primary>
    table primary <cross join> <natural join> <table primary or joined table> <union join>
    table primary or joined table <table reference>
    table reference <cross join> <merge statement> <natural join> <qualified join> <table reference list> <union join>
    table reference list <from clause>
    table row value expression <row value expression list>
    table scope <table definition>
    table subquery <derived table> <exists predicate> <in predicate value> <lateral derived table> <match predicate part 2> <quantified comparison predicate part 2> <unique predicate>
    table value constructor <simple table>
    table value constructor by query <multiset value constructor>
    target array element specification <target specification>
    target array reference <target array element specification>
    target character set specification <transliteration definition>
    target data type <drop user-defined cast statement> <user-defined cast definition>
    target specification <fetch target list> <into argument> <select target list> <SQL argument>
    target subtype <subtype treatment>
    target table <delete statement: positioned> <delete statement: searched> <dynamic delete statement: positioned> <dynamic update statement: positioned> <merge statement> <preparable dynamic delete statement: positioned> <preparable dynamic update statement: positioned> <update statement: positioned> <update statement: searched>
    temporary table declaration <direct SQL data statement> <SQL-client module definition> <statement or declaration>
    term <interval term> <numeric value expression> <term>
    time fractional seconds precision <time precision> <timestamp precision>
    time interval <day-time literal>
    time literal <datetime literal>
    time precision <current local time value function> <current time value function> <datetime type>
    time string <delimiter token> <time literal>
    time value <unquoted time string>
    time zone <datetime factor>
    time zone field <extract field>
    time zone interval <unquoted time string>
    time zone specifier <time zone>
    timestamp literal <datetime literal>
    timestamp precision <current local timestamp value function> <current timestamp value function> <datetime type>
    timestamp string <delimiter token> <timestamp literal>
    to sql <transform element>
    to sql function <to sql>
    transaction access mode <transaction mode>
    transaction characteristics <session characteristic> <set transaction statement>
    transaction mode <start transaction statement> <transaction characteristics>
    transcoding <character value function>
    transcoding name <transcoding>
    transform definition <schema element> <SQL schema definition statement>
    transform element <transform element list>
    transform element list <add transform element list> <transform group>
    transform group <transform definition>
    transform group characteristic <set transform group statement>
    transform group element <transforms to be dropped>
    transform group specification <embedded transform group specification> <external body reference> <module transform group specification>
    transform kind <drop transform element list>
    transforms to be dropped <drop transform statement>
    transliteration definition <schema element> <SQL schema definition statement>
    transliteration name <character transliteration> <drop transliteration statement> <existing transliteration name> <object name> <transliteration definition>
    transliteration routine <transliteration source>
    transliteration source <transliteration definition>
    trigger action time <trigger definition>
    trigger column list <trigger event>
    trigger definition <schema element> <SQL schema definition statement>
    trigger event <trigger definition>
    trigger name <drop trigger statement> <trigger definition>
    triggered action <trigger definition>
    triggered SQL statement <triggered action>
    trim character <trim operands>
    trim function <character value function>
    trim octet <blob trim operands>
    trim operands <trim function>
    trim source <trim operands>
    trim specification <blob trim operands> <trim operands>
    truth value <boolean test>
    type list <type predicate part 2>
    type predicate <predicate>
    type predicate part 2 <type predicate> <when operand>
    underscore <introducer> <regular character set> <SQL language identifier> <SQL special character>
    Unicode 4 digit escape value <Unicode escape value>
    Unicode 6 digit escape value <Unicode escape value>
    Unicode character escape value <Unicode escape value>
    Unicode character string literal <general literal>
    Unicode delimited identifier <delimiter token>
    Unicode delimiter body <Unicode delimited identifier>
    Unicode escape character <Unicode 4 digit escape value> <Unicode 6 digit escape value> <Unicode character escape value> <Unicode escape specifier>
    Unicode escape specifier <Unicode delimited identifier>
    Unicode escape value <Unicode identifier part> <Unicode representation>
    Unicode identifier part <Unicode delimiter body>
    Unicode representation <Unicode character string literal>
    union join <joined table>
    unique column list <unique constraint definition>
    unique constraint definition <table constraint>
    unique predicate <predicate>
    unique specification <column constraint> <unique constraint definition>
    unqualified schema name <schema name>
    unquoted date string <date string> <unquoted timestamp string>
    unquoted interval string <interval string>
    unquoted time string <time string> <unquoted timestamp string>
    unquoted timestamp string <timestamp string>
    unsigned integer <array type> <datetime value> <exact numeric literal> <goto target> <high value> <interval fractional seconds precision> <interval leading field precision> <large object length> <length> <low value> <maximum dynamic result sets> <precision> <scale> <seconds fraction> <seconds integer value> <signed integer> <time fractional seconds precision>
    unsigned literal <unsigned value specification>
    unsigned numeric literal <nondelimiter token> <signed numeric literal> <unsigned literal>
    unsigned value specification <nonparenthesized value expression primary> <window frame following> <window frame preceding>
    updatability clause <cursor specification>
    update rule <referential triggered action>
    update source <set clause>
    update statement: positioned <SQL data change statement>
    update statement: searched <direct SQL data statement> <preparable SQL data statement> <SQL data change statement>
    update target <set target>
    upper limit <repeat factor>
    user identifier <authorization identifier>
    user-defined cast definition <schema element> <SQL schema definition statement>
    user-defined character set name <character set specification>
    user-defined ordering definition <schema element> <SQL schema definition statement>
    user-defined representation <reference type specification>
    user-defined type body <user-defined type definition>
    user-defined type definition <schema element> <SQL schema definition statement>
    user-defined type name <path-resolved user-defined type name> <schema-resolved user-defined type name>
    user-defined type option <user-defined type option list>
    user-defined type option list <user-defined type body>
    user-defined type specification <type list>
    user-defined type value expression <common value expression> <specific type method>
    using argument <using arguments>
    using arguments <input using clause>
    using descriptor <describe input statement> <describe output statement> <using input descriptor>
    using input descriptor <input using clause>
    value expression <array element> <case abbreviation> <cast operand> <contextually typed row value constructor element> <cycle mark value> <derived column> <general set function> <generalized expression> <generation expression> <hypothetical set function value expression list> <merge insert value element> <multiset element> <non-cycle mark value> <parenthesized value expression> <result expression> <return value> <row value constructor element> <sort key> <SQL argument> <subtype operand> <update source>
    value expression primary <all fields reference> <array factor> <attribute or method reference> <blob primary> <character primary> <datetime primary> <direct invocation> <field reference> <generalized invocation> <interval primary> <method reference> <multiset primary> <numeric primary> <reference value expression> <user-defined type value expression>
    value specification <catalog name characteristic> <character set name characteristic> <collation specification> <role specification> <schema name characteristic> <set session user identifier statement> <SQL-path characteristic> <transform group characteristic>
    vertical bar <concatenation operator> <regular expression> <SQL special character>
    view column list <regular view specification>
    view column option <view element>
    view definition <schema element> <SQL schema definition statement>
    view element <view element list>
    view element list <referenceable view specification>
    view specification <view definition>
    when operand <simple when clause>
    where clause <table expression>
    white space <separator>
    width bucket bound 1 <width bucket function>
    width bucket bound 2 <width bucket function>
    width bucket count <width bucket function>
    width bucket function <numeric value function>
    width bucket operand <width bucket function>
    window clause <table expression>
    window definition <window definition list>
    window definition list <window clause>
    window frame between <window frame extent>
    window frame bound <window frame bound 1> <window frame bound 2>
    window frame bound 1 <window frame between>
    window frame bound 2 <window frame between>
    window frame clause <window specification details>
    window frame exclusion <window frame clause>
    window frame extent <window frame clause>
    window frame following <window frame bound>
    window frame preceding <window frame start>
    window frame start <window frame bound> <window frame extent>
    window frame units <window frame clause>
    window function <nonparenthesized value expression primary>
    window function type <window function>
    window name <existing window name> <new window name> <window name or specification>
    window name or specification <window function>
    window order clause <window specification details>
    window partition clause <window specification details>
    window partition column reference <window partition column reference list>
    window partition column reference list <window partition clause>
    window specification <in-line window specification> <window definition>
    window specification details <window specification>
    with clause <query expression>
    with column list <with list element>
    with list <with clause>
    with list element <with list>
    with or without data <as subquery clause>
    with or without time zone <datetime type>
    within group specification <hypothetical set function> <inverse distribution function>
    year-month literal <unquoted interval string>
    years value <date value> <year-month literal>

    Top


    Cross-Reference Table: Keywords

    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    Keyword Rules using it
    ABS <absolute value expression> <interval absolute value function> <non-reserved word>
    ABSOLUTE <fetch orientation> <non-reserved word>
    ACTION <non-reserved word> <referential action>
    ADA <language name> <non-reserved word>
    ADD <add attribute definition> <add column definition> <add column scope clause> <add domain constraint definition> <add original method specification> <add overriding method specification> <add table constraint definition> <add transform element list> <reserved word>
    ADMIN <grant role statement> <non-reserved word> <revoke role statement> <role definition>
    AFTER <non-reserved word> <trigger action time>
    ALL <all> <constraint name list> <disconnect object> <multiset term> <multiset value expression> <non-join query expression> <non-join query term> <object privileges> <reserved word> <set quantifier> <transforms to be dropped>
    ALLOCATE <allocate cursor statement> <allocate descriptor statement>