Syntax

[<constraint definition>]

| <special character>

<check expression> ::=

<clear snapshot log statement> ::=

CLEAR SNAPSHOT LOG ON <table name>

<close statement> ::=

CLOSE [<result table name>]

<code spec> ::=

ASCII

| EBCDIC

| BYTE

<column attributes> ::=

[<key or not null spec>]

[<default spec>]

[REFERENCES <table name> [(column name)]]

[UNIQUE]

<column definition> ::=

| <column name> <domain name> [<key or not null spec>]

<column name> ::=

<column spec> ::=

| <table name>.<column name>

| <reference name>.<column name>

| <result table name>.<column name>

<comment> ::=

| <parameter name>

<comment on statement> ::=

COMMENT ON <object spec> IS <comment>

<commit statement> ::=

COMMIT [WORK] [KEEP <lock statement>]

<comp op> ::=

< | > | <> | != | = | <= | >=

| ¬= | ¬< | ¬> for a computer with the code type EBCDIC

| ~= | ~< | ~> for a computer with the code type ASCII

<comparison predicate> ::=

| <expression> <comp op> <subquery>

| <expression list> <equal or not> (<expression list>)

| <expression list> <equal or not> <subquery>

<complement sign> ::=

| ~

| ¬

<connect statement> ::=

CONNECT <user spec>

IDENTIFIED BY <password spec>

[SQLMODE <sqlmode spec>]

[<isolation spec>]

[TIMEOUT <unsigned integer>]

[CACHELIMIT <unsigned integer>]

[TERMCHAR SET <termchar set name>]

<constraint definition> ::=

CHECK <search condition>

| CONSTRAINT <search condition>

| CONSTRAINT <constraint name> CHECK <search condition>

<constraint name> ::=

<conversion function> ::=

NUM ( <expression> )

| CHR ( <expression>[, <unsigned integer> ] )

| HEX ( <expression> )

| CHAR ( <expression>[, <datetimeformat> ] )

<create domain statement> ::=

CREATE DOMAIN <domain name> <data type>

[<default spec>] [<constraint definition>]

<create index statement> ::=

CREATE [UNIQUE] INDEX <index spec>

<create snapshot log statement> ::=

CREATE SNAPSHOT LOG ON <table name>

<create snapshot statement> ::=

CREATE SNAPSHOT <table name> [(<alias name>,...)]

AS <query expression>

<create synonym statement> ::=

CREATE SYNONYM [<owner>.]<synonym name> FOR <table name>

<create table statement> ::=

CREATE TABLE <table name> [(<table description element>,...)]

[<table option>]

[AS <query expression> [<duplicates clause>] ]

| CREATE TABLE <table name> LIKE <source table>

[<table option>]

<create user statement> ::=

CREATE USER <user name> PASSWORD <password>

[<user mode>]

[PERMLIMIT <unsigned integer>]

[TEMPLIMIT <unsigned integer>]

[TIMEOUT <unsigned integer>]

[COSTWARNING <unsigned integer>]

[COSTLIMIT <unsigned integer>]

[CACHELIMIT <unsigned integer>]

[[NOT] EXCLUSIVE]

[AT <serverdb name>]

| CREATE USER <like user> PASSWORD <password>

LIKE <source user>

| CREATE USER <user name> PASSWORD <password>

USERGROUP <usergroup name>

<create usergroup statement> ::=

CREATE USERGROUP <usergroup name>

[<usergroup mode>]

[PERMLIMIT <unsigned integer>]

[TEMPLIMIT <unsigned integer>]

[TIMEOUT <unsigned integer>]

[COSTWARNING <unsigned integer>]

[COSTLIMIT <unsigned integer>]

[CACHELIMIT <unsigned integer>]

[[NOT] EXCLUSIVE]

[AT <serverdb name>]

<create view statement> ::=

CREATE [OR REPLACE] VIEW <table name> [(<alias name>,...)]

AS <query expression>

[WITH CHECK OPTION]

<data type> ::=

CHAR[ACTER] (<unsigned integer>) [<code spec>]

| VARCHAR (<unsigned integer>) [<code spec>]

| LONG [VARCHAR] [<code spec>]

| BOOLEAN

| FIXED (<unsigned integer> [,<unsigned integer>])

| FLOAT (<unsigned integer>)

| DATE

| TIME

| TIMESTAMP

<date function> ::=

ADDDATE ( <date or timestamp expression>, <expression> )

| SUBDATE ( <date or timestamp expression>, <expression> )

| DATEDIFF ( <date or timestamp expression>,

<date or timestamp expression> )

| DAYOFWEEK ( <date or timestamp expression> )

| WEEKOFYEAR ( <date or timestamp expression> )

| DAYOFMONTH ( <date or timestamp expression> )

| DAYOFYEAR ( <date or timestamp expression> )

| MAKEDATE ( <expression>, <expression> )

| DAYNAME ( <date or timestamp expression> )

| MONTHNAME ( <date or timestamp expression> )

<date or timestamp expression> ::=

<datetimeformat> ::=

EUR

| INTERNAL

| ISO

| JIS

| USA

<db procedure> ::=

[<owner>.]<program name>.<procedure name>

<declare cursor statement> ::=

DECLARE <result table name> CURSOR FOR <select statement>

<default expression> ::=

<default predicate> ::=

<column spec> <comp op> DEFAULT

<default spec> ::=

DEFAULT <default value>

<default value> ::=

| NULL

| USER

| USERGROUP

| DATE

| TIME

| TIMESTAMP

| STAMP

| TRUE

| FALSE

<delete rule> ::=

ON DELETE CASCADE

| ON DELETE RESTRICT

| ON DELETE SET DEFAULT

| ON DELETE SET NULL

<delete statement> ::=

DELETE [FROM] <table name> [<reference name>]

[KEY <key spec>,...]

[WHERE <search condition>]

| DELETE [FROM] <table name> [<reference name>]

WHERE CURRENT OF <result table name>

<delimiter token> ::=

( | ) | , | . | + | - | * | /

| < | > | <> | != | = | <= | >=

| ¬= | ¬< | ¬> for a computer with the code type EBCDIC

| ~= | ~< | ~> for a computer with the code type ASCII

<derived column> ::=

<expression> [<result column name>]

| <result column name> = <expression>

<digit> ::=

0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<dir or position> ::=

| <position>

| SAME

<dir spec> ::=

FIRST

| LAST

| NEXT

| PREV

<dir1 spec> ::=

FIRST

| LAST

<dir2 spec> ::=

| PREV

<distinct function> ::=

<set function name> ( DISTINCT <expression> )

<distinct spec> ::=

DISTINCT

| ALL

<domain name> ::=

[<owner>.]<identifier>

<double quotes> ::=

<drop definition> ::=

DROP <column name>,... [<cascade option>]

| DROP (<column name>,...) [<cascade option>]

| DROP CONSTRAINT <constraint name>

| DROP PRIMARY KEY

| DROP REPLICATION

<drop domain statement> ::=

DROP DOMAIN <domain name>

<drop index statement> ::=

DROP INDEX <index name> [ON <table name>]

| DROP INDEX <table name>.<column name>

<drop snapshot statement> ::=

DROP SNAPSHOT <table name>

<drop snapshot log statement> ::=

DROP SNAPSHOT LOG ON <table name>

<drop synonym statement> ::=

DROP SYNONYM [<owner>.]<synonym name>

<drop table statement> ::=

DROP TABLE <table name> [<cascade option>]

<drop user statement> ::=

DROP USER <user name> [<cascade option>]

<drop usergroup statement> ::=

DROP USERGROUP <usergroup name> [<cascade option>]

<drop view statement> ::=

DROP VIEW <table name> [<cascade option>]

<duplicates clause> ::=

REJECT DUPLICATES

| IGNORE DUPLICATES

| UPDATE DUPLICATES

<equal or not> ::=

| <>

| ¬= for a computer with the code type EBCDIC

| ~= for a computer with the code type ASCII

<exists predicate> ::=

EXISTS <subquery>

<exists table statement> ::=

EXISTS TABLE <table name>

<explain statement> ::=

EXPLAIN [(<result table name>)] <query statement>

| EXPLAIN [(<result table name>)] <single select statement>

<exponent> ::=

[<sign>] [ [<digit>] <digit>] <digit>

<expression> ::=

<term>

| <expression> + <term>

| <expression> - <term>

<expression list> ::=

(<expression>,...)

<extended expression> ::=

| DEFAULT

| STAMP

<extended letter> ::=

# | @ | $

<extended value spec> ::=

| DEFAULT

| STAMP

<extraction function> ::=

YEAR ( <date or timestamp expression> )

| MONTH ( <date or timestamp expression> )

| DAY ( <date or timestamp expression> )

| HOUR ( <time or timestamp expression> )

| MINUTE ( <time or timestamp expression> )

| SECOND ( <time or timestamp expression> )

| MICROSECOND ( <expression> )

| TIMESTAMP ( <expression>[, <expression> ] )

| DATE ( <expression> )

| TIME ( <expression> )

<factor> ::=

[<sign>] <primary>

<fetch statement> ::=

FETCH [<dir or position>] [<result table name>]

INTO <parameter spec>,...

<first character> ::=

| <extended letter>

<first password character> ::=

| <extended letter>

| <trigonometric function>

| <digit>

<fixed point literal> ::=

[<sign>] <unsigned integer>[.<unsigned integer>]

| [<sign>] <unsigned integer>.

| [<sign>] .<unsigned integer>

<floating point literal> ::=

| <mantissa>e<exponent>

<from clause> ::=

FROM <table spec>,...

<function spec> ::=

| <string function>

| <date function>

| <time function>

| <extraction function>

| <special function>

| <conversion function>

| <userdefined function>

<grant statement> ::=

GRANT <priv spec>,... TO <grantee>,... [WITH GRANT OPTION]

| GRANT EXECUTE ON <db procedure> TO <grantee>,...

<grant user statement> ::=

GRANT USER <granted users>

[FROM <user name>] TO <user name>

<grant usergroup statement> ::=

GRANT USERGROUP <granted usergroups>

[FROM <user name>] TO <user name>

<granted users> ::=

<user name>,...

| *

<granted usergroups> ::=

<usergroup name>,...

| *

<grantee> ::=

PUBLIC

| <user name>

| <usergroup name>

<group clause> ::=

GROUP BY <expression>,...

<having clause> ::=

HAVING <search condition>

<hex digit> ::=

0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

| A | B | C | D | E | F

| a | b | c | d | e | f

<hex digit seq> ::=

| <hex digit seq> <hex digit> <hex digit>

<hex literal> ::=

x''

| X''

| x'<hex digit seq>'

| X'<hex digit seq>'

<hours> ::=

<identifier> ::=

| <double quotes>.token.<special identifier>.token.<double quotes>

<identifier tail character> ::=

| <extended letter>

<expression> [<outer join indicator>]

| <digit>

| <underscore>

<in predicate> ::=

| <expression> [NOT] IN (<expression>,...)

| <expression list> [NOT] IN <subquery>

| <expression list> [NOT] IN (<expression list>,...)

<index clause> ::=

<column name> [<order spec>]

<index name> ::=

<index name spec> ::=

INDEX <column name>

| INDEXNAME <index name>

<index pos spec> ::=

INDEX <column name> = <value spec>

| INDEXNAME <index name> VALUES (<value spec>,...)

<index spec> ::=

| <named index spec>

<indicator name> ::=

<insert columns and values> ::=

[(<column name>,...)] VALUES (<extended expression>,...)

| [(<column name>,...)] <query expression>

| SET <set insert clause>,...

<insert statement> ::=

INSERT [INTO] <table name> <insert columns and values>

[<duplicates clause>]

<isolation spec> ::=

ISOLATION LEVEL <unsigned integer>

<join predicate> ::=

<expression> [<outer join indicator>]

<key definition> ::=

PRIMARY KEY (<column name>,...)

<key or not null spec> ::=

[PRIMARY] KEY

| NOT NULL [WITH DEFAULT]

<key spec> ::=

<key word> ::=

| <restricted key word>

| <reserved key word>

<language specific character> ::=

Every letter that occurs in a North, Central or South

European language, but is not contained in <letter>

(e.g. the German umlauts, French grave accent, etc.).

<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

| 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

<like expression> ::=

| '<pattern element>...'

<like predicate> ::=

[ESCAPE <expression>]

<like user> ::=

<literal> ::=

| <numeric literal>

<lock option> ::=

WITH LOCK <with lock info>

<lock spec> ::=

| <row lock spec>

| <table lock spec> <row lock spec>

<lock statement> ::=

LOCK [<wait option>] <lock spec> IN SHARE MODE

| LOCK [<wait option>] <lock spec> IN EXCLUSIVE MODE

| LOCK [<wait option>] <lock spec> IN SHARE MODE

<lock spec> IN EXCLUSIVE MODE

| LOCK [<wait option>] <row lock spec> OPTIMISTIC

<mantissa> ::=

