Skip to content

Instantly share code, notes, and snippets.

@drikosev

drikosev/direct_SQL_statement.txt

Created July 22, 2022 09:22
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save drikosev/3104c3cb79b0b4d8f41da6162f4c65d3 to your computer and use it in GitHub Desktop.
Save drikosev/3104c3cb79b0b4d8f41da6162f4c65d3 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
direct_SQL_statement.txt
<sql-implementation> ::=
<direct SQL statement>
<direct SQL statement> ::=
[ <separator> ] <directly executable statement> <semicolon>
<separator> ::=
{ <comment> | <white spaces> } ...
<comment> ::=
<simple comment>
| <bracketed comment>
<simple comment> ::=
- - [ <comment character> ... ] <newline>
<comment character> ::=
<wchar_t> -= <newline>
<wchar_t> ::=
\u0001 .. \uffff
<newline> ::=
\n \r
| \r \n
| \n
| \r
<bracketed comment> ::=
<bracketed comment introducer> <bracketed comment contents> <bracketed comment terminator>
<bracketed comment introducer> ::=
/ *
<bracketed comment contents> ::=
[ { <bracketed comment character> | <bracketed comment> } ... ]
<bracketed comment character> ::=
<wchar_t> -= { <asterisk> | <solidus> }
| <solidus> { <wchar_t> -= <asterisk> }
| <asterisk> { <wchar_t> -= <solidus> }
<asterisk> ::=
*
<solidus> ::=
/
<bracketed comment terminator> ::=
* /
<white spaces> ::=
<white space> ... -: <white space>
<white space> ::=
\t
| \s
| \n
| \r
| \nl
| \x000b
| \x000C
| \x0085
| \x2028
| \x2029
| \x00a0
| \x1680
| \x2000
| \x2001
| \x2002
| \x2003
| \x2004
| \x2005
| \x2006
| \x2007
| \x2008
| \x2009
| \x200a
| \x202f
| \x3000
<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>
<delete statement: searched> ::=
DELETE FROM <target table> [ [ AS ] <correlation name> ] [ WHERE <search condition> ]
DELETE ::=
D E L E T E
FROM ::=
F R O M
<target table> ::=
<table name>
| ONLY <left paren> <table name> <right paren>
<table name> ::=
<local or schema qualified name>
<local or schema qualified name> ::=
[ <local or schema qualifier> <period> ] <qualified identifier>
<local or schema qualifier> ::=
<schema name>
| <local qualifier>
<schema name> ::=
[ <catalog name> <period> ] <unqualified schema name>
<catalog name> ::=
<identifier>
<identifier> ::=
<actual identifier>
<actual identifier> ::=
<regular identifier>
| <delimited identifier>
| <Unicode delimited identifier>
<regular identifier> ::=
<identifier body> -= <reserved word>
<identifier body> ::=
<identifier start> [ <identifier part> ... ] -: <identifier part> /* */
<identifier start> ::=
A .. Z
| <underscore>
A ::=
a
<underscore> ::=
_
<identifier part> ::=
<identifier start>
| <identifier extend>
| <digit>
<identifier extend> ::=
\u00b7
<digit> ::=
0 .. 9
<reserved word> ::=
ABS
| ALL
| ALLOCATE
| ALTER
| AND
| <ANY>
| ARE
| ARRAY
| AS
| ASENSITIVE
| ASYMMETRIC
| AT
| ATOMIC
| AUTHORIZATION
| AVG
| BEGIN
| BETWEEN
| BIGINT
| BINARY
| BLOB
| BOOLEAN
| BOTH
| BY
| CALL
| CALLED
| CARDINALITY
| CASCADED
| CASE
| CAST
| CEIL
| CEILING
| CHAR
| CHAR_LENGTH
| CHARACTER
| CHARACTER_LENGTH
| CHECK
| CLOB
| CLOSE
| COALESCE
| COLLATE
| COLLECT
| COLUMN
| COMMIT
| CONDITION
| CONNECT
| CONSTRAINT
| CONVERT
| CORR
| CORRESPONDING
| COUNT
| COVAR_POP
| COVAR_SAMP
| CREATE
| CROSS
| CUBE
| CUME_DIST
| 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
| DENSE_RANK
| DEREF
| DESCRIBE
| DETERMINISTIC
| DISCONNECT
| DISTINCT
| DOUBLE
| DROP
| DYNAMIC
| EACH
| ELEMENT
| ELSE
| END
| END-EXEC
| ESCAPE
| EVERY
| EXCEPT
| EXEC
| EXECUTE
| EXISTS
| EXP
| EXTERNAL
| EXTRACT
| FALSE
| FETCH
| FILTER
| FLOAT
| FLOOR
| FOR
| FOREIGN
| FREE
| FROM
| FULL
| FUNCTION
| FUSION
| GET
| GLOBAL
| GRANT
| GROUP
| GROUPING
| HAVING
| HOLD
| HOUR
| IDENTITY
| IN
| INDICATOR
| INNER
| INOUT
| INSENSITIVE
| INSERT
| INT
| INTEGER
| INTERSECT
| INTERSECTION
| INTERVAL
| INTO
| IS
| JOIN
| LANGUAGE
| LARGE
| LATERAL
| LEADING
| LEFT
| LIKE
| LN
| LOCAL
| LOCALTIME
| LOCALTIMESTAMP
| LOWER
| MATCH
| MAX
| MEMBER
| MERGE
| METHOD
| MIN
| MINUTE
| MOD
| MODIFIES
| MODULE
| MONTH
| MULTISET
| NATIONAL
| NATURAL
| NCHAR
| NCLOB
| NEW
| NO
| <NONE>
| NORMALIZE
| NOT
| NULL
| NULLIF
| NUMERIC
| OCTET_LENGTH
| OF
| OLD
| ON
| ONLY
| OPEN
| OR
| ORDER
| OUT
| OUTER
| OVER
| OVERLAPS
| OVERLAY
| PARAMETER
| PARTITION
| PERCENT_RANK
| PERCENTILE_CONT
| PERCENTILE_DISC
| POSITION
| POWER
| PRECISION
| PREPARE
| PRIMARY
| PROCEDURE
| RANGE
| RANK
| 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
| ROW_NUMBER
| ROWS
| SAVEPOINT
| SCOPE
| SCROLL
| SEARCH
| SECOND
| SELECT
| SENSITIVE
| SESSION_USER
| SET
| SIMILAR
| SMALLINT
| SOME
| SPECIFIC
| SPECIFICTYPE
| SQL
| SQLEXCEPTION
| SQLSTATE
| SQLWARNING
| SQRT
| START
| STATIC
| STDDEV_POP
| STDDEV_SAMP
| SUBMULTISET
| SUBSTRING
| SUM
| SYMMETRIC
| SYSTEM
| SYSTEM_USER
| TABLE
| TABLESAMPLE
| THEN
| TIME
| TIMESTAMP
| TIMEZONE_HOUR
| TIMEZONE_MINUTE
| TO
| TRAILING
| TRANSLATE
| TRANSLATION
| TREAT
| TRIGGER
| TRIM
| 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
ABS ::=
A B S
B ::=
b
ALL ::=
A L L
ALLOCATE ::=
A L L O C A T E
C ::=
c
ALTER ::=
A L T E R
AND ::=
A N D
<ANY> ::=
A N Y
ARE ::=
A R E
ARRAY ::=
A R R A Y
AS ::=
A S
ASENSITIVE ::=
A S E N S I T I V E
ASYMMETRIC ::=
A S Y M M E T R I C
AT ::=
A T
ATOMIC ::=
A T O M I C
AUTHORIZATION ::=
A U T H O R I Z A T I O N
AVG ::=
A V G
BEGIN ::=
B E G I N
BETWEEN ::=
B E T W E E N
BIGINT ::=
B I G I N T
BINARY ::=
B I N A R Y
BLOB ::=
B L O B
BOOLEAN ::=
B O O L E A N
BOTH ::=
B O T H
BY ::=
B Y
CALL ::=
C A L L
CALLED ::=
C A L L E D
CARDINALITY ::=
C A R D I N A L I T Y
CASCADED ::=
C A S C A D E D
CASE ::=
C A S E
CAST ::=
C A S T
CEIL ::=
C E I L
CEILING ::=
C E I L I N G
CHAR ::=
C H A R
CHAR_LENGTH ::=
C H A R _ L E N G T H
CHARACTER ::=
C H A R A C T E R
CHARACTER_LENGTH ::=
C H A R A C T E R _ L E N G T H
CHECK ::=
C H E C K
CLOB ::=
C L O B
CLOSE ::=
C L O S E
COALESCE ::=
C O A L E S C E
COLLATE ::=
C O L L A T E
COLLECT ::=
C O L L E C T
COLUMN ::=
C O L U M N
COMMIT ::=
C O M M I T
CONDITION ::=
C O N D I T I O N
CONNECT ::=
C O N N E C T
CONSTRAINT ::=
C O N S T R A I N T
CONVERT ::=
C O N V E R T
CORR ::=
C O R R
CORRESPONDING ::=
C O R R E S P O N D I N G
COUNT ::=
C O U N T
COVAR_POP ::=
C O V A R _ P O P
COVAR_SAMP ::=
C O V A R _ S A M P
CREATE ::=
C R E A T E
CROSS ::=
C R O S S
CUBE ::=
C U B E
CUME_DIST ::=
C U M E _ D I S T
CURRENT ::=
C U R R E N T
CURRENT_DATE ::=
C U R R E N T _ D A T E
CURRENT_DEFAULT_TRANSFORM_GROUP ::=
C U R R E N T _ D E F A U L T _ T R A N S F O R M _ G R O U P
CURRENT_PATH ::=
C U R R E N T _ P A T H
CURRENT_ROLE ::=
C U R R E N T _ R O L E
CURRENT_TIME ::=
C U R R E N T _ T I M E
CURRENT_TIMESTAMP ::=
C U R R E N T _ T I M E S T A M P
CURRENT_TRANSFORM_GROUP_FOR_TYPE ::=
C U R R E N T _ T R A N S F O R M _ G R O U P _ F O R _ T Y P E
CURRENT_USER ::=
C U R R E N T _ U S E R
CURSOR ::=
C U R S O R
CYCLE ::=
C Y C L E
DATE ::=
D A T E
DAY ::=
D A Y
DEALLOCATE ::=
D E A L L O C A T E
DEC ::=
D E C
DECIMAL ::=
D E C I M A L
DECLARE ::=
D E C L A R E
DEFAULT ::=
D E F A U L T
DENSE_RANK ::=
D E N S E _ R A N K
DEREF ::=
D E R E F
DESCRIBE ::=
D E S C R I B E
DETERMINISTIC ::=
D E T E R M I N I S T I C
DISCONNECT ::=
D I S C O N N E C T
DISTINCT ::=
D I S T I N C T
DOUBLE ::=
D O U B L E
DROP ::=
D R O P
DYNAMIC ::=
D Y N A M I C
EACH ::=
E A C H
ELEMENT ::=
E L E M E N T
ELSE ::=
E L S E
END ::=
E N D
END-EXEC ::=
E N D - E X E C
ESCAPE ::=
E S C A P E
EVERY ::=
E V E R Y
EXCEPT ::=
E X C E P T
EXEC ::=
E X E C
EXECUTE ::=
E X E C U T E
EXISTS ::=
E X I S T S
EXP ::=
E X P
EXTERNAL ::=
E X T E R N A L
EXTRACT ::=
E X T R A C T
FALSE ::=
F A L S E
FETCH ::=
F E T C H
FILTER ::=
F I L T E R
FLOAT ::=
F L O A T
FLOOR ::=
F L O O R
FOR ::=
F O R
FOREIGN ::=
F O R E I G N
FREE ::=
F R E E
FULL ::=
F U L L
FUNCTION ::=
F U N C T I O N
FUSION ::=
F U S I O N
GET ::=
G E T
GLOBAL ::=
G L O B A L
GRANT ::=
G R A N T
GROUP ::=
G R O U P
GROUPING ::=
G R O U P I N G
HAVING ::=
H A V I N G
HOLD ::=
H O L D
HOUR ::=
H O U R
IDENTITY ::=
I D E N T I T Y
IN ::=
I N
INDICATOR ::=
I N D I C A T O R
INNER ::=
I N N E R
INOUT ::=
I N O U T
INSENSITIVE ::=
I N S E N S I T I V E
INSERT ::=
I N S E R T
INT ::=
I N T
INTEGER ::=
I N T E G E R
INTERSECT ::=
I N T E R S E C T
INTERSECTION ::=
I N T E R S E C T I O N
INTERVAL ::=
I N T E R V A L
INTO ::=
I N T O
IS ::=
I S
JOIN ::=
J O I N
LANGUAGE ::=
L A N G U A G E
LARGE ::=
L A R G E
LATERAL ::=
L A T E R A L
LEADING ::=
L E A D I N G
LEFT ::=
L E F T
LIKE ::=
L I K E
LN ::=
L N
LOCAL ::=
L O C A L
LOCALTIME ::=
L O C A L T I M E
LOCALTIMESTAMP ::=
L O C A L T I M E S T A M P
LOWER ::=
L O W E R
MATCH ::=
M A T C H
MAX ::=
M A X
MEMBER ::=
M E M B E R
MERGE ::=
M E R G E
METHOD ::=
M E T H O D
MIN ::=
M I N
MINUTE ::=
M I N U T E
MOD ::=
M O D
MODIFIES ::=
M O D I F I E S
MODULE ::=
M O D U L E
MONTH ::=
M O N T H
MULTISET ::=
M U L T I S E T
NATIONAL ::=
N A T I O N A L
NATURAL ::=
N A T U R A L
NCHAR ::=
N C H A R
NCLOB ::=
N C L O B
NEW ::=
N E W
NO ::=
N O
<NONE> ::=
N O N E
NORMALIZE ::=
N O R M A L I Z E
NOT ::=
N O T
NULL ::=
N U L L
NULLIF ::=
N U L L I F
NUMERIC ::=
N U M E R I C
OCTET_LENGTH ::=
O C T E T _ L E N G T H
OF ::=
O F
OLD ::=
O L D
ON ::=
O N
ONLY ::=
O N L Y
OPEN ::=
O P E N
OR ::=
O R
ORDER ::=
O R D E R
OUT ::=
O U T
OUTER ::=
O U T E R
OVER ::=
O V E R
OVERLAPS ::=
O V E R L A P S
OVERLAY ::=
O V E R L A Y
PARAMETER ::=
P A R A M E T E R
PARTITION ::=
P A R T I T I O N
PERCENT_RANK ::=
P E R C E N T _ R A N K
PERCENTILE_CONT ::=
P E R C E N T I L E _ C O N T
PERCENTILE_DISC ::=
P E R C E N T I L E _ D I S C
POSITION ::=
P O S I T I O N
POWER ::=
P O W E R
PRECISION ::=
P R E C I S I O N
PREPARE ::=
P R E P A R E
PRIMARY ::=
P R I M A R Y
PROCEDURE ::=
P R O C E D U R E
RANGE ::=
R A N G E
RANK ::=
R A N K
READS ::=
R E A D S
REAL ::=
R E A L
RECURSIVE ::=
R E C U R S I V E
REF ::=
R E F
REFERENCES ::=
R E F E R E N C E S
REFERENCING ::=
R E F E R E N C I N G
REGR_AVGX ::=
R E G R _ A V G X
REGR_AVGY ::=
R E G R _ A V G Y
REGR_COUNT ::=
R E G R _ C O U N T
REGR_INTERCEPT ::=
R E G R _ I N T E R C E P T
REGR_R2 ::=
R E G R _ R 2
REGR_SLOPE ::=
R E G R _ S L O P E
REGR_SXX ::=
R E G R _ S X X
REGR_SXY ::=
R E G R _ S X Y
REGR_SYY ::=
R E G R _ S Y Y
RELEASE ::=
R E L E A S E
RESULT ::=
R E S U L T
RETURN ::=
R E T U R N
RETURNS ::=
R E T U R N S
REVOKE ::=
R E V O K E
RIGHT ::=
R I G H T
ROLLBACK ::=
R O L L B A C K
ROLLUP ::=
R O L L U P
ROW ::=
R O W
ROW_NUMBER ::=
R O W _ N U M B E R
ROWS ::=
R O W S
SAVEPOINT ::=
S A V E P O I N T
SCOPE ::=
S C O P E
SCROLL ::=
S C R O L L
SEARCH ::=
S E A R C H
SECOND ::=
S E C O N D
SELECT ::=
S E L E C T
SENSITIVE ::=
S E N S I T I V E
SESSION_USER ::=
S E S S I O N _ U S E R
SET ::=
S E T
SIMILAR ::=
S I M I L A R
SMALLINT ::=
S M A L L I N T
SOME ::=
S O M E
SPECIFIC ::=
S P E C I F I C
SPECIFICTYPE ::=
S P E C I F I C T Y P E
SQL ::=
S Q L
SQLEXCEPTION ::=
S Q L E X C E P T I O N
SQLSTATE ::=
S Q L S T A T E
SQLWARNING ::=
S Q L W A R N I N G
SQRT ::=
S Q R T
START ::=
S T A R T
STATIC ::=
S T A T I C
STDDEV_POP ::=
S T D D E V _ P O P
STDDEV_SAMP ::=
S T D D E V _ S A M P
SUBMULTISET ::=
S U B M U L T I S E T
SUBSTRING ::=
S U B S T R I N G
SUM ::=
S U M
SYMMETRIC ::=
S Y M M E T R I C
SYSTEM ::=
S Y S T E M
SYSTEM_USER ::=
S Y S T E M _ U S E R
TABLE ::=
T A B L E
TABLESAMPLE ::=
T A B L E S A M P L E
THEN ::=
T H E N
TIME ::=
T I M E
TIMESTAMP ::=
T I M E S T A M P
TIMEZONE_HOUR ::=
T I M E Z O N E _ H O U R
TIMEZONE_MINUTE ::=
T I M E Z O N E _ M I N U T E
TO ::=
T O
TRAILING ::=
T R A I L I N G
TRANSLATE ::=
T R A N S L A T E
TRANSLATION ::=
T R A N S L A T I O N
TREAT ::=
T R E A T
TRIGGER ::=
T R I G G E R
TRIM ::=
T R I M
TRUE ::=
T R U E
UESCAPE ::=
U E S C A P E
UNION ::=
U N I O N
UNIQUE ::=
U N I Q U E
UNKNOWN ::=
U N K N O W N
UNNEST ::=
U N N E S T
UPDATE ::=
U P D A T E
UPPER ::=
U P P E R
USER ::=
U S E R
USING ::=
U S I N G
VALUE ::=
V A L U E
VALUES ::=
V A L U E S
VAR_POP ::=
V A R _ P O P
VAR_SAMP ::=
V A R _ S A M P
VARCHAR ::=
V A R C H A R
VARYING ::=
V A R Y I N G
WHEN ::=
W H E N
WHENEVER ::=
W H E N E V E R
WHERE ::=
W H E R E
WIDTH_BUCKET ::=
W I D T H _ B U C K E T
WINDOW ::=
W I N D O W
WITH ::=
W I T H
WITHIN ::=
W I T H I N
WITHOUT ::=
W I T H O U T
YEAR ::=
Y E A R
<delimited identifier> ::=
<double quote> <delimited identifier body> <double quote>
<double quote> ::=
"
<delimited identifier body> ::=
{ <delimited identifier part> ... } -= <delimited identifier body is long>
<delimited identifier part> ::=
<nondoublequote character>
| <doublequote symbol>
<nondoublequote character> ::=
<wchar_t> -= <double quote>
<doublequote symbol> ::=
" "
<delimited identifier body is long> ::=
<delimited identifier part> [ 128 ] <delimited identifier part> ...
<Unicode delimited identifier> ::=
U <ampersand> <double quote> <Unicode delimiter body> <double quote> <Unicode escape specifier>
<ampersand> ::=
&
<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>
<Unicode 4 digit escape value> ::=
<Unicode escape character>
<hexit>
<hexit>
<hexit>
<hexit>
<Unicode escape character> ::=
!!
<hexit> ::=
<digit>
| A
| B
| C
| D
| E
| F
| a
| b
| c
| d
| e
| f
<Unicode 6 digit escape value> ::=
<Unicode escape character>
<plus sign>
<hexit>
<hexit>
<hexit>
<hexit>
<hexit>
<hexit>
<plus sign> ::=
+
<Unicode character escape value> ::=
<Unicode escape character> <Unicode escape character>
<Unicode escape specifier> ::=
[ UESCAPE <quote> <Unicode escape character> <quote> ]
<quote> ::=
'
<period> ::=
.
<unqualified schema name> ::=
<identifier>
<local qualifier> ::=
MODULE
<qualified identifier> ::=
<identifier>
<left paren> ::=
(
<right paren> ::=
)
<correlation name> ::=
<identifier>
<search condition> ::=
<boolean value expression>
<boolean value expression> ::=
<boolean term>
| <boolean value expression> OR <boolean term>
<boolean term> ::=
<boolean factor>
| <boolean term> AND <boolean factor>
<boolean factor> ::=
[ NOT ] <boolean test>
<boolean test> ::=
<boolean primary> [ IS [ NOT ] <truth value> ]
<boolean primary> ::=
<predicate>
| <boolean predicand>
<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>
<comparison predicate> ::=
<numeric value expression> <comp op> <numeric value expression>
<numeric value expression> ::=
<term>
| <numeric value expression> <plus sign> <term>
| <numeric value expression> <minus sign> <term>
<term> ::=
<factor>
| <term> <asterisk> <factor>
| <term> <solidus> <factor>
<factor> ::=
[ <sign> ] <numeric primary>
<sign> ::=
<plus sign>
| <minus sign>
<minus sign> ::=
-
<numeric primary> ::=
<string value expression>
| <numeric value function>
<string value expression> ::=
<character value expression>
<character value expression> ::=
<concatenation>
| <character factor>
<concatenation> ::=
<character value expression> <concatenation operator> <character factor>
<concatenation operator> ::=
| |
<character factor> ::=
<character primary> [ <collate clause> ]
<character primary> ::=
<value expression primary>
| <string value function>
<value expression primary> ::=
<parenthesized value expression>
| <nonparenthesized value expression primary>
<parenthesized value expression> ::=
<left paren> <value expression> <right paren>
<value expression> ::=
<boolean value expression>
<nonparenthesized value expression primary> ::=
<unsigned value specification>
| <column reference>
| <set function specification>
| <window function>
| <scalar subquery>
| <case expression>
| <cast specification>
| <subtype treatment>
| <static method invocation>
| <new specification>
| <attribute or method reference>
| <reference resolution>
| <collection value constructor>
| <array element reference>
| <multiset element reference>
| <routine or method invocation>
| <next value expression>
<unsigned value specification> ::=
<unsigned literal>
| <general value specification>
<unsigned literal> ::=
<unsigned numeric literal>
| <general literal>
<unsigned numeric literal> ::=
<exact numeric literal>
| <approximate numeric literal>
<exact numeric literal> ::=
<unsigned integer> [ <period> [ <unsigned integer> ] ]
| <period> <unsigned integer>
<unsigned integer> ::=
<digit> ...
<approximate numeric literal> ::=
<mantissa> E <exponent>
<mantissa> ::=
<exact numeric literal>
<exponent> ::=
<signed integer>
<signed integer> ::=
[ <sign> ] <unsigned integer>
<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> ::=
<quote> [ <character representation> ... ] <quote>
<character representation> ::=
<nonquote character>
| <quote symbol>
<nonquote character> ::=
<wchar_t> -= <quote>
<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> } ... ] <Unicode escape specifier>
<introducer> ::=
<underscore>
<Unicode representation> ::=
<character representation>
| <Unicode escape value>
<binary string literal> ::=
X <quote> [ { <hexit> <hexit> } ... ] <quote> [ { <separator> <quote> [ { <hexit> <hexit> } ... ] <quote> } ... ]
<datetime literal> ::=
<date literal>
| <time literal>
| <timestamp literal>
<date literal> ::=
DATE <date string>
<date string> ::=
<quote> <unquoted date string> <quote>
<unquoted date string> ::=
<date value>
<date value> ::=
<years value>
<minus sign>
<months value>
<minus sign>
<days value>
<years value> ::=
<datetime value>
<datetime value> ::=
<unsigned integer>
<months value> ::=
<datetime value>
<days value> ::=
<datetime value>
<time literal> ::=
TIME <time string>
<time string> ::=
<quote> <unquoted time string> <quote>
<unquoted time string> ::=
<time value> [ <time zone interval> ]
<time value> ::=
<hours value>
<colon>
<minutes value>
<colon>
<seconds value>
<hours value> ::=
<datetime value>
<colon> ::=
:
<minutes value> ::=
<datetime value>
<seconds value> ::=
<seconds integer value> [ <period> [ <seconds fraction> ] ]
<seconds integer value> ::=
<unsigned integer>
<seconds fraction> ::=
<unsigned integer>
<time zone interval> ::=
<sign>
<hours value>
<colon>
<minutes value>
<timestamp literal> ::=
TIMESTAMP <timestamp string>
<timestamp string> ::=
<quote> <unquoted timestamp string> <quote>
<unquoted timestamp string> ::=
<unquoted date string> <space> <unquoted time string>
<space> ::=
\s
<interval literal> ::=
INTERVAL [ <sign> ] <interval string> <interval qualifier>
<interval string> ::=
<quote> <unquoted interval string> <quote>
<unquoted interval string> ::=
[ <sign> ] { <year-month literal> | <day-time literal> }
<year-month literal> ::=
<years value> [ <minus sign> <months value> ]
| <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>
<interval qualifier> ::=
<start field> TO <end field>
| <single datetime field>
<start field> ::=
<non-second primary datetime field> [ <left paren> <interval leading field precision> <right paren> ]
<non-second primary datetime field> ::=
YEAR
| MONTH
| DAY
| HOUR
| MINUTE
<interval leading field precision> ::=
<unsigned integer>
<end field> ::=
<non-second primary datetime field>
| SECOND [ <left paren> <interval fractional seconds precision> <right paren> ]
<interval fractional seconds precision> ::=
<unsigned integer>
<single datetime field> ::=
<non-second primary datetime field> [ <left paren> <interval leading field precision> <right paren> ]
| SECOND [ <left paren> <interval leading field precision> [ <comma> <interval fractional seconds precision> ] <right paren> ]
<comma> ::=
,
<boolean literal> ::=
TRUE
| FALSE
| UNKNOWN
<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
<host parameter specification> ::=
<host parameter name> [ <indicator parameter> ]
<host parameter name> ::=
<colon> <identifier>
<indicator parameter> ::=
[ INDICATOR ] <host parameter name>
<SQL parameter reference> ::=
<basic identifier chain>
<basic identifier chain> ::=
<identifier chain>
<identifier chain> ::=
<identifier> [ { <period> <identifier> } ... ]
<dynamic parameter specification> ::=
<question mark>
<question mark> ::=
?
<embedded variable specification> ::=
<embedded variable name> [ <indicator variable> ]
<embedded variable name> ::=
<colon> <host identifier>
<host identifier> ::=
<Ada host identifier>
| <C host identifier>
| <COBOL host identifier>
| <Fortran host identifier>
| <MUMPS host identifier>
| <Pascal host identifier>
| <PL/I host identifier>
<Ada host identifier> ::=
!!
<C host identifier> ::=
!!
<COBOL host identifier> ::=
!!
<Fortran host identifier> ::=
!!
<MUMPS host identifier> ::=
!!
<Pascal host identifier> ::=
!!
<PL/I host identifier> ::=
!!
<indicator variable> ::=
[ INDICATOR ] <embedded variable name>
<current collation specification> ::=
COLLATION
FOR
<left paren>
<string value expression>
<right paren>
COLLATION ::=
C O L L A T I O N
<path-resolved user-defined type name> ::=
<user-defined type name>
<user-defined type name> ::=
[ <schema name> <period> ] <qualified identifier>
<column reference> ::=
<basic identifier chain>
<set function specification> ::=
<aggregate function>
| <grouping operation>
<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> ]
<filter clause> ::=
FILTER
<left paren>
WHERE
<search condition>
<right paren>
<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
<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>
<rank function type> ::=
RANK
| DENSE_RANK
| PERCENT_RANK
| CUME_DIST
<hypothetical set function value expression list> ::=
<value expression> [ { <comma> <value expression> } ... ]
<within group specification> ::=
WITHIN
GROUP
<left paren>
ORDER
BY
<sort specification list>
<right paren>
<sort specification list> ::=
<sort specification> [ { <comma> <sort specification> } ... ]
<sort specification> ::=
<sort key> [ <ordering specification> ] [ <null ordering> ]
<sort key> ::=
<value expression>
<ordering specification> ::=
ASC
| DESC
ASC ::=
A S C
DESC ::=
D E S C
<null ordering> ::=
NULLS FIRST
| NULLS LAST
NULLS ::=
N U L L S
FIRST ::=
F I R S T
LAST ::=
L A S T
<inverse distribution function> ::=
<inverse distribution function type>
<left paren>
<inverse distribution function argument>
<right paren>
<within group specification>
<inverse distribution function type> ::=
PERCENTILE_CONT
| PERCENTILE_DISC
<inverse distribution function argument> ::=
<numeric value expression>
<grouping operation> ::=
GROUPING <left paren> <column reference> [ { <comma> <column reference> } ... ] <right paren>
<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>
<window name or specification> ::=
<window name>
| <in-line window specification>
<window name> ::=
<identifier>
<in-line window specification> ::=
<window specification>
<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> ]
<collate clause> ::=
COLLATE <collation name>
<collation name> ::=
<schema qualified name>
<schema qualified name> ::=
[ <schema name> <period> ] <qualified identifier>
<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
UNBOUNDED ::=
U N B O U N D E D
PRECEDING ::=
P R E C E D I N G
<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> ::=
<window frame start>
| UNBOUNDED FOLLOWING
| <window frame following>
FOLLOWING ::=
F O L L O W I N G
<window frame following> ::=
<unsigned value specification> FOLLOWING
<window frame bound 2> ::=
<window frame bound>
<window frame exclusion> ::=
EXCLUDE CURRENT ROW
| EXCLUDE GROUP
| EXCLUDE TIES
| EXCLUDE NO OTHERS
EXCLUDE ::=
E X C L U D E
TIES ::=
T I E S
OTHERS ::=
O T H E R S
<scalar subquery> ::=
<subquery>
<subquery> ::=
<left paren> <query expression> <right paren>
<query expression> ::=
[ <with clause> ] <query expression body>
<with clause> ::=
WITH [ RECURSIVE ] <with list>
<with list> ::=
<with list element> [ { <comma> <with list element> } ... ]
<with list element> ::=
<query name> [ <left paren> <with column list> <right paren> ] AS <left paren> <query expression> <right paren> [ <search or cycle clause> ]
<query name> ::=
<identifier>
<with column list> ::=
<column name list>
<column name list> ::=
<column name> [ { <comma> <column name> } ... ]
<column name> ::=
<identifier>
<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>
DEPTH ::=
D E P T H
BREADTH ::=
B R E A D T H
<sequence column> ::=
<column name>
<cycle clause> ::=
CYCLE
<cycle column list>
SET
<cycle mark column>
TO
<cycle mark value>
DEFAULT
<non-cycle mark value>
USING
<path column>
<cycle column list> ::=
<cycle column> [ { <comma> <cycle column> } ... ]
<cycle column> ::=
<column name>
<cycle mark column> ::=
<column name>
<cycle mark value> ::=
<value expression>
<non-cycle mark value> ::=
<value expression>
<path column> ::=
<column name>
<query expression body> ::=
<query term>
| <query expression body> UNION [ ALL | DISTINCT ] [ <corresponding spec> ] <query term>
| <query expression body> EXCEPT [ ALL | DISTINCT ] [ <corresponding spec> ] <query term>
<query term> ::=
<query primary>
| <query term> INTERSECT [ ALL | DISTINCT ] [ <corresponding spec> ] <query primary>
<query primary> ::=
<simple table>
| <left paren> <query expression body> <right paren>
<simple table> ::=
<query specification>
| <table value constructor>
| <explicit table>
<query specification> ::=
SELECT [ <set quantifier> ] <select list> <table expression>
<select list> ::=
<asterisk>
| <select sublist> [ { <comma> <select sublist> } ... ]
<select sublist> ::=
<derived column>
| <qualified asterisk>
<derived column> ::=
<value expression> [ <as clause> ]
<as clause> ::=
[ AS ] <column name>
<qualified asterisk> ::=
<asterisked identifier chain> <period> <asterisk>
| <all fields reference>
<asterisked identifier chain> ::=
<asterisked identifier> [ { <period> <asterisked identifier> } ... ]
<asterisked identifier> ::=
<identifier>
<all fields reference> ::=
<value expression primary> <period> <asterisk> [ AS <left paren> <all fields column name list> <right paren> ]
<all fields column name list> ::=
<column name list>
<table expression> ::=
<from clause> [ <where clause> ] [ <group by clause> ] [ <having clause> ] [ <window clause> ]
<from clause> ::=
FROM <table reference list>
<table reference list> ::=
<table reference> [ { <comma> <table reference> } ... ]
<table reference> ::=
<table factor>
| <joined table>
<table factor> ::=
<table primary> [ <sample clause> ]
<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>
<table or query name> ::=
<table name>
<derived column list> ::=
<column name list>
<derived table> ::=
<table subquery>
<table subquery> ::=
<subquery>
<lateral derived table> ::=
LATERAL <table subquery>
<collection derived table> ::=
UNNEST <left paren> <collection value expression> <right paren> [ WITH ORDINALITY ]
<collection value expression> ::=
<array value expression>
| <multiset value expression>
<array value expression> ::=
<array concatenation>
| <array primary>
<array concatenation> ::=
<array value expression 1> <concatenation operator> <array primary>
<array value expression 1> ::=
<array value expression>
<array primary> ::=
<value expression primary>
<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>
<multiset value function> ::=
<multiset set function>
<multiset set function> ::=
SET
<left paren>
<multiset value expression>
<right paren>
ORDINALITY ::=
O R D I N A L I T Y
<table function derived table> ::=
TABLE
<left paren>
<collection value expression>
<right paren>
<only spec> ::=
ONLY
<left paren>
<table or query name>
<right paren>
<joined table> ::=
<cross join>
| <qualified join>
| <natural join>
<cross join> ::=
<table reference>
CROSS
JOIN
<table factor>
<qualified join> ::=
<table reference> [ <join type> ] JOIN <table reference> <join specification>
<join type> ::=
INNER
| <outer join type> [ OUTER ]
<outer join type> ::=
LEFT
| RIGHT
| FULL
<join specification> ::=
<join condition>
| <named columns join>
<join condition> ::=
ON <search condition>
<named columns join> ::=
USING
<left paren>
<join column list>
<right paren>
<join column list> ::=
<column name list>
<natural join> ::=
<table reference> NATURAL [ <join type> ] JOIN <table factor>
<sample clause> ::=
TABLESAMPLE <sample method> <left paren> <sample percentage> <right paren> [ <repeatable clause> ]
<sample method> ::=
BERNOULLI
| SYSTEM
BERNOULLI ::=
B E R N O U L L I
<sample percentage> ::=
<numeric value expression>
<repeatable clause> ::=
REPEATABLE
<left paren>
<repeat argument>
<right paren>
REPEATABLE ::=
R E P E A T A B L E
<repeat argument> ::=
<numeric value expression>
<where clause> ::=
WHERE <search condition>
<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>
SETS ::=
S E T S
<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>
<having clause> ::=
HAVING <search condition>
<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>
<table value constructor> ::=
VALUES <row value expression list>
<row value expression list> ::=
<table row value expression> [ { <comma> <table row value expression> } ... ]
<table row value expression> ::=
<row value special case>
| <row value constructor>
<row value special case> ::=
<nonparenthesized value expression primary>
<row value constructor> ::=
<common value expression>
| <boolean value expression>
| <explicit row value constructor>
<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>
<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>
<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> ]
<time precision> ::=
<time fractional seconds precision>
<time fractional seconds precision> ::=
<unsigned integer>
<current timestamp value function> ::=
CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
<timestamp precision> ::=
<time fractional seconds precision>
<current local time value function> ::=
LOCALTIME [ <left paren> <time precision> <right paren> ]
<current local timestamp value function> ::=
LOCALTIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
<time zone> ::=
AT <time zone specifier>
<time zone specifier> ::=
LOCAL
| TIME ZONE <interval primary>
ZONE ::=
Z O N E
<interval primary> ::=
<value expression primary> [ <interval qualifier> ]
| <interval value function>
<interval value function> ::=
<interval absolute value function>
<interval absolute value function> ::=
ABS
<left paren>
<interval value expression>
<right paren>
<interval value expression> ::=
<interval term>
| <interval value expression 1> <plus sign> <interval term 1>
| <interval value expression 1> <minus sign> <interval term 1>
| <left paren> <datetime value expression> <minus sign> <datetime term> <right paren> <interval qualifier>
<interval term> ::=
<interval factor>
| <interval term 2> <asterisk> <factor>
| <interval term 2> <solidus> <factor>
| <term> <asterisk> <interval factor>
<interval factor> ::=
[ <sign> ] <interval primary>
<interval term 2> ::=
<interval term>
<interval value expression 1> ::=
<interval value expression>
<interval term 1> ::=
<interval term>
<user-defined type value expression> ::=
<value expression primary>
<reference value expression> ::=
<value expression primary>
<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> ::=
<value expression>
<row value constructor element list> ::=
<row value constructor element> [ { <comma> <row value constructor element> } ... ]
<row subquery> ::=
<subquery>
<explicit table> ::=
TABLE <table or query name>
<corresponding spec> ::=
CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]
<corresponding column list> ::=
<column name list>
<case expression> ::=
<case abbreviation>
| <case specification>
<case abbreviation> ::=
NULLIF <left paren> <value expression> <comma> <value expression> <right paren>
| COALESCE <left paren> <value expression> { <comma> <value expression> } ... <right paren>
<case specification> ::=
<simple case>
| <searched case>
<simple case> ::=
CASE <case operand> <simple when clause> ... [ <else clause> ] END
<case operand> ::=
<row value predicand>
| <overlaps predicate part 1>
<row value predicand> ::=
<value expression>
<overlaps predicate part 1> ::=
<row value predicand 1>
<row value predicand 1> ::=
<row value predicand>
<simple when clause> ::=
WHEN
<when operand>
THEN
<result>
<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>
| <normalized 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>
<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>
<equals operator> ::=
=
<not equals operator> ::=
<>
<less than operator> ::=
<
<greater than operator> ::=
>
<less than or equals operator> ::=
< =
<greater than or equals operator> ::=
> =
<between predicate part 2> ::=
[ NOT ] BETWEEN [ ASYMMETRIC | SYMMETRIC ] <row value predicand> AND <row value predicand>
<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> } ... ]
<row value expression> ::=
<row value special case>
| <explicit row value constructor>
<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 part 2> ::=
[ NOT ] LIKE <octet pattern> [ ESCAPE <escape octet> ]
<octet pattern> ::=
<blob value expression>
<blob value expression> ::=
<blob concatenation>
| <blob factor>
<blob concatenation> ::=
<blob value expression> <concatenation operator> <blob factor>
<blob factor> ::=
<blob primary>
<blob primary> ::=
<value expression primary>
| <string value function>
<string value function> ::=
<character 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>
<start position> ::=
<numeric value expression>
<string length> ::=
<numeric value expression>
<char length units> ::=
CHARACTERS
| OCTETS
CHARACTERS ::=
C H A R A C T E R S
OCTETS ::=
O C T E T S
<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>
<transcoding name> ::=
<schema qualified name>
<character transliteration> ::=
TRANSLATE
<left paren>
<character value expression>
USING
<transliteration name>
<right paren>
<transliteration name> ::=
<schema qualified name>
<trim function> ::=
TRIM
<left paren>
<trim operands>
<right paren>
<trim operands> ::=
[ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>
<trim specification> ::=
LEADING
| TRAILING
| BOTH
<trim character> ::=
<character value expression>
<trim source> ::=
<character value expression>
<character overlay function> ::=
OVERLAY <left paren> <character value expression> PLACING <character value expression> FROM <start position> [ FOR <string length> ] [ USING <char length units> ] <right paren>
PLACING ::=
P L A C I N G
<normalize function> ::=
NORMALIZE
<left paren>
<character value expression>
<right paren>
<specific type method> ::=
<user-defined type value expression> <period> SPECIFICTYPE [ <left paren> <right paren> ]
<escape octet> ::=
<blob value expression>
<similar predicate part 2> ::=
[ NOT ] SIMILAR TO <similar pattern> [ ESCAPE <escape character> ]
<similar pattern> ::=
<character value expression>
<null predicate part 2> ::=
IS [ NOT ] NULL
<quantified comparison predicate part 2> ::=
<comp op> <quantifier> <table subquery>
<quantifier> ::=
<all>
| <some>
<all> ::=
ALL
<some> ::=
SOME
| <ANY>
<normalized predicate part 2> ::=
IS [ NOT ] NORMALIZED
NORMALIZED ::=
N O R M A L I Z E D
<match predicate part 2> ::=
MATCH [ UNIQUE ] [ SIMPLE | PARTIAL | FULL ] <table subquery>
SIMPLE ::=
S I M P L E
PARTIAL ::=
P A R T I A L
<overlaps predicate part 2> ::=
OVERLAPS <row value predicand 2>
<row value predicand 2> ::=
<row value predicand>
<distinct predicate part 2> ::=
IS [ NOT ] DISTINCT FROM <row value predicand 4>
<row value predicand 4> ::=
<row value predicand>
<member predicate part 2> ::=
[ NOT ] MEMBER [ OF ] <multiset value expression>
<submultiset predicate part 2> ::=
[ NOT ] SUBMULTISET [ OF ] <multiset value expression>
<set predicate part 2> ::=
IS [ NOT ] A SET
<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>
<result> ::=
<result expression>
| NULL
<result expression> ::=
<value expression>
<else clause> ::=
ELSE <result>
<searched case> ::=
CASE <searched when clause> ... [ <else clause> ] END
<searched when clause> ::=
WHEN
<search condition>
THEN
<result>
<cast specification> ::=
CAST
<left paren>
<cast operand>
AS
<cast target>
<right paren>
<cast operand> ::=
<value expression>
| <implicitly typed value specification>
<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>
<left bracket or trigraph> ::=
<left bracket>
| <left bracket trigraph>
<left bracket> ::=
[
<left bracket trigraph> ::=
? ? (
<right bracket or trigraph> ::=
<right bracket>
| <right bracket trigraph>
<right bracket> ::=
[
<right bracket trigraph> ::=
? ? )
<cast target> ::=
<domain name>
| <data type>
<domain name> ::=
<schema qualified name>
<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 type>
<length> ::=
<unsigned integer> [ <char length units> ]
<character large object type> ::=
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> ]
OBJECT ::=
O B J E C T
<large object length> ::=
<unsigned integer> [ <multiplier> ] [ <char length units> ]
| <large object length token> [ <char length units> ]
<multiplier> ::=
K
| M
| G
<large object length token> ::=
<digit> ... <multiplier>
<national character string type> ::=
NATIONAL CHARACTER [ <left paren> <length> <right paren> ]
| NATIONAL CHAR [ <left paren> <length> <right paren> ]
| NCHAR [ <left paren> <length> <right paren> ]
| NATIONAL CHARACTER VARYING <left paren> <length> <right paren>
| NATIONAL CHAR VARYING <left paren> <length> <right paren>
| NCHAR VARYING <left paren> <length> <right paren>
| <national character large object type>
<national character large object type> ::=
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
<precision> ::=
<unsigned integer>
<scale> ::=
<unsigned integer>
<approximate numeric type> ::=
FLOAT [ <left paren> <precision> <right paren> ]
| REAL
| DOUBLE PRECISION
<boolean type> ::=
BOOLEAN
<datetime type> ::=
DATE
| TIME [ <left paren> <time precision> <right paren> ] [ <with or without time zone> ]
| TIMESTAMP [ <left paren> <timestamp precision> <right paren> ] [ <with or without time zone> ]
<with or without time zone> ::=
WITH TIME ZONE
| WITHOUT TIME ZONE
<interval type> ::=
INTERVAL <interval qualifier>
<row type> ::=
ROW <row type body>
<row type body> ::=
<left paren> <field definition> [ { <comma> <field definition> } ... ] <right paren>
<field definition> ::=
<field name> <data type>
<field name> ::=
<identifier>
<reference type> ::=
REF <left paren> <referenced type> <right paren> [ <scope clause> ]
<referenced type> ::=
<path-resolved user-defined type name>
<scope clause> ::=
SCOPE <table name>
<collection type> ::=
<array type>
| <multiset type>
<array type> ::=
<data type> ARRAY [ <left bracket or trigraph> <maximum cardinality> <right bracket or trigraph> ]
<maximum cardinality> ::=
<unsigned integer>
<multiset type> ::=
<data type> MULTISET
<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>
<static method invocation> ::=
<path-resolved user-defined type name> <double colon> <method name> [ <SQL argument list> ]
<double colon> ::=
: :
<method name> ::=
<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>
<target specification> ::=
<host parameter specification>
| <SQL parameter reference>
| <column reference>
| <target array element specification>
| <dynamic parameter specification>
| <embedded variable specification>
<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>
<simple value specification> ::=
<literal>
| <host parameter name>
| <SQL parameter reference>
| <embedded variable name>
<literal> ::=
<signed numeric literal>
| <general literal>
<signed numeric literal> ::=
[ <sign> ] <unsigned numeric literal>
<new specification> ::=
NEW <path-resolved user-defined type name> <SQL argument list>
<attribute or method reference> ::=
<value expression primary> <dereference operator> <qualified identifier> [ <SQL argument list> ]
<dereference operator> ::=
<right arrow>
<right arrow> ::=
- >
<reference resolution> ::=
DEREF
<left paren>
<reference value expression>
<right paren>
<collection value constructor> ::=
<array value constructor>
| <multiset value constructor>
<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>
<order by clause> ::=
ORDER BY <sort specification list>
<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>
<array element reference> ::=
<array value expression>
<left bracket or trigraph>
<numeric value expression>
<right bracket or trigraph>
<multiset element reference> ::=
ELEMENT
<left paren>
<multiset value expression>
<right paren>
<routine or method invocation> ::=
<direct invocation>
| <generalized invocation>
| <routine 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> ]
<routine invocation> ::=
<routine name> <SQL argument list>
<routine name> ::=
[ <schema name> <period> ] <qualified identifier>
<next value expression> ::=
NEXT
VALUE
FOR
<sequence generator name>
NEXT ::=
N E X T
<sequence generator name> ::=
<schema qualified name>
<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>
<extract expression> ::=
EXTRACT
<left paren>
<extract field>
FROM
<extract source>
<right paren>
<extract field> ::=
<primary datetime field>
| <time zone field>
<primary datetime field> ::=
<non-second primary datetime field>
| SECOND
<time zone field> ::=
TIMEZONE_HOUR
| TIMEZONE_MINUTE
<extract source> ::=
<datetime value expression>
| <interval value expression>
<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>
<cardinality expression> ::=
CARDINALITY
<left paren>
<collection value expression>
<right paren>
<absolute value expression> ::=
ABS
<left paren>
<numeric value expression>
<right paren>
<modulus expression> ::=
MOD
<left paren>
<numeric value expression dividend>
<comma>
<numeric value expression divisor>
<right paren>
<numeric value expression dividend> ::=
<numeric value expression>
<numeric value expression divisor> ::=
<numeric value expression>
<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>
<between predicate> ::=
<row value predicand> <between predicate part 2>
<in predicate> ::=
<numeric value expression> <in predicate part 2>
<like predicate> ::=
<character like predicate>
<character like predicate> ::=
<string value expression> <character like predicate part 2>
<similar predicate> ::=
<row value predicand> <similar predicate part 2>
<null predicate> ::=
<row value predicand> <null predicate part 2>
<quantified comparison predicate> ::=
<row value predicand> <quantified comparison predicate part 2>
<exists predicate> ::=
EXISTS <table subquery>
<unique predicate> ::=
UNIQUE <table subquery>
<normalized predicate> ::=
<row value predicand> <normalized predicate part 2>
<match predicate> ::=
<row value predicand> <match predicate part 2>
<overlaps predicate> ::=
<overlaps predicate part 1> <overlaps predicate part 2>
<distinct predicate> ::=
<row value predicand 3> <distinct predicate part 2>
<row value predicand 3> ::=
<row value predicand>
<member predicate> ::=
<row value predicand> <member predicate part 2>
<submultiset predicate> ::=
<row value predicand> <submultiset predicate part 2>
<set predicate> ::=
<row value predicand> <set predicate part 2>
<type predicate> ::=
<row value predicand> <type predicate part 2>
<boolean predicand> ::=
<numeric value expression>
<truth value> ::=
TRUE
| FALSE
| UNKNOWN
<direct select statement: multiple rows> ::=
<cursor specification>
<cursor specification> ::=
<query expression> [ <order by clause> ] [ <updatability clause> ]
<updatability clause> ::=
FOR { READ ONLY | UPDATE [ OF <column name list> ] }
READ ::=
R E A D
<insert statement> ::=
INSERT
INTO
<insertion target>
<insert columns and source>
<insertion target> ::=
<table name>
<insert columns and source> ::=
<from subquery>
| <from default>
<from subquery> ::=
[ <left paren> <insert column list> <right paren> ] [ <override clause> ] <query expression>
<insert column list> ::=
<column name list>
<override clause> ::=
OVERRIDING USER VALUE
| OVERRIDING SYSTEM VALUE
OVERRIDING ::=
O V E R R I D I N G
<from default> ::=
DEFAULT VALUES
<update statement: searched> ::=
UPDATE <target table> [ [ AS ] <correlation name> ] SET <set clause list> [ WHERE <search condition> ]
<set clause list> ::=
<set clause> [ { <comma> <set clause> } ... ]
<set clause> ::=
<multiple column assignment>
| <set target> <equals operator> <update source>
<multiple column assignment> ::=
<set target list> <equals operator> <assigned row>
<set target list> ::=
<left paren> <set target> [ { <comma> <set target> } ... ] <right paren>
<set target> ::=
<update target>
| <mutated set clause>
<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>
<assigned row> ::=
<contextually typed row value expression>
<contextually typed row value expression> ::=
<row value special case>
| <contextually typed row value constructor>
<contextually typed row value constructor> ::=
<common value expression>
| <boolean value expression>
| <contextually typed value specification>
| <left paren> <contextually typed row value specification> <right paren>
| <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 value specification> ::=
<implicitly typed value specification>
| <default specification>
<default specification> ::=
DEFAULT
<contextually typed row value constructor element> ::=
<value expression>
| <contextually typed value specification>
<contextually typed row value constructor element list> ::=
<contextually typed row value constructor element> [ { <comma> <contextually typed row value constructor element> } ... ]
<update source> ::=
<value expression>
| <contextually typed value specification>
<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>
MATCHED ::=
M A T C H E D
<merge update specification> ::=
UPDATE SET <set clause list>
<merge when not matched clause> ::=
WHEN
NOT
MATCHED
THEN
<merge insert specification>
<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>
<temporary table declaration> ::=
DECLARE LOCAL TEMPORARY TABLE <table name> <table element list> [ ON COMMIT <table commit action> ROWS ]
TEMPORARY ::=
T E M P O R A R Y
<table element list> ::=
<left paren> <table element> [ { <comma> <table element> } ... ] <right paren>
<table element> ::=
<column definition>
| <table constraint definition>
| <like clause>
<column definition> ::=
<column name> [ <data type or domain name> ] [ <default clause> | <identity column specification> | <generation clause> ] [ <column constraint definition> ... ] [ <collate clause> ]
<data type or domain name> ::=
<data type>
| <domain name>
<default clause> ::=
DEFAULT <default option>
<default option> ::=
<literal>
| <datetime value function>
| USER
| CURRENT_USER
| CURRENT_ROLE
| SESSION_USER
| SYSTEM_USER
| CURRENT_PATH
| <implicitly typed value specification>
<identity column specification> ::=
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ <left paren> <common sequence generator options> <right paren> ]
GENERATED ::=
G E N E R A T E D
ALWAYS ::=
A L W A Y S
<common sequence generator options> ::=
<common sequence generator option> ...
<common sequence generator option> ::=
<sequence generator start with option>
| <basic sequence generator option>
<sequence generator start with option> ::=
START WITH <sequence generator start value>
<sequence generator start value> ::=
<signed numeric literal>
<basic sequence generator option> ::=
<sequence generator increment by option>
| <sequence generator maxvalue option>
| <sequence generator minvalue option>
| <sequence generator cycle option>
<sequence generator increment by option> ::=
INCREMENT BY <sequence generator increment>
INCREMENT ::=
I N C R E M E N T
<sequence generator increment> ::=
<signed numeric literal>
<sequence generator maxvalue option> ::=
MAXVALUE <sequence generator max value>
| NO MAXVALUE
MAXVALUE ::=
M A X V A L U E
<sequence generator max value> ::=
<signed numeric literal>
<sequence generator minvalue option> ::=
MINVALUE <sequence generator min value>
| NO MINVALUE
MINVALUE ::=
M I N V A L U E
<sequence generator min value> ::=
<signed numeric literal>
<sequence generator cycle option> ::=
CYCLE
| NO CYCLE
<generation clause> ::=
<generation rule> AS <generation expression>
<generation rule> ::=
GENERATED ALWAYS
<generation expression> ::=
<left paren> <value expression> <right paren>
<column constraint definition> ::=
[ <constraint name definition> ] <column constraint> [ <constraint characteristics> ]
<constraint name definition> ::=
CONSTRAINT <constraint name>
<constraint name> ::=
<schema qualified name>
<column constraint> ::=
NOT NULL
| <unique specification>
| <references specification>
| <check constraint definition>
<unique specification> ::=
UNIQUE
| PRIMARY KEY
KEY ::=
K E Y
<references specification> ::=
REFERENCES <referenced table and columns> [ MATCH <match type> ] [ <referential triggered action> ]
<referenced table and columns> ::=
<table name> [ <left paren> <reference column list> <right paren> ]
<reference column list> ::=
<column name list>
<match type> ::=
FULL
| PARTIAL
| SIMPLE
<referential triggered action> ::=
<update rule> [ <delete rule> ]
| <delete rule> [ <update rule> ]
<update rule> ::=
ON UPDATE <referential action>
<referential action> ::=
CASCADE
| SET NULL
| SET DEFAULT
| RESTRICT
| NO ACTION
CASCADE ::=
C A S C A D E
RESTRICT ::=
R E S T R I C T
ACTION ::=
A C T I O N
<delete rule> ::=
ON DELETE <referential action>
<check constraint definition> ::=
CHECK
<left paren>
<search condition>
<right paren>
<constraint characteristics> ::=
<constraint check time> [ [ NOT ] DEFERRABLE ]
| [ NOT ] DEFERRABLE [ <constraint check time> ]
<constraint check time> ::=
INITIALLY DEFERRED
| INITIALLY IMMEDIATE
INITIALLY ::=
I N I T I A L L Y
DEFERRED ::=
D E F E R R E D
IMMEDIATE ::=
I M M E D I A T E
DEFERRABLE ::=
D E F E R R A B L E
<table constraint definition> ::=
[ <constraint name definition> ] <table constraint> [ <constraint characteristics> ]
<table constraint> ::=
<unique constraint definition>
| <referential constraint definition>
| <check constraint definition>
<unique constraint definition> ::=
<unique specification> <left paren> <unique column list> <right paren>
| UNIQUE ( VALUE )
<unique column list> ::=
<column name list>
<referential constraint definition> ::=
FOREIGN
KEY
<left paren>
<referencing columns>
<right paren>
<references specification>
<referencing columns> ::=
<reference column list>
<like clause> ::=
LIKE <table name> [ <like options> ]
<like options> ::=
<like option> ...
<like option> ::=
<identity option>
| <column default option>
| <generation option>
<identity option> ::=
INCLUDING IDENTITY
| EXCLUDING IDENTITY
INCLUDING ::=
I N C L U D I N G
EXCLUDING ::=
E X C L U D I N G
<column default option> ::=
INCLUDING DEFAULTS
| EXCLUDING DEFAULTS
DEFAULTS ::=
D E F A U L T S
<generation option> ::=
INCLUDING GENERATED
| EXCLUDING GENERATED
<table commit action> ::=
PRESERVE
| DELETE
PRESERVE ::=
P R E S E R V E
<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>
<schema definition> ::=
CREATE SCHEMA <schema name clause> [ <schema character set or path> ] [ <schema element> ... ]
SCHEMA ::=
S C H E M A
<schema name clause> ::=
<schema name>
| AUTHORIZATION <schema authorization identifier>
| <schema name> AUTHORIZATION <schema authorization identifier>
<schema authorization identifier> ::=
<authorization identifier>
<authorization identifier> ::=
<role name>
| <user identifier>
<role name> ::=
<identifier>
<user identifier> ::=
<identifier>
<schema character set or path> ::=
<schema character set specification>
| <schema path specification>
| <schema character set specification> <schema path specification>
| <schema path specification> <schema character set specification>
<schema character set specification> ::=
DEFAULT CHARACTER SET <character set specification>
<schema path specification> ::=
<path specification>
<path specification> ::=
PATH <schema name list>
PATH ::=
P A T H
<schema name list> ::=
<schema name> [ { <comma> <schema name> } ... ]
<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>
<table definition> ::=
CREATE [ <table scope> ] TABLE <table name> <table contents source> [ ON COMMIT <table commit action> ROWS ]
<table scope> ::=
<global or local> TEMPORARY
<global or local> ::=
GLOBAL
| LOCAL
<table contents source> ::=
<table element list>
| <typed table clause>
| <as subquery clause>
<typed table clause> ::=
OF <path-resolved user-defined type name> [ <subtable clause> ] [ <typed table element list> ]
<subtable clause> ::=
UNDER <supertable clause>
UNDER ::=
U N D E R
<supertable clause> ::=
<supertable name>
<supertable name> ::=
<table name>
<typed table element list> ::=
<left paren> <typed table element> [ { <comma> <typed table element> } ... ] <right paren>
<typed table element> ::=
<column options>
| <table constraint definition>
| <self-referencing column specification>
<column options> ::=
<column name>
WITH
OPTIONS
<column option list>
OPTIONS ::=
O P T I O N S
<column option list> ::=
[ <scope clause> ] [ <default clause> ] [ <column constraint definition> ... ]
<self-referencing column specification> ::=
REF IS <self-referencing column name> [ <reference generation> ]
<self-referencing column name> ::=
<column name>
<reference generation> ::=
SYSTEM GENERATED
| USER GENERATED
| DERIVED
DERIVED ::=
D E R I V E D
<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
DATA ::=
D A T A
<view definition> ::=
CREATE [ RECURSIVE ] VIEW <table name> <view specification> AS <query expression> [ WITH [ <levels clause> ] CHECK OPTION ]
VIEW ::=
V I E W
<view specification> ::=
<regular view specification>
| <referenceable view specification>
<regular view specification> ::=
[ <left paren> <view column list> <right paren> ]
<view column list> ::=
<column name list>
<referenceable view specification> ::=
OF <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
OPTION ::=
O P T I O N
<domain definition> ::=
CREATE DOMAIN <domain name> [ AS ] <predefined type> [ <default clause> ] [ <domain constraint> ... ] [ <collate clause> ]
DOMAIN ::=
D O M A I N
<domain constraint> ::=
[ <constraint name definition> ] <check constraint definition> [ <constraint characteristics> ]
<character set definition> ::=
CREATE CHARACTER SET <character set name> [ AS ] <character set source> [ <collate clause> ]
<character set name> ::=
[ <schema name> <period> ] <SQL language identifier>
<SQL language identifier> ::=
<SQL language identifier start> [ <SQL language identifier part> ... ]
<SQL language identifier start> ::=
<simple Latin letter>
<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
<SQL language identifier part> ::=
<simple Latin letter>
| <digit>
| <underscore>
<character set source> ::=
GET <character set specification>
<collation definition> ::=
CREATE COLLATION <collation name> FOR <character set specification> FROM <existing collation name> [ <pad characteristic> ]
<existing collation name> ::=
<collation name>
<pad characteristic> ::=
NO PAD
| PAD SPACE
PAD ::=
P A D
SPACE ::=
S P A C E
<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>
<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
ROUTINE ::=
R O U T I N E
INSTANCE ::=
I N S T A N C E
CONSTRUCTOR ::=
C O N S T R U C T O R
<specific name> ::=
<schema qualified name>
<member name> ::=
<member name alternatives> [ <data type list> ]
<member name alternatives> ::=
<schema qualified routine name>
| <method name>
<schema qualified routine name> ::=
<schema qualified name>
<data type list> ::=
<left paren> [ <data type> [ { <comma> <data type> } ... ] ] <right paren>
<schema-resolved user-defined type name> ::=
<user-defined type name>
<assertion definition> ::=
CREATE ASSERTION <constraint name> CHECK <left paren> <search condition> <right paren> [ <constraint characteristics> ]
ASSERTION ::=
A S S E R T I O N
<trigger definition> ::=
CREATE TRIGGER <trigger name> <trigger action time> <trigger event> ON <table name> [ REFERENCING <transition table or variable list> ] <triggered action>
<trigger name> ::=
<schema qualified name>
<trigger action time> ::=
BEFORE
| AFTER
BEFORE ::=
B E F O R E
AFTER ::=
A F T E R
<trigger event> ::=
INSERT
| DELETE
| UPDATE [ OF <trigger column list> ]
<trigger column list> ::=
<column name list>
<transition table or variable list> ::=
<transition table or variable> ...
<transition table or variable> ::=
OLD [ ROW ] [ AS ] <old transition variable name>
| NEW [ ROW ] [ AS ] <new transition variable name>
| OLD TABLE [ AS ] <old transition table name>
| NEW TABLE [ AS ] <new transition table name>
<old transition variable name> ::=
<correlation name>
<new transition variable name> ::=
<correlation name>
<old transition table name> ::=
<transition table name>
<transition table name> ::=
<identifier>
<new transition table name> ::=
<transition table name>
<triggered action> ::=
[ FOR EACH { ROW | STATEMENT } ] [ WHEN <left paren> <search condition> <right paren> ] <triggered SQL statement>
STATEMENT ::=
S T A T E M E N T
<triggered SQL statement> ::=
<SQL procedure statement>
| BEGIN ATOMIC { <SQL procedure statement> <semicolon> } ... END
<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 data statement> ::=
<open statement>
| <fetch statement>
| <close statement>
| <select statement: single row>
| <free locator statement>
| <hold locator statement>
| <SQL data change statement>
<open statement> ::=
OPEN <cursor name>
<cursor name> ::=
<local qualified name>
<local qualified name> ::=
[ <local qualifier> <period> ] <qualified identifier>
<fetch statement> ::=
FETCH [ [ <fetch orientation> ] FROM ] <cursor name> INTO <fetch target list>
<fetch orientation> ::=
NEXT
| PRIOR
| FIRST
| LAST
| { ABSOLUTE | RELATIVE } <simple value specification>
PRIOR ::=
P R I O R
ABSOLUTE ::=
A B S O L U T E
RELATIVE ::=
R E L A T I V E
<fetch target list> ::=
<target specification> [ { <comma> <target specification> } ... ]
<close statement> ::=
CLOSE <cursor name>
<select statement: single row> ::=
SELECT [ <set quantifier> ] <select list> INTO <select target list> <table expression>
<select target list> ::=
<target specification> [ { <comma> <target specification> } ... ]
<free locator statement> ::=
FREE LOCATOR <locator reference> [ { <comma> <locator reference> } ... ]
LOCATOR ::=
L O C A T O R
<locator reference> ::=
<host parameter name>
| <embedded variable name>
| <dynamic parameter specification>
<hold locator statement> ::=
HOLD LOCATOR <locator reference> [ { <comma> <locator reference> } ... ]
<SQL data change statement> ::=
<delete statement: positioned>
| <delete statement: searched>
| <insert statement>
| <update statement: positioned>
| <update statement: searched>
| <merge statement>
<delete statement: positioned> ::=
DELETE FROM <target table> [ [ AS ] <correlation name> ] WHERE CURRENT OF <cursor name>
<update statement: positioned> ::=
UPDATE <target table> [ [ AS ] <correlation name> ] SET <set clause list> WHERE CURRENT OF <cursor name>
<SQL control statement> ::=
<call statement>
| <return statement>
<call statement> ::=
CALL <routine invocation>
<return statement> ::=
RETURN <return value>
<return value> ::=
<value expression>
| NULL
<SQL transaction statement> ::=
<start transaction statement>
| <set transaction statement>
| <set constraints mode statement>
| <savepoint statement>
| <release savepoint statement>
| <commit statement>
| <rollback statement>
<start transaction statement> ::=
START TRANSACTION [ <transaction mode> [ { <comma> <transaction mode> } ... ] ]
TRANSACTION ::=
T R A N S A C T I O N
<transaction mode> ::=
<isolation level>
| <transaction access mode>
| <diagnostics size>
<isolation level> ::=
ISOLATION LEVEL <level of isolation>
ISOLATION ::=
I S O L A T I O N
LEVEL ::=
L E V E L
<level of isolation> ::=
READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
| SERIALIZABLE
UNCOMMITTED ::=
U N C O M M I T T E D
COMMITTED ::=
C O M M I T T E D
SERIALIZABLE ::=
S E R I A L I Z A B L E
<transaction access mode> ::=
READ ONLY
| READ WRITE
WRITE ::=
W R I T E
<diagnostics size> ::=
DIAGNOSTICS SIZE <number of conditions>
DIAGNOSTICS ::=
D I A G N O S T I C S
SIZE ::=
S I Z E
<number of conditions> ::=
<simple value specification>
<set transaction statement> ::=
SET [ LOCAL ] <transaction characteristics>
<transaction characteristics> ::=
TRANSACTION <transaction mode> [ { <comma> <transaction mode> } ... ]
<set constraints mode statement> ::=
SET CONSTRAINTS <constraint name list> { DEFERRED | IMMEDIATE }
CONSTRAINTS ::=
C O N S T R A I N T S
<constraint name list> ::=
ALL
| <constraint name> [ { <comma> <constraint name> } ... ]
<savepoint statement> ::=
SAVEPOINT <savepoint specifier>
<savepoint specifier> ::=
<savepoint name>
<savepoint name> ::=
<identifier>
<release savepoint statement> ::=
RELEASE SAVEPOINT <savepoint specifier>
<commit statement> ::=
COMMIT [ WORK ] [ AND [ NO ] CHAIN ]
WORK ::=
W O R K
CHAIN ::=
C H A I N
<rollback statement> ::=
ROLLBACK [ WORK ] [ AND [ NO ] CHAIN ] [ <savepoint clause> ]
<savepoint clause> ::=
TO SAVEPOINT <savepoint specifier>
<SQL connection statement> ::=
<connect statement>
| <set connection statement>
| <disconnect statement>
<connect statement> ::=
CONNECT TO <connection target>
<connection target> ::=
<SQL-server name> [ AS <connection name> ] [ USER <connection user name> ]
| DEFAULT
<SQL-server name> ::=
<simple value specification>
<connection name> ::=
<simple value specification>
<connection user name> ::=
<simple value specification>
<set connection statement> ::=
SET CONNECTION <connection object>
CONNECTION ::=
C O N N E C T I O N
<connection object> ::=
DEFAULT
| <connection name>
<disconnect statement> ::=
DISCONNECT <disconnect object>
<disconnect object> ::=
<connection object>
| ALL
| CURRENT
<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>
<set session user identifier statement> ::=
SET
SESSION
AUTHORIZATION
<value specification>
SESSION ::=
S E S S I O N
<value specification> ::=
<literal>
| <general value specification>
<set role statement> ::=
SET ROLE <role specification>
ROLE ::=
R O L E
<role specification> ::=
<value specification>
| <NONE>
<set local time zone statement> ::=
SET
TIME
ZONE
<set time zone value>
<set time zone value> ::=
<interval value expression>
| LOCAL
<set session characteristics statement> ::=
SET
SESSION
CHARACTERISTICS
AS
<session characteristic list>
CHARACTERISTICS ::=
C H A R A C T E R I S T I C S
<session characteristic list> ::=
<session characteristic> [ { <comma> <session characteristic> } ... ]
<session characteristic> ::=
<transaction characteristics>
<set catalog statement> ::=
SET <catalog name characteristic>
<catalog name characteristic> ::=
CATALOG <value specification>
CATALOG ::=
C A T A L O G
<set schema statement> ::=
SET <schema name characteristic>
<schema name characteristic> ::=
SCHEMA <value specification>
<set names statement> ::=
SET <character set name characteristic>
<character set name characteristic> ::=
NAMES <value specification>
NAMES ::=
N A M E S
<set path statement> ::=
SET <SQL-path characteristic>
<SQL-path characteristic> ::=
PATH <value specification>
<set session collation statement> ::=
SET COLLATION <collation specification> [ FOR <character set specification list> ]
| SET NO COLLATION [ FOR <character set specification list> ]
<collation specification> ::=
<value specification>
<character set specification list> ::=
<character set specification> [ { <comma> <character set specification> } ... ]
<SQL diagnostics statement> ::=
<get diagnostics statement>
<get diagnostics statement> ::=
GET DIAGNOSTICS <SQL diagnostics information>
<SQL diagnostics information> ::=
<statement information>
| <condition information>
<statement information> ::=
<statement information item> [ { <comma> <statement information item> } ... ]
<statement information item> ::=
<simple target specification> <equals operator> <statement information item name>
<simple target specification> ::=
<host parameter specification>
| <SQL parameter reference>
| <column reference>
| <embedded variable 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
NUMBER ::=
N U M B E R
MORE ::=
M O R E
COMMAND_FUNCTION ::=
C O M M A N D _ F U N C T I O N
COMMAND_FUNCTION_CODE ::=
C O M M A N D _ F U N C T I O N _ C O D E
DYNAMIC_FUNCTION ::=
D Y N A M I C _ F U N C T I O N
DYNAMIC_FUNCTION_CODE ::=
D Y N A M I C _ F U N C T I O N _ C O D E
ROW_COUNT ::=
R O W _ C O U N T
TRANSACTIONS_COMMITTED ::=
T R A N S A C T I O N S _ C O M M I T T E D
TRANSACTIONS_ROLLED_BACK ::=
T R A N S A C T I O N S _ R O L L E D _ B A C K
TRANSACTION_ACTIVE ::=
T R A N S A C T I O N _ A C T I V E
<condition information> ::=
{ EXCEPTION | CONDITION } <condition number> <condition information item> [ { <comma> <condition information item> } ... ]
EXCEPTION ::=
E X C E P T I O N
<condition number> ::=
<simple value specification>
<condition information item> ::=
<simple target specification> <equals operator> <condition information item name>
<condition information item name> ::=
CATALOG_NAME
| CLASS_ORIGIN
| COLUMN_NAME
| CONDITION_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
CATALOG_NAME ::=
C A T A L O G _ N A M E
CLASS_ORIGIN ::=
C L A S S _ O R I G I N
COLUMN_NAME ::=
C O L U M N _ N A M E
CONDITION_NUMBER ::=
C O N D I T I O N _ N U M B E R
CONNECTION_NAME ::=
C O N N E C T I O N _ N A M E
CONSTRAINT_CATALOG ::=
C O N S T R A I N T _ C A T A L O G
CONSTRAINT_NAME ::=
C O N S T R A I N T _ N A M E
CONSTRAINT_SCHEMA ::=
C O N S T R A I N T _ S C H E M A
CURSOR_NAME ::=
C U R S O R _ N A M E
MESSAGE_LENGTH ::=
M E S S A G E _ L E N G T H
MESSAGE_OCTET_LENGTH ::=
M E S S A G E _ O C T E T _ L E N G T H
MESSAGE_TEXT ::=
M E S S A G E _ T E X T
PARAMETER_MODE ::=
P A R A M E T E R _ M O D E
PARAMETER_NAME ::=
P A R A M E T E R _ N A M E
PARAMETER_ORDINAL_POSITION ::=
P A R A M E T E R _ O R D I N A L _ P O S I T I O N
RETURNED_SQLSTATE ::=
R E T U R N E D _ S Q L S T A T E
ROUTINE_CATALOG ::=
R O U T I N E _ C A T A L O G
ROUTINE_NAME ::=
R O U T I N E _ N A M E
ROUTINE_SCHEMA ::=
R O U T I N E _ S C H E M A
SCHEMA_NAME ::=
S C H E M A _ N A M E
SERVER_NAME ::=
S E R V E R _ N A M E
SPECIFIC_NAME ::=
S P E C I F I C _ N A M E
SUBCLASS_ORIGIN ::=
S U B C L A S S _ O R I G I N
TABLE_NAME ::=
T A B L E _ N A M E
TRIGGER_CATALOG ::=
T R I G G E R _ C A T A L O G
TRIGGER_NAME ::=
T R I G G E R _ N A M E
TRIGGER_SCHEMA ::=
T R I G G E R _ S C H E M A
<SQL dynamic statement> ::=
<SQL descriptor statement>
| <prepare statement>
| <deallocate prepared statement>
| <describe statement>
| <execute statement>
| <execute immediate statement>
| <SQL dynamic data statement>
<SQL descriptor statement> ::=
<allocate descriptor statement>
| <deallocate descriptor statement>
| <set descriptor statement>
| <get descriptor statement>
<allocate descriptor statement> ::=
ALLOCATE [ SQL ] DESCRIPTOR <descriptor name> [ WITH MAX <occurrences> ]
DESCRIPTOR ::=
D E S C R I P T O R
<descriptor name> ::=
[ <scope option> ] <simple value specification>
<scope option> ::=
GLOBAL
| LOCAL
<occurrences> ::=
<simple value specification>
<deallocate descriptor statement> ::=
DEALLOCATE [ SQL ] DESCRIPTOR <descriptor name>
<set descriptor statement> ::=
SET [ SQL ] DESCRIPTOR <descriptor name> <set descriptor information>
<set descriptor information> ::=
<set header information> [ { <comma> <set header information> } ... ]
| VALUE <item number> <set item information> [ { <comma> <set item information> } ... ]
<set header information> ::=
<header item name> <equals operator> <simple value specification 1>
<header item name> ::=
COUNT
| KEY_TYPE
| DYNAMIC_FUNCTION
| DYNAMIC_FUNCTION_CODE
| TOP_LEVEL_COUNT
KEY_TYPE ::=
K E Y _ T Y P E
TOP_LEVEL_COUNT ::=
T O P _ L E V E L _ C O U N T
<simple value specification 1> ::=
<simple value specification>
<item number> ::=
<simple value specification>
<set item information> ::=
<descriptor item name> <equals operator> <simple value specification 2>
<descriptor item name> ::=
CARDINALITY
| CHARACTER_SET_CATALOG
| CHARACTER_SET_NAME
| CHARACTER_SET_SCHEMA
| COLLATION_CATALOG
| COLLATION_NAME
| COLLATION_SCHEMA
| DATA
| DATETIME_INTERVAL_CODE
| DATETIME_INTERVAL_PRECISION
| DEGREE
| INDICATOR
| KEY_MEMBER
| LENGTH
| LEVEL
| NAME
| NULLABLE
| OCTET_LENGTH
| PARAMETER_MODE
| PARAMETER_ORDINAL_POSITION
| PARAMETER_SPECIFIC_CATALOG
| PARAMETER_SPECIFIC_NAME
| PARAMETER_SPECIFIC_SCHEMA
| PRECISION
| RETURNED_CARDINALITY
| RETURNED_LENGTH
| RETURNED_OCTET_LENGTH
| SCALE
| SCOPE_CATALOG
| SCOPE_NAME
| SCOPE_SCHEMA
| TYPE
| UNNAMED
| USER_DEFINED_TYPE_CATALOG
| USER_DEFINED_TYPE_NAME
| USER_DEFINED_TYPE_SCHEMA
| USER_DEFINED_TYPE_CODE
CHARACTER_SET_CATALOG ::=
C H A R A C T E R _ S E T _ C A T A L O G
CHARACTER_SET_NAME ::=
C H A R A C T E R _ S E T _ N A M E
CHARACTER_SET_SCHEMA ::=
C H A R A C T E R _ S E T _ S C H E M A
COLLATION_CATALOG ::=
C O L L A T I O N _ C A T A L O G
COLLATION_NAME ::=
C O L L A T I O N _ N A M E
COLLATION_SCHEMA ::=
C O L L A T I O N _ S C H E M A
DATETIME_INTERVAL_CODE ::=
D A T E T I M E _ I N T E R V A L _ C O D E
DATETIME_INTERVAL_PRECISION ::=
D A T E T I M E _ I N T E R V A L _ P R E C I S I O N
DEGREE ::=
D E G R E E
KEY_MEMBER ::=
K E Y _ M E M B E R
LENGTH ::=
L E N G T H
NAME ::=
N A M E
NULLABLE ::=
N U L L A B L E
PARAMETER_SPECIFIC_CATALOG ::=
P A R A M E T E R _ S P E C I F I C _ C A T A L O G
PARAMETER_SPECIFIC_NAME ::=
P A R A M E T E R _ S P E C I F I C _ N A M E
PARAMETER_SPECIFIC_SCHEMA ::=
P A R A M E T E R _ S P E C I F I C _ S C H E M A
RETURNED_CARDINALITY ::=
R E T U R N E D _ C A R D I N A L I T Y
RETURNED_LENGTH ::=
R E T U R N E D _ L E N G T H
RETURNED_OCTET_LENGTH ::=
R E T U R N E D _ O C T E T _ L E N G T H
SCALE ::=
S C A L E
SCOPE_CATALOG ::=
S C O P E _ C A T A L O G
SCOPE_NAME ::=
S C O P E _ N A M E
SCOPE_SCHEMA ::=
S C O P E _ S C H E M A
TYPE ::=
T Y P E
UNNAMED ::=
U N N A M E D
USER_DEFINED_TYPE_CATALOG ::=
U S E R _ D E F I N E D _ T Y P E _ C A T A L O G
USER_DEFINED_TYPE_NAME ::=
U S E R _ D E F I N E D _ T Y P E _ N A M E
USER_DEFINED_TYPE_SCHEMA ::=
U S E R _ D E F I N E D _ T Y P E _ S C H E M A
USER_DEFINED_TYPE_CODE ::=
U S E R _ D E F I N E D _ T Y P E _ C O D E
<simple value specification 2> ::=
<simple value specification>
<get descriptor statement> ::=
GET [ SQL ] DESCRIPTOR <descriptor name> <get descriptor information>
<get descriptor information> ::=
<get header information> [ { <comma> <get header information> } ... ]
| VALUE <item number> <get item information> [ { <comma> <get item information> } ... ]
<get header information> ::=
<simple target specification 1> <equals operator> <header item name>
<simple target specification 1> ::=
<simple target specification>
<get item information> ::=
<simple target specification 2> <equals operator> <descriptor item name>
<simple target specification 2> ::=
<simple target specification>
<prepare statement> ::=
PREPARE <SQL statement name> [ <attributes specification> ] FROM <SQL statement variable>
<SQL statement name> ::=
<statement name>
| <extended statement name>
<statement name> ::=
<identifier>
<extended statement name> ::=
[ <scope option> ] <simple value specification>
<attributes specification> ::=
ATTRIBUTES <attributes variable>
ATTRIBUTES ::=
A T T R I B U T E S
<attributes variable> ::=
<simple value specification>
<SQL statement variable> ::=
<simple value specification>
<deallocate prepared statement> ::=
DEALLOCATE PREPARE <SQL statement name>
<describe statement> ::=
<describe input statement>
| <describe output statement>
<describe input statement> ::=
DESCRIBE INPUT <SQL statement name> <using descriptor> [ <nesting option> ]
INPUT ::=
I N P U T
<using descriptor> ::=
USING [ SQL ] DESCRIPTOR <descriptor name>
<nesting option> ::=
WITH NESTING
| WITHOUT NESTING
NESTING ::=
N E S T I N G
<describe output statement> ::=
DESCRIBE [ OUTPUT ] <described object> <using descriptor> [ <nesting option> ]
OUTPUT ::=
O U T P U T
<described object> ::=
<SQL statement name>
| CURSOR <extended cursor name> STRUCTURE
<extended cursor name> ::=
[ <scope option> ] <simple value specification>
STRUCTURE ::=
S T R U C T U R E
<execute statement> ::=
EXECUTE <SQL statement name> [ <result using clause> ] [ <parameter using clause> ]
<result using clause> ::=
<output using clause>
<output using clause> ::=
<into arguments>
| <into descriptor>
<into arguments> ::=
INTO <into argument> [ { <comma> <into argument> } ... ]
<into argument> ::=
<target specification>
<into descriptor> ::=
INTO [ SQL ] DESCRIPTOR <descriptor name>
<parameter using clause> ::=
<input using clause>
<input using clause> ::=
<using arguments>
| <using input descriptor>
<using arguments> ::=
USING <using argument> [ { <comma> <using argument> } ... ]
<using argument> ::=
<general value specification>
<using input descriptor> ::=
<using descriptor>
<execute immediate statement> ::=
EXECUTE IMMEDIATE <SQL statement variable>
<SQL dynamic data statement> ::=
<allocate cursor statement>
| <dynamic open statement>
| <dynamic fetch statement>
| <dynamic close statement>
| <dynamic delete statement: positioned>
| <dynamic update statement: positioned>
<allocate cursor statement> ::=
ALLOCATE <extended cursor name> <cursor intent>
<cursor intent> ::=
<statement cursor>
| <result set cursor>
<statement cursor> ::=
[ <cursor sensitivity> ] [ <cursor scrollability> ] CURSOR [ <cursor holdability> ] [ <cursor returnability> ] FOR <extended statement name>
<cursor sensitivity> ::=
SENSITIVE
| INSENSITIVE
| ASENSITIVE
<cursor scrollability> ::=
SCROLL
| NO SCROLL
<cursor holdability> ::=
WITH HOLD
| WITHOUT HOLD
<cursor returnability> ::=
WITH RETURN
| WITHOUT RETURN
<result set cursor> ::=
FOR PROCEDURE <specific routine designator>
<dynamic open statement> ::=
OPEN <dynamic cursor name> [ <input using clause> ]
<dynamic cursor name> ::=
<cursor name>
| <extended cursor name>
<dynamic fetch statement> ::=
FETCH [ [ <fetch orientation> ] FROM ] <dynamic cursor name> <output using clause>
<dynamic close statement> ::=
CLOSE <dynamic cursor name>
<dynamic delete statement: positioned> ::=
DELETE
FROM
<target table>
WHERE
CURRENT
OF
<dynamic cursor name>
<dynamic update statement: positioned> ::=
UPDATE
<target table>
SET
<set clause list>
WHERE
CURRENT
OF
<dynamic cursor name>
<semicolon> ::=
;
<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> ]
<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>
<attribute definition> ::=
<attribute name> <data type> [ <attribute default> ] [ <collate clause> ]
<attribute name> ::=
<identifier>
<attribute default> ::=
<default clause>
<user-defined type option list> ::=
<user-defined type option> [ <user-defined type option> ... ]
<user-defined type option> ::=
<instantiable clause>
| <finality>
| <reference type specification>
| <cast to ref>
| <cast to type>
| <cast to distinct>
| <cast to source>
<instantiable clause> ::=
INSTANTIABLE
| NOT INSTANTIABLE
INSTANTIABLE ::=
I N S T A N T I A B L E
<finality> ::=
FINAL
| NOT FINAL
FINAL ::=
F I N A L
<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>
<list of attributes> ::=
<left paren> <attribute name> [ { <comma> <attribute name> } ... ] <right paren>
<system-generated representation> ::=
REF
IS
SYSTEM
GENERATED
<cast to ref> ::=
CAST
<left paren>
SOURCE
AS
REF
<right paren>
WITH
<cast to ref identifier>
SOURCE ::=
S O U R C E
<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>
<cast to distinct> ::=
CAST
<left paren>
SOURCE
AS
DISTINCT
<right paren>
WITH
<cast to distinct identifier>
<cast to distinct identifier> ::=
<identifier>
<cast to source> ::=
CAST
<left paren>
DISTINCT
AS
SOURCE
<right paren>
WITH
<cast to source identifier>
<cast to source identifier> ::=
<identifier>
<method specification list> ::=
<method specification> [ { <comma> <method specification> } ... ]
<method specification> ::=
<original method specification>
| <overriding method specification>
<original method specification> ::=
<partial method specification> [ SELF AS RESULT ] [ SELF AS LOCATOR ] [ <method characteristics> ]
<partial method specification> ::=
[ INSTANCE | STATIC | CONSTRUCTOR ] METHOD <method name> <SQL parameter declaration list> <returns clause> [ SPECIFIC <specific method name> ]
<SQL parameter declaration list> ::=
<left paren> [ <SQL parameter declaration> [ { <comma> <SQL parameter declaration> } ... ] ] <right paren>
<SQL parameter declaration> ::=
[ <parameter mode> ] [ <SQL parameter name> ] <parameter type> [ RESULT ]
<parameter mode> ::=
IN
| OUT
| INOUT
<SQL parameter name> ::=
<identifier>
<parameter type> ::=
<data type> [ <locator indication> ]
<locator indication> ::=
AS LOCATOR
<returns clause> ::=
RETURNS <returns type>
<returns type> ::=
<returns data type> [ <result cast> ]
| <returns table type>
<returns data type> ::=
<data type> [ <locator indication> ]
<result cast> ::=
CAST FROM <result cast from type>
<result cast from type> ::=
<data type> [ <locator indication> ]
<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>
<specific method name> ::=
[ <schema name> <period> ] <qualified identifier>
SELF ::=
S E L F
<method characteristics> ::=
<method characteristic> ...
<method characteristic> ::=
<language clause>
| <parameter style clause>
| <deterministic characteristic>
| <SQL-data access indication>
| <null-call clause>
<language clause> ::=
LANGUAGE <language name>
<language name> ::=
ADA
| C
| COBOL
| FORTRAN
| M
| MUMPS
| PASCAL
| PLI
| SQL
ADA ::=
A D A
COBOL ::=
C O B O L
FORTRAN ::=
F O R T R A N
MUMPS ::=
M U M P S
PASCAL ::=
P A S C A L
PLI ::=
P L I
<parameter style clause> ::=
PARAMETER STYLE <parameter style>
STYLE ::=
S T Y L E
<parameter style> ::=
SQL
| GENERAL
GENERAL ::=
G E N E R A L
<deterministic characteristic> ::=
DETERMINISTIC
| NOT DETERMINISTIC
<SQL-data access indication> ::=
NO SQL
| CONTAINS SQL
| READS SQL DATA
| MODIFIES SQL DATA
CONTAINS ::=
C O N T A I N S
<null-call clause> ::=
RETURNS NULL ON NULL INPUT
| CALLED ON NULL INPUT
<overriding method specification> ::=
OVERRIDING <partial method specification>
<user-defined cast definition> ::=
CREATE CAST <left paren> <source data type> AS <target data type> <right paren> WITH <cast function> [ AS ASSIGNMENT ]
<source data type> ::=
<data type>
<target data type> ::=
<data type>
<cast function> ::=
<specific routine designator>
ASSIGNMENT ::=
A S S I G N M E N T
<user-defined ordering definition> ::=
CREATE
ORDERING
FOR
<schema-resolved user-defined type name>
<ordering form>
ORDERING ::=
O R D E R I N G
<ordering form> ::=
<equals ordering form>
| <full ordering form>
<equals ordering form> ::=
EQUALS
ONLY
BY
<ordering category>
EQUALS ::=
E Q U A L S
<ordering category> ::=
<relative category>
| <map category>
| <state category>
<relative category> ::=
RELATIVE WITH <relative function specification>
<relative function specification> ::=
<specific routine designator>
<map category> ::=
MAP WITH <map function specification>
MAP ::=
M A P
<map function specification> ::=
<specific routine designator>
<state category> ::=
STATE [ <specific name> ]
STATE ::=
S T A T E
<full ordering form> ::=
ORDER
FULL
BY
<ordering category>
<transform definition> ::=
CREATE { TRANSFORM | TRANSFORMS } FOR <schema-resolved user-defined type name> <transform group> ...
TRANSFORM ::=
T R A N S F O R M
TRANSFORMS ::=
T R A N S F O R M S
<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>
<to sql function> ::=
<specific routine designator>
<from sql> ::=
FROM
SQL
WITH
<from sql function>
<from sql function> ::=
<specific routine designator>
<schema routine> ::=
<schema procedure>
| <schema function>
<schema procedure> ::=
CREATE <SQL-invoked procedure>
<SQL-invoked procedure> ::=
PROCEDURE
<schema qualified routine name>
<SQL parameter declaration list>
<routine characteristics>
<routine body>
<routine characteristics> ::=
[ <routine characteristic> ... ]
<routine characteristic> ::=
<language clause>
| <parameter style clause>
| SPECIFIC <specific name>
| <deterministic characteristic>
| <SQL-data access indication>
| <null-call clause>
| <dynamic result sets characteristic>
| <savepoint level indication>
<dynamic result sets characteristic> ::=
DYNAMIC
RESULT
SETS
<maximum dynamic result sets>
<maximum dynamic result sets> ::=
<unsigned integer>
<savepoint level indication> ::=
NEW SAVEPOINT LEVEL
| OLD SAVEPOINT LEVEL
<routine body> ::=
<SQL routine spec>
| <external body reference>
<SQL routine spec> ::=
[ <rights clause> ] <SQL routine body>
<rights clause> ::=
SQL SECURITY INVOKER
| SQL SECURITY DEFINER
SECURITY ::=
S E C U R I T Y
INVOKER ::=
I N V O K E R
DEFINER ::=
D E F I N E R
<SQL routine body> ::=
<SQL procedure statement>
<external body reference> ::=
EXTERNAL [ NAME <external routine name> ] [ <parameter style clause> ] [ <transform group specification> ] [ <external security clause> ]
<external routine name> ::=
<identifier>
| <character string literal>
<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>
<external security clause> ::=
EXTERNAL SECURITY DEFINER
| EXTERNAL SECURITY INVOKER
| EXTERNAL SECURITY IMPLEMENTATION DEFINED
IMPLEMENTATION ::=
I M P L E M E N T A T I O N
DEFINED ::=
D E F I N E D
<schema function> ::=
CREATE <SQL-invoked function>
<SQL-invoked function> ::=
{ <function specification> | <method specification designator> } <routine body>
<function specification> ::=
FUNCTION <schema qualified routine name> <SQL parameter declaration list> <returns clause> <routine characteristics> [ <dispatch clause> ]
<dispatch clause> ::=
STATIC DISPATCH
DISPATCH ::=
D I S P A T C H
<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>
<sequence generator definition> ::=
CREATE SEQUENCE <sequence generator name> [ <sequence generator options> ]
SEQUENCE ::=
S E Q U E N C E
<sequence generator options> ::=
<sequence generator option> ...
<sequence generator option> ::=
<sequence generator data type option>
| <common sequence generator options>
<sequence generator data type option> ::=
AS <data type>
<grant statement> ::=
<grant privilege statement>
| <grant role statement>
<grant privilege statement> ::=
GRANT <privileges> TO <grantee> [ { <comma> <grantee> } ... ] [ WITH HIERARCHY OPTION ] [ WITH GRANT OPTION ] [ GRANTED BY <grantor> ]
<privileges> ::=
<object privileges> ON <object name>
<object privileges> ::=
ALL PRIVILEGES
| <action> [ { <comma> <action> } ... ]
PRIVILEGES ::=
P R I V I L E G E S
<action> ::=
SELECT
| SELECT <left paren> <privilege column list> <right paren>
| SELECT <left paren> <privilege method list> <right paren>
| DELETE
| INSERT [ <left paren> <privilege column list> <right paren> ]
| UPDATE [ <left paren> <privilege column list> <right paren> ]
| REFERENCES [ <left paren> <privilege column list> <right paren> ]
| USAGE
| TRIGGER
| UNDER
| EXECUTE
<privilege column list> ::=
<column name list>
<privilege method list> ::=
<specific routine designator> [ { <comma> <specific routine designator> } ... ]
USAGE ::=
U S A G E
<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>
<grantee> ::=
PUBLIC
| <authorization identifier>
PUBLIC ::=
P U B L I C
HIERARCHY ::=
H I E R A R C H Y
GRANTED ::=
G R A N T E D
<grantor> ::=
CURRENT_USER
| CURRENT_ROLE
<grant role statement> ::=
GRANT <role granted> [ { <comma> <role granted> } ... ] TO <grantee> [ { <comma> <grantee> } ... ] [ WITH ADMIN OPTION ] [ GRANTED BY <grantor> ]
<role granted> ::=
<role name>
ADMIN ::=
A D M I N
<role definition> ::=
CREATE ROLE <role name> [ WITH ADMIN <grantor> ]
<SQL-invoked routine> ::=
<schema routine>
<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>
<drop schema statement> ::=
DROP
SCHEMA
<schema name>
<drop behavior>
<drop behavior> ::=
CASCADE
| RESTRICT
<alter table statement> ::=
ALTER
TABLE
<table name>
<alter table action>
<alter table action> ::=
<add column definition>
| <alter column definition>
| <drop column definition>
| <add table constraint definition>
| <drop table constraint definition>
<add column definition> ::=
ADD [ COLUMN ] <column definition>
ADD ::=
A D D
<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>
<set column default clause> ::=
SET <default clause>
<drop column default clause> ::=
DROP DEFAULT
<add column scope clause> ::=
ADD <scope clause>
<drop column scope clause> ::=
DROP SCOPE <drop behavior>
<alter identity column specification> ::=
<alter identity column option> ...
<alter identity column option> ::=
<alter sequence generator restart option>
| SET <basic sequence generator option>
<alter sequence generator restart option> ::=
RESTART WITH <sequence generator restart value>
RESTART ::=
R E S T A R T
<sequence generator restart value> ::=
<signed numeric literal>
<drop column definition> ::=
DROP [ COLUMN ] <column name> <drop behavior>
<add table constraint definition> ::=
ADD <table constraint definition>
<drop table constraint definition> ::=
DROP
CONSTRAINT
<constraint name>
<drop behavior>
<drop table statement> ::=
DROP
TABLE
<table name>
<drop behavior>
<drop view statement> ::=
DROP
VIEW
<table name>
<drop behavior>
<alter routine statement> ::=
ALTER
<specific routine designator>
<alter routine characteristics>
<alter routine 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
<drop routine statement> ::=
DROP <specific routine designator> <drop behavior>
<drop user-defined cast statement> ::=
DROP
CAST
<left paren>
<source data type>
AS
<target data type>
<right paren>
<drop behavior>
<revoke statement> ::=
<revoke privilege statement>
| <revoke role statement>
<revoke privilege statement> ::=
REVOKE [ <revoke option extension> ] <privileges> FROM <grantee> [ { <comma> <grantee> } ... ] [ GRANTED BY <grantor> ] <drop behavior>
<revoke option extension> ::=
GRANT OPTION FOR
| HIERARCHY OPTION FOR
<revoke role statement> ::=
REVOKE [ ADMIN OPTION FOR ] <role revoked> [ { <comma> <role revoked> } ... ] FROM <grantee> [ { <comma> <grantee> } ... ] [ GRANTED BY <grantor> ] <drop behavior>
<role revoked> ::=
<role name>
<drop role statement> ::=
DROP ROLE <role name>
<alter domain statement> ::=
ALTER
DOMAIN
<domain name>
<alter domain action>
<alter domain action> ::=
<set domain default clause>
| <drop domain default clause>
| <add domain constraint definition>
| <drop domain constraint definition>
<set domain default clause> ::=
SET <default clause>
<drop domain default clause> ::=
DROP DEFAULT
<add domain constraint definition> ::=
ADD <domain constraint>
<drop domain constraint definition> ::=
DROP CONSTRAINT <constraint name>
<drop domain statement> ::=
DROP
DOMAIN
<domain name>
<drop behavior>
<drop collation statement> ::=
DROP
COLLATION
<collation name>
<drop behavior>
<drop transliteration statement> ::=
DROP TRANSLATION <transliteration name>
<drop assertion statement> ::=
DROP ASSERTION <constraint name> [ <drop behavior> ]
<drop trigger statement> ::=
DROP TRIGGER <trigger name>
<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>
<add attribute definition> ::=
ADD ATTRIBUTE <attribute definition>
ATTRIBUTE ::=
A T T R I B U T E
<add original method specification> ::=
ADD <original method specification>
<add overriding method specification> ::=
ADD <overriding method specification>
<drop method specification> ::=
DROP <specific method specification designator> RESTRICT
<specific method specification designator> ::=
[ INSTANCE | STATIC | CONSTRUCTOR ] METHOD <method name> <data type list>
<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>
<add transform element list> ::=
ADD
<left paren>
<transform element list>
<right paren>
<drop transform element list> ::=
DROP <left paren> <transform kind> [ <comma> <transform kind> ] <drop behavior> <right paren>
<transform kind> ::=
TO SQL
| FROM SQL
<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>
<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>
<drop sequence generator statement> ::=
DROP
SEQUENCE
<sequence generator name>
<drop behavior>
<direct implementation-defined statement> ::=
!!
(<can be followed by separator>) ::=
( <can be followed by separator> ) <separator>
| ( <can be followed by separator> )
<can be followed by separator> ::=
<regular identifier>
| <unsigned numeric literal>
| <national character string literal>
| <binary string literal>
| <large object length token>
| <Unicode delimited identifier>
| <Unicode character string literal>
| <SQL language identifier>
| <character string literal>
| <date string>
| <time string>
| <timestamp string>
| <interval string>
| <delimited identifier>
| <SQL special character>
| <not equals operator>
| <greater than or equals operator>
| <less than or equals operator>
| <concatenation operator>
| <right arrow>
| <left bracket trigraph>
| <right bracket trigraph>
| <double colon>
| <double period>
| <percent>
| <ampersand>
| <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>
| <vertical bar>
| <left brace>
| <right brace>
<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>
<percent> ::=
%
<circumflex> ::=
^
<vertical bar> ::=
|
<left brace> ::=
{
<right brace> ::=
}
<double period> ::=
. .
(<non-reserved word>) ::=
( <non-reserved word> ) <separator>
| ( <non-reserved word> ) -: <letter>
<non-reserved word> ::=
ABSOLUTE
| ACTION
| ADA
| ADD
| ADMIN
| AFTER
| ALWAYS
| ASC
| ASSERTION
| ASSIGNMENT
| ATTRIBUTE
| ATTRIBUTES
| BEFORE
| BERNOULLI
| BREADTH
| CASCADE
| CATALOG
| CATALOG_NAME
| CHAIN
| CHARACTER_SET_CATALOG
| CHARACTER_SET_NAME
| CHARACTER_SET_SCHEMA
| CHARACTERISTICS
| CHARACTERS
| CLASS_ORIGIN
| COBOL
| COLLATION
| COLLATION_CATALOG
| COLLATION_NAME
| COLLATION_SCHEMA
| COLUMN_NAME
| COMMAND_FUNCTION
| COMMAND_FUNCTION_CODE
| COMMITTED
| CONDITION_NUMBER
| CONNECTION
| CONNECTION_NAME
| CONSTRAINT_CATALOG
| CONSTRAINT_NAME
| CONSTRAINT_SCHEMA
| CONSTRAINTS
| CONSTRUCTOR
| CONTAINS
| CONTINUE
| CURSOR_NAME
| DATA
| DATETIME_INTERVAL_CODE
| DATETIME_INTERVAL_PRECISION
| DEFAULTS
| DEFERRABLE
| DEFERRED
| DEFINED
| DEFINER
| DEGREE
| DEPTH
| DERIVED
| DESC
| DESCRIPTOR
| DIAGNOSTICS
| DISPATCH
| DOMAIN
| DYNAMIC_FUNCTION
| DYNAMIC_FUNCTION_CODE
| EQUALS
| EXCEPTION
| EXCLUDE
| EXCLUDING
| FINAL
| FIRST
| FOLLOWING
| FORTRAN
| FOUND
| GENERAL
| GENERATED
| GO
| GOTO
| GRANTED
| HIERARCHY
| IMMEDIATE
| IMPLEMENTATION
| INCLUDING
| INCREMENT
| INITIALLY
| INPUT
| INSTANCE
| INSTANTIABLE
| INVOKER
| ISOLATION
| KEY
| KEY_MEMBER
| KEY_TYPE
| LAST
| LENGTH
| LEVEL
| LOCATOR
| MAP
| MATCHED
| MAXVALUE
| MESSAGE_LENGTH
| MESSAGE_OCTET_LENGTH
| MESSAGE_TEXT
| MINVALUE
| MORE
| MUMPS
| NAME
| NAMES
| NESTING
| NEXT
| NORMALIZED
| NULLABLE
| NULLS
| NUMBER
| OBJECT
| OCTETS
| OPTION
| OPTIONS
| ORDERING
| ORDINALITY
| OTHERS
| OUTPUT
| OVERRIDING
| PAD
| PARAMETER_MODE
| PARAMETER_NAME
| PARAMETER_ORDINAL_POSITION
| PARAMETER_SPECIFIC_CATALOG
| PARAMETER_SPECIFIC_NAME
| PARAMETER_SPECIFIC_SCHEMA
| PARTIAL
| PASCAL
| PATH
| PLACING
| PLI
| PRECEDING
| PRESERVE
| PRIOR
| PRIVILEGES
| PUBLIC
| READ
| RELATIVE
| REPEATABLE
| RESTART
| RESTRICT
| RETURNED_CARDINALITY
| RETURNED_LENGTH
| RETURNED_OCTET_LENGTH
| RETURNED_SQLSTATE
| ROLE
| ROUTINE
| ROUTINE_CATALOG
| ROUTINE_NAME
| ROUTINE_SCHEMA
| ROW_COUNT
| 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
| STATE
| STATEMENT
| STRUCTURE
| STYLE
| SUBCLASS_ORIGIN
| TABLE_NAME
| TEMPORARY
| TIES
| TOP_LEVEL_COUNT
| TRANSACTION
| TRANSACTION_ACTIVE
| TRANSACTIONS_COMMITTED
| TRANSACTIONS_ROLLED_BACK
| TRANSFORM
| TRANSFORMS
| TRIGGER_CATALOG
| TRIGGER_NAME
| TRIGGER_SCHEMA
| 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
CONTINUE ::=
C O N T I N U E
FOUND ::=
F O U N D
GO ::=
G O
GOTO ::=
G O T O
SECTION ::=
S E C T I O N
<letter> ::=
a .. z
| A .. Z
(<reserved word>) ::=
( <reserved word> ) <separator>
| ( <reserved word> ) -: <letter>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment