From: Jeff Fried <
[email protected]>
Subject: Re: Where is SQL syntax spec
To: Tim Bunce <
[email protected]>
Date: Tue, 24 May 94 15:57:39 PDT
In-Reply-To: <
[email protected]>; from "Tim Bunce" at May 24, 94 6:59 pm
Tim,
I thought i'd add to life's complexity by appending a copy of the
SQL3 bnf. SQL3 is a superset of SQL-92 [which is a superset of SQL-89
level 2]. SQL3 is not yet a standard, but SQL-92 is a standard. In
fact ENTRY LEVEL SQL-92 is the "current" implementation state of most
vendors. There are only a few differences between SQL-92 ENTRY LEVEL
and SQL-89 Level II, but two of them are very important:
- Delimited identifiers
- The handling of the WITH CHECK option on views defaults to
CASCADE. In SQL-89 the default was [effectively] LOCAL.
.. jeff
>
for the language done at about 1-SEP-1993 15:13:55.88.
The specific version of the BNF included here is: ANSI-only, SQL3-only.
<SQL terminal character> ::=
<SQL language character>
<SQL language character> ::=
<simple Latin letter>
| <digit>
| <SQL special character>
<simple Latin letter> ::=
<simple Latin upper case letter>
| <simple Latin lower case letter>
<simple Latin upper case letter> ::=
A | B | C | D | E | F | G | H | I | J | K | L | M | N | O
| P | Q | R | S | T | U | V | W | X | Y | Z
<simple Latin lower case letter> ::=
a | b | c | d | e | f | g | h | i | j | k | l | m | n | o
| p | q | r | s | t | u | v | w | x | y | z
<digit> ::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<SQL special character> ::=
<space>
| <double quote>
| <percent>
| <ampersand>
| <quote>
| <left paren>
| <right paren>
| <asterisk>
| <plus sign>
| <comma>
| <minus sign>
| <period>
| <solidus>
| <colon>
| <semicolon>
| <less than operator>
| <equals operator>
| <greater than operator>
| <question mark>
| <left bracket>
| <right bracket>
| <circumflex>
| <underscore>
| <vertical bar>
<space> ::= !! <EMPHASIS>(space character in character set in use)
<double quote> ::= "
<percent> ::= %
<ampersand> ::= &
<quote> ::= '
<left paren> ::= (
<right paren> ::= )
<asterisk> ::= *
<plus sign> ::= +
<comma> ::= ,
<minus sign> ::= -
<period> ::= .
<solidus> ::= /
<colon> ::= :
<semicolon> ::= ;
<less than operator> ::= <
<equals operator> ::= =
<greater than operator> ::= >
<question mark> ::= ?
<left bracket> ::= [
<right bracket> ::= ]
<circumflex> ::= ^
<underscore> ::= _
<vertical bar> ::= |
<separator> ::= { <comment> | <space> | <newline> }...
<comment> ::=
<simple comment>
| <bracketed comment>
<simple comment> ::=
<simple comment introducer> [ <comment character>... ] <newline>
<simple comment introducer> ::= <minus sign><minus sign>[<minus sign>...]
<comment character> ::=
<nonquote character>
| <quote>
<nonquote character> ::= !! <EMPHASIS>(See the Syntax Rules.)
<newline> ::= !! <EMPHASIS>(implementation-defined end-of-line indicator)
<bracketed comment> ::= !! (<EMPHASIS>(See the Syntax Rules))
<bracketed comment introducer>
<bracketed comment contents>
<bracketed comment terminator>
<bracketed comment introducer> ::= <solidus><asterisk>
<bracketed comment contents> ::=
[ { <comment character> | <separator> }... ]
<bracketed comment terminator> ::= <asterisk><solidus>
<token> ::=
<nondelimiter token>
| <delimiter token>
<nondelimiter token> ::=
<regular identifier>
| <key word>
| <unsigned numeric literal>
| <national character string literal>
| <bit string literal>
| <hex string literal>
| <user-defined operator symbol>
<regular identifier> ::= <identifier body>
<identifier body> ::=
<identifier start> [ { <underscore> | <identifier part> }... ]
<identifier start> ::= !! <EMPHASIS>(See the Syntax Rules)
<identifier part> ::=
<identifier start>
| <digit>
<key word> ::=
<reserved word>
| <non-reserved word>
<reserved word> ::=
ABSOLUTE | ACTION | ACTOR | ADD | AFTER | ALIAS
| ALL | ALLOCATE | ALTER
| AND | ANY | ARE
| AS | ASC | ASSERTION
| ASYNC | AT
| ATTRIBUTES
| AUTHORIZATION | AVG
| BEFORE | BEGIN | BETWEEN | BIT | BIT_LENGTH
| BOOLEAN | BOTH | BREADTH | BY
| CASCADE | CASCADED | CASE | CAST
| CATALOG
| CHAR | CHARACTER
| CHAR_LENGTH | CHARACTER_LENGTH | CHECK | CLASS | CLOSE | COALESCE
| COLLATE
| COLLATION | COLUMN | COMMIT | COMPLETION
| CONNECT | CONNECTION | CONSTRAINT
| CONSTRAINTS | CONSTRUCTOR | CONTINUE | CONVERT | CORRESPONDING
| COUNT
| CREATE | CROSS | CURRENT | CURRENT_DATE
| CURRENT_PATH
| CURRENT_TIME
| CURRENT_TIMESTAMP | CURRENT_USER | CURSOR | CYCLE
| DATA | DATE | DAY | DEALLOCATE
| DEC | DECIMAL | DECLARE | DEFAULT
| DEFERRABLE | DEFERRED | DELETE | DEPTH
| DESC | DESCRIBE
| DESCRIPTOR
| DESIGNATOR
| DESTROY | DESTRUCTOR | DICTIONARY
| DIAGNOSTICS | DISCONNECT | DISTINCT | DOMAIN
| DOUBLE | DROP
| EACH
| ELEMENT
| ELSE
| END | END-EXEC | EQUALS
| ESCAPE | EXCEPT
| EXEC | EXECUTE | EXISTS | EXTERNAL | EXTRACT
| FACTOR
| FALSE | FETCH | FIRST | FLOAT | FOR | FOREIGN
| FOUND | FROM | FULL
| FUNCTION
| GENERAL | GET | GLOBAL | GO | GOTO
| GRANT | GROUP
| HAVING | HOUR
| IDENTITY | IGNORE | IMMEDIATE
| IN | INDICATOR
| INITIALLY | INNER | INOUT
| INPUT | INSENSITIVE | INSERT
| INSTEAD
| INT | INTEGER | INTERSECT | INTERVAL
| INTO | IS | ISOLATION
| JOIN
| KEY
| LANGUAGE | LAST | LEADING | LEFT
| LESS | LEVEL | LIKE | LIMIT
| LIST
| LOCAL | LOWER
| MATCH | MAX | MIN | MINUTE | MODIFY | MODULE
| MONTH
| MOVE | MULTISET
| NAMES | NATIONAL | NATURAL | NCHAR | NEW
| NEW_TABLE
| NEXT | NO
| NONE | NOT| NULL | NULLIF | NUMERIC
| OCTET_LENGTH | OF | OFF
| OID | OLD
| OLD_TABLE
| ON | ONLY | OPEN | OPERATION
| OPERATOR
| OPERATORS
| OPTION | OR | ORDER
| OUT | OUTER | OUTPUT | OVERLAPS
| PAD | PARAMETERS | PARTIAL
| PATH
| PENDANT | POSITION | POSTFIX | PRECISION | PREFIX
| PREORDER | PREPARE | PRESERVE | PRIMARY | PRIOR | PRIVATE
| PRIVILEGES | PROCEDURE | PROTECTED | PUBLIC
| READ | REAL | RECURSIVE
| REFERENCES | REFERENCING | RELATIVE | REPRESENTATION
| RESTRICT | REVOKE | RIGHT
| ROLE | ROLLBACK
| ROUTINE
| ROW | ROWS
| SAVEPOINT | SCHEMA | SCROLL | SEARCH | SECOND | SECTION
| SELECT
| SENSITIVE
| SEQUENCE
| SESSION | SESSION_USER | SET
| SIMILAR | SIZE | SMALLINT | SOME | SPACE | SPECIFIC
| SQL | SQLCODE
| SQLERROR | SQLEXCEPTION | SQLSTATE | SQLWARNING
| START | STATE
| STRUCTURE
| SUBSTRING | SUM
| SYMBOL
| SYSTEM_USER
| TABLE | TEMPLATE | TEMPORARY
| TERM
| TEST | THAN
| THEN | THERE | TIME | TIMESTAMP
| TIMEZONE_HOUR
| TIMEZONE_MINUTE | TO | TRAILING | TRANSACTION
| TRANSLATE | TRANSLATION
| TRIGGER | TRIM | TRUE | TYPE
| UNDER | UNION | UNIQUE | UNKNOWN
| UPDATE | UPPER | USAGE | USER | USING
| VALUE | VALUES | VARCHAR | VARIABLE | VARIANT
| VARYING | VIEW
| VIRTUAL | VISIBLE
| WAIT | WHEN | WHENEVER | WHERE
| WITH | WITHOUT
| WORK | WRITE
| YEAR
| ZONE
<non-reserved word> ::=
ADA
| C | CATALOG_NAME
| CHAIN
| CHARACTER_SET_CATALOG | CHARACTER_SET_NAME
| CHARACTER_SET_SCHEMA | CLASS_ORIGIN | COBOL | COLLATION_CATALOG
| COLLATION_NAME
| COLLATION_SCHEMA | COLUMN_NAME | COMMAND_FUNCTION
| COMMITTED | CONDITION_NUMBER | CONNECTION_NAME | CONSTRAINT_CATALOG
| CONSTRAINT_NAME | CONSTRAINT_SCHEMA | CURSOR_NAME
| DATA | DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_PRECISION
| DYNAMIC_FUNCTION
| FORTRAN
| HOLD
| KEY_MEMBER | KEY_TYPE
| LENGTH
| MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | MORE | MUMPS
| NAME | NULLABLE | NUMBER
| PASCAL | PLI
| REPEATABLE | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE
| ROUTINE_CATALOG | ROUTINE_NAME | ROUTINE_SCHEMA | ROW_COUNT
| SCALE | SCHEMA_NAME | SERIALIZABLE | SERVER_NAME | SPECIFIC_NAME
| SUBCLASS_ORIGIN
| TABLE_NAME | TYPE
| UNCOMMITTED | UNNAMED
<unsigned numeric literal> ::=
<exact numeric literal>
| <approximate numeric literal>
<exact numeric literal> ::=
<unsigned integer> [ <period> [ <unsigned integer> ] ]
| <period> <unsigned integer>
<unsigned integer> ::= <digit>...
<approximate numeric literal> ::= <mantissa> E <exponent>
<mantissa> ::= <exact numeric literal>
<exponent> ::= <signed integer>
<signed integer> ::= [ <sign> ] <unsigned integer>
<sign> ::= <plus sign> | <minus sign>
<national character string literal> ::=
N <quote> [ <character representation>... ] <quote>
[ { <separator> <quote> [ <character representation>... ] <quote> }... ]
<character representation> ::=
<nonquote character>
| <quote symbol>
<quote symbol> ::= <quote><quote>
<bit string literal> ::=
B <quote> [ <bit>... ] <quote>
[ { <separator> <quote> [ <bit>... ] <quote> }... ]
<bit> ::= 0 | 1
<hex string literal> ::=
X <quote> [ <hexit>... ] <quote>
[ { <separator> <quote> [ <hexit>... ] <quote> }... ]
<hexit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f
<user-defined operator symbol> ::= !! <EMPHASIS>(See the Syntax Rules)
<delimiter token> ::=
<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>
| <double period>
| <double colon>
| <assignment operator>
| <left bracket>
| <right bracket>
<character string literal> ::=
[ <introducer><character set specification> ]
<quote> [ <character representation>... ] <quote>
[ { <separator> <quote> [ <character representation>... ] <quote> }... ]
<introducer> ::= <underscore>
<character set specification> ::=
<standard character repertoire name>
| <implementation-defined character repertoire name>
| <user-defined character repertoire name>
| <standard universal character form-of-use name>
| <implementation-defined universal character form-of-use name>
<standard character repertoire name> ::= <character set name>
<character set name> ::= [ <schema name> <period> ]
<SQL language identifier>
<schema name> ::=
[ <catalog name> <period> ] <unqualified schema name>
<catalog name> ::= <identifier>
<identifier> ::=
[ <introducer><character set specification> ] <actual identifier>
<actual identifier> ::=
<regular identifier>
| <delimited identifier>
<delimited identifier> ::=
<double quote> <delimited identifier body> <double quote>
<delimited identifier body> ::= <delimited identifier part>...
<delimited identifier part> ::=
<nondoublequote character>
| <doublequote symbol>
<nondoublequote character> ::= !! <EMPHASIS>(See the Syntax Rules)
<doublequote symbol> ::= <double quote><double quote>
<unqualified schema name> ::= <identifier>
<SQL language identifier> ::=
<SQL language identifier start>
[ { <underscore> | <SQL language identifier part> }... ]
<SQL language identifier start> ::= <simple Latin letter>
<SQL language identifier part> ::=
<simple Latin letter>
| <digit>
<implementation-defined character repertoire name> ::=
<character set name>
<user-defined character repertoire name> ::= <character set name>
<standard universal character form-of-use name> ::=
<character set name>
<implementation-defined universal character form-of-use name> ::=
<character set name>
<date string> ::=
<quote> <date value> <quote>
<date value> ::=
<years value> <minus sign> <months value>
<minus sign> <days value>
<years value> ::= <datetime value>
<datetime value> ::= <unsigned integer>
<months value> ::= <datetime value>
<days value> ::= <datetime value>
<time string> ::=
<quote> <time value> [ <time zone interval> ] <quote>
<time value> ::=
<hours value> <colon> <minutes value> <colon> <seconds value>
<hours value> ::= <datetime value>
<minutes value> ::= <datetime value>
<seconds value> ::=
<seconds integer value> [ <period> [ <seconds fraction> ] ]
<seconds integer value> ::= <unsigned integer>
<seconds fraction> ::= <unsigned integer>
<time zone interval> ::=
<sign> <hours value> <colon> <minutes value>
<timestamp string> ::=
<quote> <date value> <space> <time value>
[ <time zone interval> ] <quote>
<interval string> ::=
<quote> { <year-month literal> | <day-time literal> } <quote>
<year-month literal> ::=
<years value>
| [ <years value> <minus sign> ] <months value>
<day-time literal> ::=
<day-time interval>
| <time interval>
<day-time interval> ::=
<days value>
[ <space> <hours value> [ <colon> <minutes value>
[ <colon> <seconds value> ] ] ]
<time interval> ::=
<hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]
| <minutes value> [ <colon> <seconds value> ]
| <seconds value>
<not equals operator> ::= <>
<greater than or equals operator> ::= >=
<less than or equals operator> ::= <=
<concatenation operator> ::= ||
<double period> ::= ..
<double colon> ::= ::
<assignment operator> ::= :=
<SQL-client module definition> ::= <module>
<module> ::=
<module name clause>
<module remainder>
[ END MODULE ]
<module name clause> ::=
MODULE [ <module name> ]
<module name> ::=
<SQL-server module name>
| <SQL-client module name>
<SQL-server module name> ::= <qualified identifier>
<qualified identifier> ::= <identifier>
<SQL-client module name> ::= <identifier>
<module remainder> ::=
[ <module character set specification> ]
<language clause>
<module authorization clause>
[ <module path specification> ]
<module contents>...
<module character set specification> ::=
NAMES ARE <character set specification>
<language clause> ::=
LANGUAGE <language name>
<language name> ::=
ADA | C | COBOL | FORTRAN | MUMPS | PASCAL | PLI | SQL
<module authorization clause> ::=
SCHEMA <schema name>
| AUTHORIZATION <module authorization identifier>
| SCHEMA <schema name> AUTHORIZATION <module authorization identifier>
<module authorization identifier> ::=
<authorization identifier>
<authorization identifier> ::= <identifier>
<module path specification> ::=
PATH <schema name list>
<schema name list> ::=
<schema name> [ { <comma> <schema name> }... ]
<module contents> ::=
<global declaration> [ <semicolon> ]
| <routine>
<global declaration> ::=
<declare cursor>
| <temporary abstract data type declaration>
| <temporary table declaration>
| <temporary view declaration>
<declare cursor> ::=
DECLARE <cursor name> [ <cursor sensitivity> ]
[ SCROLL ] CURSOR
[ WITH HOLD ]
FOR <cursor specification>
<cursor sensitivity> ::=
SENSITIVE
| INSENSITIVE
<cursor name> ::= <local qualified name>
<local qualified name> ::=
[ <local qualifier> <period> ] <qualified identifier>
<local qualifier> ::= MODULE
<cursor specification> ::=
<query expression> [ <order by clause> ]
[ <updatability clause> ]
<query expression> ::=
<possibly updatable query expression> [ <trigger definition>... ]
<possibly updatable query expression> ::=
<non-join query expression>
| <joined table>
<non-join query expression> ::=
<non-join query term>
| <query expression> UNION [ ALL ]
[ <corresponding spec> ] <query term>
| <query expression> EXCEPT [ ALL ]
[ <corresponding spec> ] <query term>
<non-join query term> ::=
<non-join query primary>
| <query term> INTERSECT [ ALL ]
[ <corresponding spec> ] <query primary>
| <recursive union>
<non-join query primary> ::=
<simple table>
| <left paren> <non-join query expression> <right paren>
<simple table> ::=
<query specification>
| <table value designator>
| <explicit table>
| <collection expression>
<query specification> ::=
SELECT [ <set quantifier> ] <select list>
<table expression>
<set quantifier> ::= DISTINCT | ALL
<select list> ::=
<asterisk>
| <select sublist> [ { <comma> <select sublist> }... ]
<select sublist> ::=
<derived column>
| <qualifier> <period> <asterisk>
<derived column> ::=
<value expression> [ <as clause> ]
<value expression> ::=
<numeric value expression>
| <string value expression>
| <datetime value expression>
| <interval value expression>
| <enumerated value expression>
| <boolean value expression>
| <attributes function>
| <abstract data type value expression>
| <table value expression>
| <collection value expression>
<numeric value expression> ::=
<term>
| <numeric value expression> <plus sign> <term>
| <numeric value expression> <minus sign> <term>
<term> ::=
<factor>
| <term> <asterisk> <factor>
| <term> <solidus> <factor>
<factor> ::=
[ <sign> ] <numeric primary>
<numeric primary> ::=
<value expression primary>
| <numeric value function>
<value expression primary> ::=
<unsigned value specification>
| <column reference>
| <row reference>
| <set function specification>
| <table subquery>
| <case expression>
| <left paren> <value expression> <right paren>
| <cast specification>
<unsigned value specification> ::=
<unsigned literal>
| <general value specification>
<unsigned literal> ::=
<unsigned numeric literal>
| <general literal>
<general literal> ::=
<character string literal>
| <national character string literal>
| <bit string literal>
| <hex string literal>
| <datetime literal>
| <interval literal>
| <enumeration literal>
| <boolean literal>
| <oid literal>
<datetime literal> ::=
<date literal>
| <time literal>
| <timestamp literal>
<date literal> ::=
DATE <date string>
<time literal> ::=
TIME <time string>
<timestamp literal> ::=
TIMESTAMP <timestamp string>
<interval literal> ::=
INTERVAL [ <sign> ] <interval string> <interval qualifier>
<interval qualifier> ::=
<start field> TO <end field>
| <single datetime field>
<start field> ::=
<non-second datetime field>
[ <left paren> <interval leading field precision> <right paren> ]
<non-second datetime field> ::= YEAR | MONTH | DAY | HOUR | MINUTE
<interval leading field precision> ::= <unsigned integer>
<end field> ::=
<non-second datetime field>
| SECOND
[ <left paren> <interval fractional seconds precision> <right paren> ]
<interval fractional seconds precision> ::= <unsigned integer>
<single datetime field> ::=
<non-second datetime field>
[ <left paren> <interval leading field precision> <right paren> ]
| SECOND [ <left paren> <interval leading field precision>
[ <comma> <interval fractional seconds precision> ] <right paren> ]
<enumeration literal> ::=
<domain name> <double colon> <enumeration name>
<domain name> ::= <schema qualified name>
<schema qualified name> ::=
[ <schema name> <period> ] <qualified identifier>
<enumeration name> ::= <identifier>
<boolean literal> ::=
TRUE
| FALSE
<oid literal> ::= OID <oid string>
<oid string> ::= <quote> <oid value> <quote>
<oid value> ::= <character representation>...
<general value specification> ::=
<item reference>
| USER
| CURRENT_USER
| SESSION_USER
| SYSTEM_USER
| CURRENT_PATH
| VALUE
| <function invocation>
| <attribute reference>
| <template parameter name>
<item reference> ::=
<parameter name> [ <indicator parameter> ]
<parameter name> ::= <colon> <identifier>
<indicator parameter> ::= [ INDICATOR ] <parameter name>
<function invocation> ::= <routine invocation>
<routine invocation> ::=
<routine name> <argument list>
<routine name> ::= <local or schema qualified name>
<local or schema qualified name> ::=
[ <local or schema qualifier> <period> ] <qualified identifier>
<local or schema qualifier> ::=
<schema name>
| MODULE
<argument list> ::=
<left paren> <positional arguments> <comma> <keyword arguments> <right paren>
| <left paren> <positional arguments> <right paren>
| <left paren> <keyword arguments> <right paren>
| <left paren> <right paren>
<positional arguments> ::=
<argument> [ { <comma> <argument> }... ]
<argument> ::=
<value expression>
| <generalized expression>
<generalized expression> ::=
<value expression> AS <abstract data type name>
<abstract data type name> ::= <local or schema qualified name>
<attribute name> ::=
<identifier>
| OID
<keyword arguments> ::=
<keyword argument> [ { <comma> <keyword argument> }... ]
<keyword argument> ::=
<parameter name> <keyword parameter tag> <argument>
<keyword parameter tag> ::= =>
<attribute reference> ::=
<value specification> <period> <attribute name>
<value specification> ::=
<literal>
| <general value specification>
<literal> ::=
<signed numeric literal>
| <general literal>
<signed numeric literal> ::=
[ <sign> ] <unsigned numeric literal>
<template parameter name> ::= <colon> <identifier>
<column reference> ::= [ <qualifier> <period> ] <column name>
<qualifier> ::=
<table name>
| <correlation name>
<table name> ::=
<local or schema qualified name>
<correlation name> ::= <identifier>
<column name> ::=
<identifier>
| OID
<row reference> ::= ROW <qualifier>
<set function specification> ::=
COUNT <left paren> <asterisk> <right paren>
| <general set function>
<general set function> ::=
<set function type>
<left paren> [ <set quantifier> ] <value expression> <right paren> ]
<set function type> ::=
AVG | MAX | MIN | SUM | COUNT
<table subquery> ::= <subquery>
<subquery> ::= <left paren> <query expression> <right paren>
<case expression> ::=
<case abbreviation>
| <case specification>
<case abbreviation> ::=
NULLIF <left paren> <value expression> <comma>
<value expression> <right paren>
| COALESCE <left paren> <value expression>
{ <comma> <value expression> }... <right paren>
<case specification> ::=
<simple case>
| <searched case>
<simple case> ::=
CASE <case operand>
<simple when clause>...
[ <else clause> ]
END
<case operand> ::= <value expression>
<simple when clause> ::= WHEN <when operand> THEN <result>
<when operand> ::= <value expression>
<result> ::= <result expression> | NULL
<result expression> ::= <value expression>
<else clause> ::= ELSE <result>
<searched case> ::=
CASE
<searched when clause>...
[ <else clause> ]
END
<searched when clause> ::= WHEN <search condition> THEN <result>
<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 primary>
<boolean primary> ::=
<predicate>
| <value expression primary>
<predicate> ::=
<comparison predicate>
| <between predicate>
| <in predicate>
| <like predicate>
| <null predicate>
| <quantified comparison predicate>
| <exists predicate>
| <unique predicate>
| <match predicate>
| <overlaps predicate>
| <similar predicate>
| <quantified predicate>
| <there is predicate>
| <distinct predicate>
| <boolean predicate>
<comparison predicate> ::=
<row value designator> <comp op> <row value designator>
<row value designator> ::=
<row value designator element>
| <left paren> <row value designator list> <right paren>
| <row subquery>
<row value designator element> ::=
<value expression>
| <null specification>
| <default specification>
<null specification> ::=
NULL [ <left paren> <null state> <right paren> ]
<null state> ::= <identifier>
<default specification> ::=
DEFAULT
<row value designator list> ::=
<row value designator element>
[ { <comma> <row value designator element> }... ]
<row subquery> ::= <subquery>
<comp op> ::=
<equals operator>
| <not equals operator>
| <less than operator>
| <greater than operator>
| <less than or equals operator>
| <greater than or equals operator>
<between predicate> ::=
<row value designator> [ NOT ] BETWEEN
<row value designator> AND <row value designator>
<in predicate> ::=
<row value designator>
[ NOT ] IN <in predicate value>
<in predicate value> ::=
<table subquery>
| <left paren> <in value list> <right paren>
<in value list> ::=
<value expression> { <comma> <value expression> }...
<like predicate> ::=
<match value> [ NOT ] LIKE <pattern>
[ ESCAPE <escape character> ]
<match value> ::= <character value expression>
<character value expression> ::=
<concatenation>
| <character factor>
<concatenation> ::=
<character value expression> <concatenation operator>
<character factor>
<character factor> ::=
<character primary> [ <collate clause> ]
<character primary> ::=
<value expression primary>
| <string value function>
<string value function> ::=
<character value function>
| <bit value function>
<character value function> ::=
<character substring function>
| <regular expression substring function>
| <fold>
| <form-of-use conversion>
| <character translation>
| <trim function>
<character substring function> ::=
SUBSTRING <left paren> <character value expression> FROM <start position>
[ FOR <string length> ] <right paren>
<start position> ::= <numeric value expression>
<string length> ::= <numeric value expression>
<regular expression substring function> ::=
SUBSTRING <left paren> <character value expression> FROM
<character value expression> FOR
<escape character> <right paren>
<escape character> ::= <character value expression>
<fold> ::= { UPPER | LOWER }
<left paren> <character value expression> <right paren>
<form-of-use conversion> ::=
CONVERT <left paren> <character value expression>
USING <form-of-use conversion name> <right paren>
<form-of-use conversion name> ::= <schema qualified name>
<character translation> ::=
TRANSLATE <left paren> <character value expression>
USING <translation name> <right paren>
<translation name> ::= <schema qualified name>
<trim function> ::=
TRIM <left paren> <trim operands> <right paren>
<trim operands> ::=
[ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>
<trim specification> ::=
LEADING
| TRAILING
| BOTH
<trim character> ::= <character value expression>
<trim source> ::= <character value expression>
<bit value function> ::=
<bit substring function>
<bit substring function> ::=
SUBSTRING <left paren> <bit value expression> FROM <start position>
[ FOR <string length> ] <right paren>
<bit value expression> ::=
<bit concatenation>
| <bit factor>
<bit concatenation> ::=
<bit value expression> <concatenation operator> <bit factor>
<bit factor> ::= <bit primary>
<bit primary> ::=
<value expression primary>
| <string value function>
<collate clause> ::= COLLATE <collation name>
<collation name> ::= <schema qualified name>
<pattern> ::= <character value expression>
<null predicate> ::= <row value designator>
IS [ NOT ] NULL
[ <left paren> <null values specification> <right paren> ]
<null values specification> ::= <asterisk> | <null state>
<quantified comparison predicate> ::=
<row value designator> <comp op> <quantifier> <table subquery>
<quantifier> ::= <all> | <some>
<all> ::= ALL
<some> ::= SOME | ANY
<exists predicate> ::= EXISTS <table subquery>
<unique predicate> ::= UNIQUE <table subquery>
<match predicate> ::=
<row value designator> MATCH [ UNIQUE ]
[ PARTIAL | FULL ] <table subquery>
<overlaps predicate> ::=
<row value designator 1> OVERLAPS <row value designator 2>
<row value designator 1> ::= <row value designator>
<row value designator 2> ::= <row value designator>
<row value designator 1> ::= <row value designator>
<row value designator 2> ::= <row value designator>
<similar predicate> ::=
<match value> [ NOT ] SIMILAR TO
<similar pattern>
[ ESCAPE <escape character> ]
<similar pattern> ::= <character value expression>
<quantified predicate> ::=
<existential clause> <left paren> <search condition> <right paren>
| <universal clause> <left paren> <search condition> <right paren>
| <quantified comparison predicate>
<existential clause> ::=
FOR SOME <table reference list>
<table reference list> ::=
<table reference> [ { <comma> <table reference> }... ]
<table reference> ::=
<table name> [ [ AS ] <correlation name>
[ <left paren> <derived column list> <right paren> ] ]
| <derived table> [ AS ] <correlation name>
[ <left paren> <derived column list> <right paren> ]
| <joined table>
<derived column list> ::= <column name list>
<column name list> ::=
<column name> [ { <comma> <column name> }... ]
<derived table> ::= <table subquery>
<joined table> ::=
<cross join>
| <qualified join>
| <left paren> <joined table> <right paren>
<cross join> ::=
<table reference> CROSS JOIN <table reference>
<qualified join> ::=
<table reference> [ NATURAL ] [ <join type> ] JOIN
<table reference> [ <join specification> ]
<join type> ::=
INNER
| <outer join type> [ OUTER ]
| UNION
<outer join type> ::=
LEFT
| RIGHT
| FULL
<join specification> ::=
<join condition>
| <named columns join>
| <constraint join>
<join condition> ::= ON <search condition>
<named columns join> ::=
USING <left paren> <join column list> <right paren>
<join column list> ::= <column name list>
<constraint join> ::=
| USING PRIMARY KEY
| USING FOREIGN KEY
| USING CONSTRAINT <constraint name>
<constraint name> ::= <schema qualified name>
<universal clause> ::=
FOR ALL <table reference list>
<there is predicate> ::=
<left paren> <there is clause> <where clause> <right paren>
<there is clause> ::=
THERE IS <table reference list>
<where clause> ::= WHERE <search condition>
<distinct predicate> ::=
<row value designator 1> IS DISTINCT FROM
<row value designator 2>
<boolean predicate> ::=
<boolean value expression> [ IS [ NOT ]
<truth value> ]
<truth value> ::=
TRUE
| FALSE
| UNKNOWN
<cast specification> ::=
CAST <left paren> <cast operand> AS
<cast target> <right paren>
<cast operand> ::=
<value expression>
| NULL
<cast target> ::=
<domain name>
| <data type>
<data type> ::=
<predefined type>
| <abstract data type name>
| <generated type reference>
| <template parameter name>
| <collection type>
<predefined type> ::=
<character string type>
[ CHARACTER SET <character set specification> ]
| <national character string type>
| <bit string type>
| <numeric type>
| <enumerated 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>
<length> ::= <unsigned integer>
<national character string type> ::=
NATIONAL CHARACTER [ <left paren> <length> <right paren> ]
| NATIONAL CHAR [ <left paren> <length> <right paren> ]
| NCHAR [ <left paren> <length> <right paren> ]
| NATIONAL CHARACTER VARYING <left paren> <length> <right paren>
| NATIONAL CHAR VARYING <left paren> <length> <right paren>
| NCHAR VARYING <left paren> <length> <right paren>
<bit string type> ::=
BIT [ <left paren> <length> <right paren> ]
| BIT VARYING <left paren> <length> <right paren>
<numeric type> ::=
<exact numeric type>
| <approximate numeric type>
<exact numeric type> ::=
NUMERIC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
| DECIMAL [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
| DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
| INTEGER
| INT
| SMALLINT
<precision> ::= <unsigned integer>
<scale> ::= <unsigned integer>
<approximate numeric type> ::=
FLOAT [ <left paren> <precision> <right paren> ]
| REAL
| DOUBLE PRECISION
<enumerated type> ::=
<left paren> <enumeration name list> <right paren>
<enumeration name list> ::=
<enumeration name> [ { <comma> <enumeration name> }... ]
<boolean type> ::= BOOLEAN
<datetime type> ::=
DATE
| TIME [ <left paren> <time precision> <right paren> ]
[ WITH TIME ZONE ]
| TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
[ WITH TIME ZONE ]
<time precision> ::= <time fractional seconds precision>
<time fractional seconds precision> ::= <unsigned integer>
<timestamp precision> ::= <time fractional seconds precision>
<interval type> ::= INTERVAL <interval qualifier>
<generated type reference> ::=
<type template name> <template parameter list>
<type template name> ::= <schema qualified name>
<template parameter list> ::=
<left paren>
<template parameter> [ { <comma> <template parameter> }... ]
<right paren>
<template parameter> ::=
<value specification>
| <data type>
<collection type> ::=
<set type>
| <multiset type>
| <list type>
<set type> ::= SET <left paren> <data type> <right paren>
<multiset type> ::= MULTISET <left paren> <data type> <right paren>
<list type> ::= LIST <left paren> <data type> <right paren>
<numeric value function> ::=
<position expression>
| <extract expression>
| <length expression>
<position expression> ::=
POSITION <left paren> <character value expression>
IN <character value expression> <right paren>
<extract expression> ::=
EXTRACT <left paren> <extract field>
FROM <extract source> <right paren>
<extract field> ::=
<datetime field>
| <time zone field>
<datetime field> ::=
<non-second datetime field>
| SECOND
<time zone field> ::=
TIMEZONE_HOUR
| TIMEZONE_MINUTE
<extract source> ::=
<datetime value expression>
| <interval value expression>
<datetime value expression> ::=
<datetime term>
| <interval value expression> <plus sign> <datetime term>
| <datetime value expression> <plus sign> <interval term>
| <datetime value expression> <minus sign> <interval term>
<interval term> ::=
<interval factor>
| <interval term 2> <asterisk> <factor>
| <interval term 2> <solidus> <factor>
| <term> <asterisk> <interval factor>
<interval factor> ::=
[ <sign> ] <interval primary>
<interval primary> ::=
<value expression primary> [ <interval qualifier> ]
<interval term 2> ::= <interval term>
<interval value expression> ::=
<interval term>
| <interval value expression 1> <plus sign> <interval term 1>
| <interval value expression 1> <minus sign> <interval term 1>
| <left paren> <datetime value expression> <minus sign>
<datetime term> <right paren> <interval qualifier>
<interval value expression 1> ::= <interval value expression>
<interval term 1> ::= <interval term>
<datetime term> ::=
<datetime factor>
<datetime factor> ::=
<datetime primary> [ <time zone> ]
<datetime primary> ::=
<value expression primary>
| <datetime value function>
<datetime value function> ::=
<current date value function>
| <current time value function>
| <current timestamp value function>
<current date value function> ::= CURRENT_DATE
<current time value function> ::=
CURRENT_TIME [ <left paren> <time precision> <right paren> ]
<current timestamp value function> ::=
CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
<time zone> ::=
AT <time zone specifier>
<time zone specifier> ::=
LOCAL
| TIME ZONE <interval primary>
<length expression> ::=
<char length expression>
| <octet length expression>
| <bit length expression>
<char length expression> ::=
{ CHAR_LENGTH | CHARACTER_LENGTH }
<left paren> <string value expression> <right paren>
<string value expression> ::=
<character value expression>
| <bit value expression>
<octet length expression> ::=
OCTET_LENGTH <left paren> <string value expression> <right paren>
<bit length expression> ::=
BIT_LENGTH <left paren> <string value expression> <right paren>
<enumerated value expression> ::=
<domain name> <left paren> <value expression> <right paren>
| <enumerated primary>
<enumerated primary> ::=
<value expression primary>
<attributes function> ::=
ATTRIBUTES
<left paren> <abstract data type value expression> <right paren>
<abstract data type value expression> ::= <ADT expression>
<ADT expression> ::=
<ADT term>
| <ADT expression> <term operator> <ADT term>
<term operator> ::= <ADT operator>
<ADT operator> ::= <user-defined operator symbol)
<ADT term> ::=
<ADT factor>
| <ADT term> <factor operator> <ADT factor>
<factor operator> ::= <ADT operator>
<ADT factor> ::=
<ADT primary>
| <prefix operator> <ADT primary>
| <ADT primary> <postfix operator>
<ADT primary> ::=
<value expression primary>
<prefix operator> ::= <ADT operator>
<postfix operator> ::= <ADT operator>
<table value expression> ::=
<table type>
<left paren>
[ <value expression> [ { <comma> <value expression> }... ] ]
<right paren>
<table type> ::=
TABLE
| SET
| LIST
<collection value expression> ::=
<set value designator>
| <multiset value designator>
| <list value designator>
<set value designator> ::=
SET <left paren> [ <collection list> ] <right paren>
<collection list> ::=
<collection element> [ { <comma> <collection element> }... ]
<collection element> ::= <value expression>
<multiset value designator> ::=
MULTISET <left paren> [ <collection list> ] <right paren>
<list value designator> ::=
LIST <left paren> [ <collection list> ] <right paren>
<as clause> ::= [ AS ] <column name>
<table expression> ::=
<from clause>
[ <where clause> ]
[ <group by clause> ]
[ <having clause> ]
<from clause> ::= FROM <table reference>
[ { <comma> <table reference> }... ]
<group by clause> ::=
GROUP BY <grouping column reference list>
<grouping column reference list> ::=
<grouping column reference>
[ { <comma> <grouping column reference> }... ]
<grouping column reference> ::=
<column reference> [ <collate clause> ]
<having clause> ::= HAVING <search condition>
<table value designator> ::=
VALUES <table value designator list>
<table value designator list> ::=
<row value designator> [ { <comma> <row value designator> }... ]
<explicit table> ::= <table type> <table name>
<collection expression> ::=
<value expression>
<query term> ::=
<non-join query term>
| <joined table>
<corresponding spec> ::=
CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]
<corresponding column list> ::= <column name list>
<query primary> ::=
<non-join query primary>
| <joined table>
<recursive union> ::=
<left paren> <initial expression>
RECURSIVE UNION <correlation name list>
[ <left paren> <recursive column list> <right paren> ]
<iteration expression>
[ <search clause> ]
[ <cycle clause> ]
[ <limit clause> ] <right paren>
<initial expression> ::= <query expression>
<correlation name list> ::=
<correlation name> [ { <comma> <correlation name> }... ]
<recursive column list> ::= <column name list>
<iteration expression> ::= <query expression>
<search clause> ::=
SEARCH <search order> SET <sequence column>
<search order> ::=
PREORDER
| { DEPTH | BREADTH } FIRST BY <sort specification list>
<sort specification list> ::=
<sort specification> [ { <comma> <sort specification> }... ]
<sort specification> ::=
<sort key> [ <collate clause> ] [ <ordering specification> ]
<sort key> ::=
<value expression>
<ordering specification> ::= ASC | DESC
<sequence column> ::= <column name>
<cycle clause> ::=
CYCLE [ <cycle column list> ]
SET <cycle mark column>
[ TO <cycle mark value> ]
<cycle column list> ::=
<cycle column> [ { <comma> <cycle column> }... ]
<cycle column> ::= <column name>
<cycle mark column> ::= <column name>
<cycle mark value> ::= <value expression>
<limit clause> ::=
[ RETURN | EXCEPTION ] LIMIT
<left paren> <value specification> <right paren>
<trigger definition> ::=
[ CREATE ] TRIGGER [ <trigger name> ]
<trigger action time> <trigger event>
[ ON <table name> ]
[ ORDER <order value> ]
[ REFERENCING <old or new values alias list> ]
<triggered action>
<trigger name> ::= <schema qualified name>
<trigger action time> ::=
BEFORE
| AFTER
| INSTEAD OF
<trigger event> ::=
INSERT
| DELETE
| UPDATE [ OF <trigger column list> ]
<trigger column list> ::= <column name list>
<order value> ::= <unsigned integer>
<old or new values alias list> ::=
<old or new values alias>...
<old or new values alias> ::=
OLD [ AS ]
<old values correlation name>
| NEW [ AS ]
<new values correlation name>
| OLD_TABLE [ AS ]
<old values table alias>
| NEW_TABLE [ AS ]
<new values table alias>
<old values correlation name> ::= <correlation name>
<new values correlation name> ::= <correlation name>
<old values table alias> ::= <identifier>
<new values table alias> ::= <identifier>
<triggered action> ::=
[ FOR EACH { ROW | STATEMENT } ]
[ WHEN <left paren> <search condition> <right paren> ]
<triggered SQL statement>
<triggered SQL statement> ::=
<SQL procedure statement> <semicolon>
<SQL procedure statement> ::=
[ ASYNC <left paren> <async statement identifier> <right paren> ]
<SQL executable statement>
<async statement identifier> ::= <numeric value expression>
<SQL executable statement> ::=
<SQL schema statement>
| <SQL data statement>
| <SQL transaction statement>
| <SQL connection statement>
| <SQL session statement>
| <SQL diagnostics statement>
<SQL schema statement> ::=
<SQL schema definition statement>
| <SQL schema manipulation statement>
<SQL schema definition statement> ::=
<schema definition>
| <table definition>
| <view definition>
| <grant statement>
| <role definition>
| <grant role statement>
| <domain definition>
| <null class definition>
| <character set definition>
| <collation definition>
| <translation definition>
| <assertion definition>
| <trigger definition>
| <routine>
| <abstract data type definition>
| <type template definition>
<schema definition> ::=
CREATE SCHEMA <schema name clause>
[ <schema character set specification> ]
[ <schema path specification> ]
[ <schema element>... ]
<schema name clause> ::=
<schema name>
| AUTHORIZATION <schema authorization identifier>
| <schema name> AUTHORIZATION <schema authorization identifier>
<schema authorization identifier> ::=
<authorization identifier>
<schema character set specification> ::=
DEFAULT CHARACTER SET <character set specification>
<schema path specification> ::=
PATH <schema name list>
<schema element> ::=
<table definition>
| <view definition>
| <domain definition>
| <null class definition>
| <character set definition>
| <collation definition>
| <translation definition>
| <assertion definition>
| <trigger definition>
| <routine>
| <abstract data type definition>
| <type template definition>
| <grant statement>
| <role definition>
| <grant role statement>
<table definition> ::=
CREATE [ <table scope> ] <table type> <table name>
[ <constant or updatable> ]
{ <table element list> | <subtable clause> }
[ ON COMMIT <table commit action> ROWS ]
<table scope> ::=
<global or local> TEMPORARY
<global or local> ::=
GLOBAL
| LOCAL
<constant or updatable> ::=
CONSTANT
| UPDATABLE
<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> | <domain name> }
[ <default clause> ]
[ <column constraint definition>... ]
[ <collate clause> ]
[ <null clause> ]
<default clause> ::=
{ DEFAULT | <assignment operator> } <default option>
<default option> ::=
<literal>
| <datetime value function>
| USER
| CURRENT_USER
| SESSION_USER
| SYSTEM_USER
| NULL [ <left paren> <null state> <right paren> ]
| <function invocation>
<column constraint definition> ::=
[ <constraint name definition> ]
<column constraint> [ <constraint attributes> ]
<constraint name definition> ::= CONSTRAINT <constraint name>
<column constraint> ::=
NOT NULL
| <unique specification>
| <references specification>
| <check constraint definition>
<unique specification> ::=
UNIQUE
| PRIMARY KEY
<references specification> ::=
REFERENCES [ PENDANT ] <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
<referential triggered action> ::=
<update rule> [ <delete rule> ]
| <delete rule> [ <update rule> ]
<update rule> ::= ON UPDATE <referential action>
<referential action> ::=
CASCADE
| SET NULL [ <left paren> <null state> <right paren> ]
| SET DEFAULT
| RESTRICT
| NO ACTION
<delete rule> ::= ON DELETE <referential action>
<check constraint definition> ::=
CHECK <left paren> <search condition> <right paren>
<constraint attributes> ::=
<constraint check time> [ [ NOT ] DEFERRABLE ]
| [ NOT ] DEFERRABLE [ <constraint check time> ]
<constraint check time> ::=
INITIALLY DEFERRED
| INITIALLY IMMEDIATE
<null clause> ::=
NULL IS <null class name>
<null class name> ::= <schema qualified name>
<null clause> ::=
NULL IS <null class name>
<table constraint definition> ::=
[ <constraint name definition> ]
<table constraint> [ <constraint attributes> ]
<table constraint> ::=
<unique constraint definition>
| <referential constraint definition>
| <check constraint definition>
<unique constraint definition> ::=
even in SQL3)
<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>
<subtable clause> ::=
UNDER <supertable clause>
[ { , <supertable clause> }... ]
<supertable clause> ::=
<supertable name>
[ WITH ( <member renaming element>
[ { , <member renaming element> }... ] ) ]
<supertable name> ::= <table name>
<member renaming element> ::=
<supertable member name> AS <subtable member name>
<supertable member name> ::=
<column name>
| <routine name>
<subtable member name> ::=
<column name>
| <routine name>
<table commit action> ::=
PRESERVE
| DELETE
<view definition> ::=
CREATE VIEW <table name> [ <left paren> <view column list> <right paren> ]
AS <query expression>
[ WITH [ <levels clause> ] CHECK OPTION ]
<view column list> ::= <column name list>
<levels clause> ::=
CASCADED
| LOCAL
<domain definition> ::=
CREATE DOMAIN <domain name>
[ AS ] <data type>
[ <default clause> ]
[ <domain constraint>... ]
[ <collate clause> ]
[ <null clause> ]
<domain constraint> ::=
[ <constraint name definition> ]
<check constraint definition> [ <constraint attributes> ]
<null class definition> ::=
CREATE NULL CLASS <null class name> [ AS ]
( <null state list> )
<null state list> ::=
<null state> [ { <comma> <null state> }... ]
<character set definition> ::=
CREATE CHARACTER SET <character set name>
[ AS ]
<character set source>
<form-of-use specification>
[ <collate clause> | <limited collation definition> ]
<character set source> ::=
GET <existing character set name>
[ <plus sign> <character set source> ]
| <left paren> <character list> <right paren>
<character list> ::=
<character specification> [ { <comma> <character specification> }... ]
<character specification> ::=
<character string literal>
| <ISO 10646 position>
| <ISO 10646 character name>
<ISO 10646 position> ::=
<val> [ <sep> <val> [ <sep> <val> [ <sep> <val> ] ] ]
<val> ::= <unsigned numeric literal>
<sep> ::= <ampersand>
<ISO 10646 character name> ::= !! <EMPHASIS>(See the Syntax Rules)
<form-of-use specification> ::= <identifier>
<limited collation definition> ::=
COLLATION FROM <collation source>
<collation source> ::=
<collating sequence definition>
| <translation collation>
| <collation dictionary specification>
| <collation routine specification>
<collating sequence definition> ::=
<external collation>
| <schema collation name>
| <internal collation source>
| DESC <left paren> <collation name> <right paren>
| DEFAULT
<external collation> ::=
EXTERNAL
<left paren> <quote> <external collation name> <quote> <right paren>
<external collation name> ::=
<standard collation name>
| <implementation-defined collation name>
<standard collation name> ::= <collation name>
<implementation-defined collation name> ::= <collation name>
<schema collation name> ::= <collation name>
<internal collation source> ::= <left paren> <collation options> <right paren>
<collation options> ::=
<collation option> [ { <comma> <collation option> }... ]
<collation option> ::=
USING <left paren> <collating basis> <right paren>
| SEQUENCE <left paren> <enumerated collating sequence> <right paren>
| MODIFY <left paren> <collating modifiers> <right paren>
| WHEN NOT FOUND
{ IGNORE | MAX | MIN }
<collating basis> ::=
<collating foundation> [ { <plus sign> <collating foundation> }... ]
<collating foundation> ::=
<collating sequence definition>
<collating sequence definition> [ { <asterisk> <translation name> }... ]
<enumerated collating sequence> ::=
<collating chars> [ { <comma> <collating chars> }... ]
<collating chars> ::=
<character specification>
| <character range>
<character range> ::=
<character specification> <minus sign> <character specification>
<collating modifiers> ::=
<collating modifier> [ { <comma> <collating modifier> }... ]
<collating modifier> ::=
<collating chars>
{ <less than operator> | <greater than operator> | <equals operator> }
<collating chars>
<translation collation> ::=
TRANSLATION <translation name>
[ THEN COLLATION <collation name> ]
<collation dictionary specification> ::=
DICTIONARY <dictionary name> [ <plus sign> <dictionary name> ]
<dictionary name> ::=
<quote> <implementation-defined dictionary name> <quote>
<implementation-defined dictionary name> ::= !! <EMPHASIS>(See the Syntax Rules)
<collation routine specification> ::=
ROUTINE <left paren> <implementation-defined routine name>
<left paren> <params> <right paren> <right paren>
<implementation-defined routine name> ::= !! <EMPHASIS>(See the Syntax Rules)
<params> ::= !! <EMPHASIS>(Not yet defined)
<params> ::= !! <EMPHASIS>(Not yet defined)
<existing character set name> ::=
<standard character repertoire name>
| <implementation-defined character repertoire name>
| <schema character set name>
<schema character set name> ::= <character set name>
<collation definition> ::=
CREATE COLLATION <collation name> FOR
<character set specification>
FROM <collation source>
[ <pad attribute> ]
<pad attribute> ::=
NO PAD
| PAD SPACE
<translation definition> ::=
CREATE TRANSLATION <translation name>
FOR <source character set specification>
TO <target character set specification>
FROM <translation source>
<source character set specification> ::= <character set specification>
<target character set specification> ::= <character set specification>
<translation source> ::=
<translation specification>
| <translation routine>
<translation specification> ::=
<external translation>
| IDENTITY
| <schema translation name>
| <internal translation source>
<external translation> ::=
EXTERNAL
<left paren> <quote> <external translation name> <quote> <right paren>
<external translation name> ::=
<standard translation name>
| <implementation-defined translation name>
<standard translation name> ::= <translation name>
<implementation-defined translation name> ::= <translation name>
<schema translation name> ::= <translation name>
<internal translation source> ::=
<left paren> <translation options> <right paren>
<translation options> ::=
<translation option> [ { <comma> <translation option> }... ]
<translation option> ::=
USING <left paren> <translation basis> <right paren>
| MODIFY <left paren> <translation modifiers> <right paren>
<translation basis> ::=
<translation definition> [ { <asterisk> <translation definition> }... ]
<translation modifiers> ::=
<translation modifier> [ { <comma> <translation modifier> }... ]
<translation modifier> ::=
<collating chars> <equals operator> <collating chars>
<translation routine> ::=
ROUTINE <left paren> <implementation-defined routine name>
<left paren> <params> <right paren> <right paren>
<assertion definition> ::=
CREATE ASSERTION <constraint name>
<assertion trigger>...
<triggered assertion> [ <constraint attributes> ]
<assertion trigger> ::=
<immediate assertion trigger>
| <deferred assertion trigger>
<immediate assertion trigger> ::=
AFTER { <assertion trigger statement>
[ { <comma> <assertion trigger statement> }... ] ON
<table name> }...
<assertion trigger statement> ::=
INSERT
| DELETE
| UPDATE [ OF <left paren> <assertion column list> <right paren> ]
<assertion column list> ::= <column name list>
<deferred assertion trigger> ::= BEFORE COMMIT
<triggered assertion> ::=
CHECK <left paren> <search condition> <right paren>
[ FOR
[ EACH [ ROW OF ] ] <table name> ]
<routine> ::=
[ CREATE | DECLARE ] <routine header> <routine name> <parameter list>
[ <returns clause> ]
[ <caller language clause> ]
[ SPECIFIC <specific name> ] <semicolon>
<routine body> <semicolon>
<routine header> ::=
PROCEDURE
| [ <function type> ] FUNCTION
<function type> ::=
CONSTRUCTOR
| DESTRUCTOR
| DESIGNATOR
| ACTOR
<parameter list> ::=
<left paren>
[ <parameter declaration> [ { <comma> <parameter declaration> }... ] ]
<right paren>
<parameter declaration> ::=
[ <parameter mode> ] [ <parameter name> ] <data type>
[ <default clause> ]
| <status parameter>
<parameter mode> ::=
IN
| OUT
| INOUT
<status parameter> ::=
SQLSTATE
| SQLCODE
<returns clause> ::= RETURNS <returns data type> [ <result cast> ]
<returns data type> ::= <data type>
<result cast> ::= CAST FROM <data type>
<caller language clause> ::= <language clause>
<specific name> ::= <schema qualified name>
<routine body> ::=
<SQL routine body>
| <external body reference>
<SQL routine body> ::= <SQL procedure statement>
<external body reference> ::=
EXTERNAL [ NAME <external routine name> ]
<external routine language clause>
[ <variant attribute> ]
<external routine name> ::= <identifier>
<external routine language clause> ::= <language clause>
<variant attribute> ::=
VARIANT
| NOT VARIANT
<abstract data type definition> ::=
<distinct type definition>
| <explicit abstract data type definition>
<distinct type definition> ::=
CREATE DISTINCT TYPE <distinct type name>
AS <data type>
<distinct type name> ::= <abstract data type name>
<explicit abstract data type definition> ::=
CREATE TYPE <abstract data type name>
<abstract data type body>
<abstract data type body> ::=
[ <oid options> ]
[ <subtype clause> ]
[ [ <constant or updatable> ] [ <member list> ] ]
<oid options> ::=
WITH OID [ [ NOT ] VISIBLE ]
| WITHOUT OID
<subtype clause> ::=
UNDER <supertype clause>
[ { <comma> <supertype clause> }... ]
<supertype clause> ::=
<abstract data type name> [ <component renaming clause> ]
<component renaming clause> ::=
WITH <left paren> <component renaming element>
[ { , <component renaming element> }... ] <right paren>
<component renaming element> ::=
<supertype component name> AS <subtype component name>
<supertype component name> ::= <component name>
<component name> ::= <identifier>
<subtype component name> ::= <component name>
<member list> ::=
<left paren> <member> [ { <comma> <member> }... ] <right paren>
<member> ::=
<attribute definition>
| <routine declaration>
| <operator name list>
| <equals clause>
| <less-than clause>
| <cast clause>
| <table constraint definition>
<attribute definition> ::=
<stored attribute>
| <virtual attribute>
<stored attribute> ::=
[ <encapsulation level> ]
<attribute name> [ <constant or updatable> ]
{ <data type> | <domain name> }
[ <default clause> ]
[ <column constraint definition>... ]
[ <collate clause> ]
[ <null clause> ]
<encapsulation level> ::=
PRIVATE
| PROTECTED
| PUBLIC
<virtual attribute> ::=
[ <encapsulation level> ]
<attribute name> <derivation clause>
[ <check constraint definition>... ]
[ <collate clause> ]
<derivation clause> ::=
[ READ ONLY | CONSTANT | UPDATABLE ] <data type>
VIRTUAL [ <derivation functions> ]
<derivation functions> ::=
<get function> [ <set function> ]
| <set function> [ <get function> ]
<get function> ::=
GET WITH <routine name>
<set function> ::=
SET WITH <routine name>
<routine declaration> ::=
[ <encapsulation level> ] <routine>
<operator name list> ::=
OPERATORS <specific routine designator>...
<specific routine designator> ::=
SPECIFIC <specific name>
| <member name>
<member name> ::= <routine name> [ <data type list> ]
<data type list> ::=
<left paren> <data type> [ { <comma> <data type> }... ] <right paren>
<equals clause> ::=
EQUALS <equals function specification> <semicolon>
<equals function specification> ::=
<routine name>
| STATE
| OID
<less-than clause> ::=
LESS THAN <less-than function specification> <semicolon>
<less-than function specification> ::=
<routine name>
| NONE
<cast clause> ::=
CAST <left paren> <operand data type> AS
<result data type>
WITH <cast function> <right paren> <semicolon>
<operand data type> ::= <data type>
<result data type> ::= <data type>
<cast function> ::=
<routine name>
<type template definition> ::=
CREATE TYPE TEMPLATE <type template name>
<template parameter declaration list>
<abstract data type body>
<template parameter declaration list> ::=
<left paren>
<template parameter declaration>
[ { <comma> <template parameter declaration>}... ]
<right paren>
<template parameter declaration> ::=
<template parameter name> <template parameter type>
<template parameter type> ::=
<data type>
| TYPE
<grant statement> ::=
GRANT <privileges>
TO <grantee> [ { <comma> <grantee> }... ]
[ WITH GRANT OPTION ]
<privileges> ::=
ALL SCHEMA PRIVILEGES
| <object privileges> ON <object name>
<object privileges> ::=
ALL PRIVILEGES
| <action> [ { <comma> <action> }... ]
<action> ::=
SELECT [ <left paren> <privilege column 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
| EXECUTE
| UNDER
<privilege column list> ::= <column name list>
<object name> ::=
[ <table type> ] <table name>
| DOMAIN <domain name>
| COLLATION <collation name>
| CHARACTER SET <character set name>
| TRANSLATION <translation name>
| NULL CLASS <null class name>
| DATA TYPE <abstract data type name>
| MODULE <module name>
| TYPE TEMPLATE <type template name>
| EXTERNAL ROUTINE <specific routine designator>
<grantee> ::=
PUBLIC
| <authorization identifier>
| <role name>
<role name> ::= <authorization identifier>
<role definition> ::= CREATE ROLE <role name>
<grant role statement> ::=
GRANT <role granted> [ { <comma> <role granted> }... ]
TO <grantee> [ { <comma> <grantee> }... ]
[ WITH ADMIN OPTION ]
<role granted> ::= <role name>
<SQL schema manipulation statement> ::=
<drop schema statement>
| <alter table statement>
| <drop table statement>
| <drop view statement>
| <revoke statement>
| <revoke role statement>
| <drop role statement>
| <alter domain statement>
| <drop domain statement>
| <drop null class statement>
| <drop character set statement>
| <drop collation statement>
| <drop translation statement>
| <drop assertion statement>
| <drop trigger statement>
| <drop routine statement>
| <drop data type statement>
| <drop type template statement>
<drop schema statement> ::=
DROP SCHEMA <schema name> <drop behavior>
<drop behavior> ::= CASCADE | RESTRICT
<alter table statement> ::=
ALTER <table type> <table name> <alter table action>
<alter table action> ::=
<add column definition>
| <alter column definition>
| <drop column definition>
| <add supertable clause>
| <drop supertable clause>
| <add table constraint definition>
| <drop table constraint definition>
<add column definition> ::=
ADD [ COLUMN ] <column definition>
<alter column definition> ::=
ALTER [ COLUMN ] <column name> <alter column action>
<alter column action> ::=
<set column default clause>
| <drop column default clause>
| <drop column domain clause>
<set column default clause> ::=
SET <default clause>
<drop column default clause> ::=
DROP DEFAULT
<drop column domain clause> ::=
DROP DOMAIN [ <constraint disposition> [ <constraint name list> ] ]
<constraint disposition> ::=
KEEP COLUMN CONSTRAINT
| DROP COLUMN CONSTRAINT
<constraint name list> ::=
ALL
| <constraint name> [ { <comma> <constraint name> }... ]
<drop column definition> ::=
DROP [ COLUMN ] <column name> <drop behavior>
<add supertable clause> ::=
ADD <supertable clause>
<drop supertable clause> ::=
DROP <supertable clause> <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 type> <table name> <drop behavior>
<drop view statement> ::=
DROP VIEW <table name> <drop behavior>
<revoke statement> ::=
REVOKE [ GRANT OPTION FOR ]
<privileges>
FROM <grantee> [ { <comma> <grantee> }... ] <drop behavior>
<revoke role statement> ::=
REVOKE <role revoked> [ { <comma> <role revoked> }... ]
FROM <grantee> [ { <comma> <grantee> }... ]
<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>
[ <constraint disposition> ]
<drop domain statement> ::=
DROP DOMAIN <domain name> <drop behavior>
[ <constraint disposition> [ <constraint name list> ] ]
<drop null class statement> ::=
DROP NULL CLASS <null class name>
<drop character set statement> ::=
DROP CHARACTER SET <character set name>
<drop collation statement> ::=
DROP COLLATION <collation name>
<drop behavior>
<drop translation statement> ::=
DROP TRANSLATION <translation name>
<drop assertion statement> ::=
DROP ASSERTION <constraint name>
<drop trigger statement> ::= DROP TRIGGER <trigger name>
<drop routine statement> ::=
DROP { PROCEDURE | FUNCTION } <specific routine designator> <drop behavior>
<drop data type statement> ::=
DROP DATA TYPE
<abstract data type name> <drop behavior>
<drop type template statement> ::=
DROP TYPE TEMPLATE <type template name>
<drop behavior>
<SQL data statement> ::=
<open statement>
| <fetch statement>
| <close statement>
| <select statement: single row>
| <new statement>
| <destroy statement>
| <SQL data change statement>
<open statement> ::=
OPEN <cursor name>
[ <open cascade option> ]
<open cascade option> ::=
CASCADE ON
| CASCADE OFF
<fetch statement> ::=
FETCH [ [ <fetch orientation> ] FROM ]
<cursor name> INTO <fetch target list>
<fetch orientation> ::=
NEXT
| PRIOR
| FIRST
| LAST
| { ABSOLUTE | RELATIVE } <simple value specification>
<simple value specification> ::=
<item reference>
| <literal>
<fetch target list> ::=
<target specification> [ { <comma> <target specification> }... ]
<target specification> ::=
<item reference>
| <template parameter name>
<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> }... ]
<new statement> ::=
NEW <item reference>
<destroy statement> ::=
DESTROY <object parameter name>
<object parameter name> ::= <parameter name>
<SQL data change statement> ::=
<delete statement: positioned>
| <delete statement: searched>
| <insert statement>
| <update statement: positioned>
| <update statement: searched>
<delete statement: positioned> ::=
DELETE [ FROM <table name> ]
WHERE CURRENT OF <cursor name>
<delete statement: searched> ::=
DELETE FROM <table reference>
[ WHERE <search condition> ]
<insert statement> ::=
INSERT INTO { <table reference> | CURSOR <cursor name> }
<insert columns and source>
[ <insert point> ]
<insert columns and source> ::=
[ <left paren> <insert column list> <right paren> ]
<query expression>
| DEFAULT VALUES
<insert column list> ::= <column name list>
<insert point> ::=
<relative insert point> ELEMENT <where clause>
<relative insert point> ::=
BEFORE
| AFTER
<update statement: positioned> ::=
UPDATE [ <table reference> ]
SET [ <update type> ] <set clause list>
WHERE CURRENT OF <cursor name>
<update type> ::= ALL | SOME | NONE
<set clause list> ::=
<set clause> [ { <comma> <set clause> }... ]
<set clause> ::=
<update target> <equals operator> <row value designator>
<update target> ::=
<object column>
| <left paren> <object column list> <right paren>
<object column> ::= <column name>
<object column list> ::=
<object column> [ { <comma> <object column> }... ]
<update statement: searched> ::=
UPDATE <table reference>
<update mechanism>
[ WHERE <search condition> ]
<update mechanism> ::=
<update by setting>
| <update by moving>
<update by setting> ::=
SET [ <update type> ] <set clause list>
<update by moving> ::=
MOVE <insert point>
<SQL transaction statement> ::=
<start transaction statement>
| <set transaction statement>
| <set constraints mode statement>
| <test completion statement>
| <savepoint statement>
| <release savepoint statement>
| <commit statement>
| <rollback statement>
<start transaction statement> ::=
START TRANSACTION <transaction mode>
[ { <comma> <transaction mode> }...]
<transaction mode> ::=
<isolation level>
| <transaction access mode>
| <diagnostics size>
<isolation level> ::=
ISOLATION LEVEL <level of isolation>
<level of isolation> ::=
READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
| SERIALIZABLE
<transaction access mode> ::=
READ ONLY
| READ WRITE
<diagnostics size> ::=
DIAGNOSTICS SIZE <number of conditions>
<number of conditions> ::= <simple value specification>
<set transaction statement> ::=
SET [ LOCAL ] TRANSACTION <transaction mode>
[ { <comma> <transaction mode> }... ]
<set constraints mode statement> ::=
SET CONSTRAINTS <constraint name list>
{ DEFERRED | IMMEDIATE }
<test completion statement> ::=
{ TEST | WAIT }
{ ALL | ANY | <async statement identifier list> }
COMPLETION
<async statement identifier list> ::=
<left paren> <async statement identifier>
[ { <comma> <async statement identifier> }... ] <right paren>
<savepoint statement> ::= SAVEPOINT <savepoint specifier>
<savepoint specifier> ::=
<savepoint name>
| <simple target specification>
<savepoint name> ::= <identifier>
<simple target specification> ::=
<item reference>
<release savepoint statement> ::=
RELEASE SAVEPOINT <savepoint specifier>
<commit statement> ::=
COMMIT [ WORK ] [ AND [ NO ] CHAIN ]
<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> ]
correspondence with Tony Gordon)
[ USER <user name> ]
| DEFAULT
<SQL-server name> ::= <simple value specification>
<connection name> ::= <simple value specification>
<user name> ::= <simple value specification>
<set connection statement> ::=
SET CONNECTION <connection object>
<connection object> ::=
DEFAULT
| <connection name>
<disconnect statement> ::=
DISCONNECT <disconnect object>
<disconnect object> ::=
<connection object>
| ALL
| CURRENT
<SQL session statement> ::=
<set session authorization identifier statement>
| <set role statement>
| <set local time zone statement>
<set session authorization identifier statement> ::=
SET SESSION AUTHORIZATION <value specification>
<set role statement> ::=
SET ROLE { <role name> | NONE }
<set local time zone statement> ::=
SET TIME ZONE
<set time zone value>
<set time zone value> ::=
<interval value expression>
| LOCAL
<SQL diagnostics statement> ::=
<get diagnostics statement>
<get diagnostics statement> ::=
GET DIAGNOSTICS <sql diagnostics information>
<sql diagnostics information> ::=
<statement information>
| <condition information>
<statement information> ::=
<statement information item> [ { <comma> <statement information item> }... ]
<statement information item> ::=
<simple target specification>
<equals operator> <statement information item name>
<statement information item name> ::=
NUMBER
| MORE
| COMMAND_FUNCTION
| ROW_COUNT
| TRANSACTIONS_COMMITTED
| TRANSACTIONS_ROLLED_BACK
| TRANSACTION_ACTIVE
<condition information> ::=
EXCEPTION <condition number>
<condition information item>
[ { <comma> <condition information item> }... ]
<condition number> ::= <simple value specification>
<condition information item> ::=
<simple target specification>
<equals operator> <condition information item name>
<condition information item name> ::=
CONDITION_NUMBER
| RETURNED_SQLSTATE
| CLASS_ORIGIN
| SUBCLASS_ORIGIN
| SERVER_NAME
| CONNECTION_NAME
| CONSTRAINT_CATALOG
| CONSTRAINT_SCHEMA
| CONSTRAINT_NAME
| TRIGGER_CATALOG
| TRIGGER_SCHEMA
| TRIGGER_NAME
| CATALOG_NAME
| SCHEMA_NAME
| TABLE_NAME
| COLUMN_NAME
| CURSOR_NAME
| ROUTINE_CATALOG
| ROUTINE_SCHEMA
| ROUTINE_NAME
| SPECIFIC_NAME
| MESSAGE_TEXT
| MESSAGE_LENGTH
| MESSAGE_OCTET_LENGTH
<order by clause> ::=
ORDER BY <sort specification list>
<updatability clause> ::=
FOR
{ READ ONLY |
UPDATE [ OF <column name list> ] }
<temporary abstract data type declaration> ::=
DECLARE TEMPORARY TYPE <abstract data type name>
<abstract data type body>
<temporary table declaration> ::=
DECLARE LOCAL TEMPORARY <table type> <table name>
<table element list>
[ ON COMMIT <table commit action> ROWS ]
<temporary view declaration> ::=
DECLARE TEMPORARY VIEW <table name>
[ <left paren> <view column list> <right paren> ]
AS <query expression>
<scalar subquery> ::= <subquery>
<regular expression> ::=
<regular term>
| <regular expression> <vertical bar> <regular term>
<regular term> ::=
<regular factor>
| <regular term> <regular factor>
<regular factor> ::=
<regular primary>
| <regular primary> <asterisk>
| <regular primary> <plus sign>
<regular primary> ::=
<character specifier>
| <percent>
| <regular character set>
| <left paren> <regular expression> <right paren>
<character specifier> ::=
<non-escaped character>
| <escaped character>
<non-escaped character> ::= !! <EMPHASIS>(See the Syntax Rules)
<escaped character> ::= !! <EMPHASIS>(See the Syntax Rules)
<regular character set> ::=
<underscore>
| <left bracket> <character enumeration>... <right bracket>
| <left bracket> <circumflex> <character enumeration>... <right bracket>
| <left bracket> <colon> <regular character set identifier> <colon> <right bracket>
<character enumeration> ::=
<character specifier>
| <character specifier> <minus sign> <character specifier>
<regular character set identifier> ::= <identifier>
<SQL object identifier> ::=
<SQL provenance> <SQL variant>
<SQL provenance> ::= <arc1> <arc2> <arc3>
<arc1> ::= iso | 1 | iso <left paren> 1 <right paren>
<arc2> ::= standard | 0 | standard <left paren> 0 <right paren>
<arc3> ::= 9075
<SQL variant> ::= <SQL edition> <SQL conformance>
<SQL edition> ::= <1987> | <1989> | <1992>
<1987> ::= 0 | edition1987 <left paren> 0 <right paren>
<1989> ::= <1989 base> <1989 package>
<1989 base> ::= 1 | edition1989 <left paren> 1 <right paren>
<1989 package> ::= <integrity no> | <integrity yes>
<integrity no> ::= 0 | IntegrityNo <left paren> 0 <right paren>
<integrity yes> ::= 1 | IntegrityYes <left paren> 1 <right paren>
<1992> ::= 2 | edition1992 <left paren> 2 <right paren>
<SQL conformance> ::= <low> | <intermediate> | <high>
<low> ::= 0 | Low <left paren> 0 <right paren>
<intermediate> ::= 1 | Intermediate <left paren> 1 <right paren>
<high> ::= 2 | High <left paren> 2 <right paren>
---