<mapchar set name> ::=

<match char> ::=

Every character except

%, *, X'1F', <underscore>, ?, X'1E', (.

<match class> ::=

| <match element>

<match element> ::=

Every character except ).

<match range> ::=

<match set> ::=

| ?

| X'1E'

| <match char>

| ([<complement sign>]<match class>...)

<match string> ::=

| *

| X'1F'

<minutes> ::=

<monitor statement> ::=

MONITOR ON

| MONITOR OFF

<named index spec> ::=

<index name> ON <table name> ( <index clause>,... )

<named query expression> ::=

| <named query expression> UNION [ALL] <query term>

| <named query expression> EXCEPT [ALL] <query term>

<named query primary> ::=

| (<named query expression>)

<named query spec> ::=

SELECT [<distinct spec>]

<result table name> (<select column>,...)

<named query term> ::=

| <named query term> INTERSECT [ALL] <query primary>

<named select statement> ::=

[<order clause>]

[<update clause>]

| <floating point literal>

[FOR REUSE]

<new password> ::=

<new synonym name> ::=

<new table name> ::=

<next stamp statement> ::=

NEXT STAMP [FOR <tablename>] [INTO] <parameter name>

<not restricted key word> ::=

ACCOUNTING ACTIVATE ADABAS ADD_MONTHS AFTER

ANALYZE ANSI

BAD BEGINLOAD BLOCKSIZE BUFFER

CACHELIMIT CACHES CANCEL CLEAR COLD

COMPLETE CONFIG CONSOLE CONSTRAINTS COPY

COSTLIMIT COSTWARNING CURRVAL

DATA DAYS DB2 DBA DBFUNCTION

DBPROC DBPROCEDURE DEGREE DESTPOS DEVICE

DEVSPACE DIAGNOSE DISABLE DIV DOMAINDEF

DSETPASS DUPLICATES DYNAMIC

ENDLOAD ENDPOS EUR EXPLAIN EXPLICIT

FIRSTPOS FNULL FORCE FORMAT FREAD

FREEPAGE FWRITE

GATEWAY GRANTED

HEXTORAW HOLD HOURS

IMPLICIT INDEXNAME INIT INITRANS INSTR

INTERNAL ISO

JIS

KEEP

LABEL LASTPOS LAST_DAY LOAD

MAXTRANS MDECLARE MDELETE MFETCH MICROSECONDS

MINSERT MINUTES MLOCK MOD MONITOR

MONTHS MONTHS_BETWEEN MSELECT MUPDATE

NEW_TIME NEXTVAL NEXT_DAY NOLOG NORMAL

NOSORT NVL

OFF OPTIMISTIC ORACLE OUT OVERWRITE

PAGES PARAM PARSE PARSEID PARTICIPANTS

PASSWORD PATTERN PCTUSED PERMLIMIT POS

PRIV PROC PSM

QUICK

RANGE RAWTOHEX RECONNECT REFRESH REPLICATION

REST RESTART RESTORE REUSE RFETCH

SAME SAPR3 SAVE SAVEPOINT SEARCH

SECONDS SEGMENT SELECTIVITY SEQUENCE SERVERDB

SHUTDOWN SNAPSHOT SOUNDS SOURCEPOS SQLID

SQLMODE STANDARD STARTPOS STAT STATE

STORAGE STORE SUBPAGES SUBTRANS

TABID TABLEDEF TEMP TEMPLIMIT TERMCHAR

TIMEOUT TO_CHAR TO_DATE TO_NUMBER TRANSFILE

TRIGGERDEF

UNLOAD UNLOCK UNTIL USA USERID

VERIFY VERSION VSIZE VTRACE

WAIT

YEARS

<null predicate> ::=

<expression> IS [NOT] NULL

<numeric literal> ::=

<object spec> ::=

COLUMN <table name>.<column name>

| DBPROC <db procedure>

| DOMAIN <domain name>

| INDEX <index name> ON <table name>

| INDEX <table name>.<column name>

| TABLE <table name>

| TRIGGER <trigger name> ON <table name>

| USER <user name>

| VIEW <table name>

| <parameter name>

<old password> ::=

<old synonym name> ::=

<old table name> ::=

<open cursor statement> ::=

OPEN <result table name>

<order clause> ::=

ORDER BY <sort spec>,...

<order spec> ::=

ASC

| DESC

<outer join indicator> ::=

(+)

<owner> ::=

| TEMP

<parameter name> [<indicator name>]

<password> ::=

| <first password character> [<identifier tail character>...]

<password spec> ::=

<pattern element> ::=

| <match set>

<pos1 spec> ::=

| <index pos spec> [KEY <key spec>,...]

| KEY <key spec>,...

<pos2 spec> ::=

[<index pos spec>] KEY <key spec>,...

<position> ::=

POS (<unsigned integer>)

| POS (<parameter spec>)

<predicate> ::=

| <bool predicate>

| <comparison predicate>

| <default predicate>

| <quantified predicate>

| <rowno predicate>

| <sounds predicate>

<prefix> ::=

<primary> ::=

| <column spec>

| <function spec>

| <set function spec>

| (<expression>)

<priv spec> ::=

<table privileges> ON [TABLE] <table name>,...

<privilege> ::=

INSERT

| UPDATE [(<column name>,...)]

| SELECT [(<column name>,...)]

| SELUPD [(<column name>,...)]

| DELETE

| INDEX

| ALTER

| REFERENCES [(<column name>,...)]

<procedure name> ::=

<program name> ::=

<quantified predicate> ::=

<expression> <comp op> <quantifier> (<expression>,...)

| <expression> <comp op> <quantifier> <subquery>

| <expression list> <equal or not>

<quantifier> (<expression list>,...)

| <expression list> <equal or not> <quantifier> <subquery>

<quantifier> ::=

ALL

| <some>

<query expression> ::=

| <query expression> UNION [ALL] <query term>

| <query expression> EXCEPT [ALL] <query term>

<query primary> ::=

| (<query expression>)

<query spec> ::=

SELECT [<distinct spec>] <select column>,...

<query statement> ::=

| <named select statement>

| <select statement>

<query term> ::=

| <query term> INTERSECT [ALL] <query primary>

<reference name> ::=

<referenced column> ::=

<referenced table> ::=

<referencing column> ::=

<referential constraint definition> ::=

FOREIGN KEY [<referential constraint name>]

(<referencing column>,...)

REFERENCES <referenced table> [(<referenced column>,...)]

[<delete rule>]

<referential constraint name> ::=

<refresh statement> ::=

REFRESH SNAPSHOT <table name> [COMPLETE]

<regular token> ::=

| <key word>

| <identifier>

| <parameter name>

<release statement> ::=

COMMIT [WORK] RELEASE

| ROLLBACK [WORK] RELEASE

<rename column statement> ::=

RENAME COLUMN <table name>.<column name> TO <column name>

<rename synonym statement> ::=

RENAME SYNONYM <old synonym name> TO <new synonym name>

<rename table statement> ::=

RENAME TABLE <old table name> TO <new table name>

<rename view statement> ::=

RENAME VIEW <old table name> TO <new table name>

<reserved key word> ::=

ABS ACOS ADDDATE ADDTIME ALL

ALPHA ALTER ANY ASCII ASIN

ATAN ATAN2 AVG

BINARY BIT BOOLEAN BYTE

CEIL CEILING CHAR CHARACTER CHECK

CHR COLUMN CONNECTED CONSTRAINT COS

COSH COT COUNT CURDATE CURRENT

CURTIME

DATABASE DATE DATEDIFF DAY DAYNAME

DAYOFMONTH DAYOFWEEK DAYOFYEAR DBYTE DEC

DECIMAL DECODE DEFAULT DEGREES DELETE

DIGITS DIRECT DISTINCT DOUBLE

EBCDIC ENTRY ENTRYDEF EXCEPT EXISTS

EXP EXPAND

FIRST FIXED FLOAT FLOOR FOR

FROM

GRAPHIC GREATEST GROUP

HAVING HEX HOUR

IFNULL IGNORE INDEX INITCAP INSERT

INT INTEGER INTERSECT INTO

KEY

LAST LCASE LEAST LEFT LENGTH

LFILL LINK LIST LN LOCALSYSDBA

LOG LOG10 LONG LOWER LPAD

LTRIM

MAKEDATE MAKETIME MAPCHAR MAX MICROSECOND

MIN MINUTE MONTH MONTHNAME

NEXT NOROUND NOT NOW NULL

NUM NUMERIC

OBJECT OF ORDER

PACKED PI POWER PREV PRIMARY

RADIANS REAL REFERENCED REJECT REPLACE

RFILL RIGHT ROUND ROWID ROWNO

RPAD RTRIM

SECOND SELECT SELUPD SET SHOW

SIGN SIN SINH SMALLINT SOME

SOUNDEX SQRT STAMP STATISTICS STDDEV

SUBDATE SUBSTR SUBTIME SUM SYSDBA

TABLE TAN TANH TIME TIMEDIFF

TIMESTAMP TIMEZONE TO TOIDENTIFIER TRANSLATE

TRIM TRUNC TRUNCATE

UCASE UNION UPDATE UPPER USER

USERGROUP

VALUE VALUES VARCHAR VARGRAPHIC VARIANCE

WEEKOFYEAR WHERE WITH

YEAR

ZONED

<restricted key word> ::=

ACTION ADD AND AS ASC

AT AUDIT

BEGIN BETWEEN BOTH BUFFERPOOL BY

CASCADE CAST CATALOG CLOSE CLUSTER

COMMENT COMMIT CONCAT CONNECT CREATE

CURRENT_DATE CURRENT_TIME CURSOR

DECLARE DESC DESCRIBE DISCONNECT DOMAIN

DROP

EDITPROC END ESCAPE EXCLUSIVE EXECUTE

EXTRACT

FALSE FETCH FOREIGN

GET GRANT

IDENTIFIED IN INDICATOR INNER IS

ISOLATION

JOIN

LANGUAGE LEADING LEVEL LIKE LOCAL

LOCK

MINUS MODE MODIFY

NATURAL NO NOWAIT NUMBER

OBID ON ONLY OPEN OPTIMIZE

OPTION OR OUTER

PCTFREE PRECISION PRIVILEGES PROCEDURE PUBLIC

RAW READ REFERENCES RELEASE RENAME

RESOURCE RESTRICT REVOKE ROLLBACK ROW

ROWNUM ROWS

SCHEMA SHARE SYNONYM SYSDATE

TABLESPACE TRAILING TRANSACTION TRIGGER TRUE

UID UNIQUE UNKNOWN USAGE USING

VALIDPROC VARCHAR2 VARYING VIEW

WHENEVER WORK WRITE

<result column name> ::=

<result expression> ::=

<result table name> ::=

<revoke statement> ::=

REVOKE <priv spec>,... FROM <grantee>,... [<cascade option>]

| REVOKE EXECUTE ON <db procedure> FROM <grantee>,...

<rollback statement> ::=

ROLLBACK [WORK] [KEEP <lock statement>]

<row lock spec> ::=

<row spec>...

<row spec> ::=

ROW <table name> KEY <key spec>,...

| ROW <table name> CURRENT OF <result table name>

<rowno column> ::=

ROWNO [<result column name>]

| <result column name> = ROWNO

<rowno predicate> ::=

ROWNO < <rowno spec>

| ROWNO <= <rowno spec>

<rowno spec> ::=

| <parameter spec>

<search and result spec> ::=

<search condition> ::=

| <search condition> OR <boolean term>

<search expression> ::=

<seconds> ::=

<select column> ::=

| <derived column>

| <rowno column>

| <stamp column>

<select direct statement: positioned> ::=

SELECT DIRECT <select column>,...

INTO <parameter spec>,...

WHERE CURRENT OF <result table name>

<select direct statement: searched> ::=

SELECT DIRECT <select column>,...

INTO <parameter spec>,...

KEY <key spec>,...

<select ordered format1: positioned> ::=

SELECT <dir1 spec> <select column>,...

INTO <parameter spec>,...

[<index name spec>]

WHERE CURRENT OF <result table name>

| SELECT <dir1 spec> <select column>,...

INTO <parameter spec>,...

[<index pos spec>]

WHERE CURRENT OF <result table name>

<select ordered format1: searched> ::=

SELECT <dir1 spec> <select column>,...

INTO <parameter spec>,...

[<pos1 spec>]

<select ordered format2: positioned> ::=

SELECT <dir2 spec> <select column>,...

INTO <parameter spec>,...

[<index pos spec>]

WHERE CURRENT OF <result table name>

<select ordered format2: searched> ::=

SELECT <dir2 spec> <select column>,...

INTO <parameter spec>,...

<select ordered statement: positioned> ::=

| <select ordered format2: positioned>

<select ordered statement: searched> ::=

| <select ordered format2: searched>

<select statement> ::=

[<order clause>]

[<update clause>]

[FOR REUSE]

<serverdb name> ::=

<servernode name> ::=

<set function name> ::=

COUNT

| MAX

| MIN

| SUM

| AVG

| STDDEV

| VARIANCE

<set function spec> ::=

COUNT (*)

| <distinct function>

| <all function>

<set insert clause> ::=

<set update clause> ::=

| <column name> = <subquery>

<sign> ::=

| -

<simple identifier> ::=

<first character> [<identifier tail character>...]

<single select statement> ::=

SELECT [<distinct spec>] <select column>,...

INTO <parameter spec>,...

FROM <table spec>,...

[<having clause>]

<unsigned integer> [<sort option>]

<some> ::=

SOME

| ANY

<sort option> ::=

ASC

| DESC

<sort spec> ::=

| <expression> [<sort option>]

<sounds predicate> ::=

<expression> [NOT] SOUNDS [LIKE] <expression>

<source table> ::=

<source user> ::=

<special character> ::=

Every character except <digit>, <letter>, <extended letter>,

<hex digit> <character>, <language specific character> and the character

for the line end in a file.

<special function> ::=

VALUE ( <expression>, <expression>,... )

| GREATEST ( <expression>, <expression>,... )

| LEAST ( <expression>, <expression>,... )

| DECODE ( <check expression>,

<search and result spec>,...

[, <default expression> ] )

<special identifier> ::=

<special identifier character>...

<special identifier character> ::=

Any character.

<sql statement> ::=

| <drop table statement>

| <alter table statement>

| <rename table statement>

| <rename column statement>

| <exists table statement>

| <create domain statement>

| <drop domain statement>

| <create synonym statement>

| <drop synonym statement>

| <rename synonym statement>

| <create snapshot statement>

| <drop snapshot statement>

| <create snapshot log statement>

| <drop snapshot log statement>

| <create view statement>

| <drop view statement>

| <rename view statement>

| <create index statement>

| <drop index statement>

| <comment on statement>

| <create user statement>

| <create usergroup statement>

| <drop user statement>

| <drop usergroup statement>

| <alter user statement>

| <alter usergroup statement>

| <grant user statement>

| <grant usergroup statement>

| <alter password statement>

| <refresh statement>

| <clear snapshot log statement>

| <next stamp statement>

| <query statement>

| <open cursor statement>

| <fetch statement>

| <close statement>

| <single select statement>

| <select direct statement: searched>

| <select direct statement: positioned>

| <select ordered statement: searched>

| <select ordered statement: positioned>

| <explain statement>

| <connect statement>

| <commit statement>

| <rollback statement>

| <subtrans statement>

| <lock statement>

| <unlock statement>

| <release statement>

| <update statistics statement>

| <monitor statement>

<sqlmode spec> ::=

ADABAS

| ANSI

| DB2

| ORACLE

<stamp column> ::=

STAMP [<result column name>]

| <result column name> = STAMP

<string function> ::=

| <string spec> & <string spec>

| SUBSTR ( <string spec>, <expression>[, <expression>] )

| LFILL ( <string spec>, <string literal>

| RFILL ( <string spec>, <string literal>

| LPAD ( <string spec>, <expression>, <string literal>

| RPAD ( <string spec>, <expression>, <string literal>

| <constraint definition>

| TRIM ( <string spec>[, <string spec> ] )

| LTRIM ( <string spec>[, <string spec> ] )

| RTRIM ( <string spec>[, <string spec> ] )

| EXPAND ( <string spec>, <unsigned integer> )

| UPPER ( <string spec> )

| LOWER ( <string spec> )

| INITCAP ( <string spec> )

| REPLACE ( <string spec>, <string spec>[, <string spec> ] )

| TRANSLATE ( <string spec>, <string spec>, <string spec> )

| MAPCHAR ( <string spec>[, <unsigned integer> ]

[, <mapchar set name> ] )

| ALPHA ( <string spec>[, <unsigned integer> ] )

| ASCII ( <string spec> )

| EBCDIC ( <string spec> )

| SOUNDEX ( <string spec> )

<string literal> ::=

| '<character>'...

| <hex literal>

<string spec> ::=

<subquery> ::=

(<query expression>)

<subtrans statement> ::=

SUBTRANS BEGIN

| SUBTRANS END

| SUBTRANS ROLLBACK

<synonym name> ::=

<table columns> ::=

| <table name>.*

| <reference name>.*

<table description element> ::=

| <key definition>

| <referential constraint definition>

| <unique definition>

<table expression> ::=