Syntax List

This documentation uses the BNF syntax notation with the following conventions:

	Explanation
KEYWORDS	Keywords are shown in uppercase letters for the sake of clarity. They can be entered in uppercase or lowercase letters.
<xyz>	Terms in angle brackets are placeholders for syntactical units explained in this document. Do not use angle brackets when entering an SQL statement.
clause ::= rule	Clauses are the building blocks of SQL statements. Rules describe how these building blocks are put together to form more complex clauses and also dictate the notation that is used.
clause1 clause2	The two clauses are written one after the other, separated by at least one blank.
[clause]	Optional clause. This clause can be ignored. Do not use square brackets when entering an SQL statement.
Clause1 | clause2 | ... | clausen	Alternative clauses. You can use exactly one of these clauses.
Clause,...	The clause can be repeated as often as required. The individual repetitions must be written one after the other and separated by a comma and any number of blanks.
Clause...	The clause can be repeated as often as required. The individual repetitions must be written directly one after the other without a separating comma or blank.

The syntax rules are specified in the following form:

Clause ::=
  Rule

If you want an explanation of the syntax rules, you can use the clause link to go to the relevant part of the Reference Manual. As a result, you exit the syntax list itself.

A

<add_definition> ::=
   ADD <column_definition>,...
| ADD (<column_definition>,...)
| ADD <constraint_definition>
| ADD <referential_constraint_definition>
| ADD <key_definition>

<alias_name> ::=
   <identifier>

<all_function> ::=
  <set_function_name> ( [ALL] <expression> )

<alter_definition> ::=
  ALTER CONSTRAINT <constraint_name> CHECK <search_condition>
| ALTER <key_definition>

<alter_index_statement> ::=
   ALTER INDEX <index_name> [ON <table_name>] ENABLE
| ALTER INDEX <index_name> [ON <table_name>] DISABLE
| ALTER INDEX <index_name> [ON <table_name>] INIT USAGE

<alter_password_statement>::=
   ALTER PASSWORD <old_password> TO <new_password>
| ALTER PASSWORD <user_name> <new_password>

<alter_table_statement> ::=
   ALTER TABLE <table_name> <add_definition>
| ALTER TABLE <table_name> <drop_definition>
| ALTER TABLE <table_name> <alter_definition>
| ALTER TABLE <table_name> <column_change_definition>
| ALTER TABLE <table_name> <modify_definition>
| ALTER TABLE <table_name> <referential_constraint_definition>
| ALTER TABLE <table_name> DROP FOREIGN KEY <referential_constraint_name>
| ALTER TABLE <table_name> <sample_definition>

<alter_user_statement> ::=
   ALTER USER <user_name> [<user_mode>]
    [TIMEOUT <unsigned_integer> | TIMEOUT NULL]
    [COSTWARNING <unsigned_integer> | COSTWARNING NULL]
    [COSTLIMIT <unsigned_integer> | COSTLIMIT NULL]
    [DEFAULT ROLE ALL [EXCEPT <role_name>] | DEFAULT ROLE NONE
    | DEFAULT ROLE <role_name> [IDENTIFIED BY <password>]]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ASCII | EBCDIC | UNICODE>]

<alter_usergroup_statement> ::=
   ALTER USERGROUP <usergroup_name> [<usergroup_mode>]
    [TIMEOUT <unsigned_integer> | TIMEOUT NULL]
    [COSTWARNING <unsigned_integer> | COSTWARNING NULL]
    [COSTLIMIT <unsigned_integer> | COSTLIMIT NULL]
    [DEFAULT ROLE ALL [EXCEPT <role_name>] | DEFAULT ROLE NONE
    | DEFAULT ROLE <role_name> [IDENTIFIED BY <password>]]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ASCII | EBCDIC | UNICODE>]

<argument> ::=
  <identifier>

<arithmetic_function> ::=
   TRUNC ( <expression>[, <expression>] )
| ROUND ( <expression>[, <expression>] )
| NOROUND ( <expression> )
| FIXED ( <expression>[, <unsigned_integer> [, <unsigned_integer] ] )
| FLOAT ( <expression>[, <unsigned_integer> ] )
| CEIL ( <expression> )
| FLOOR ( <expression> )
| SIGN ( <expression> )
| ABS ( <expression> )
| POWER ( <expression>, <expression> )
| EXP ( <expression> )
| SQRT ( <expression> )
| LN ( <expression> )
| LOG ( <expression>, <expression> )
| PI
| LENGTH ( <expression> )
| INDEX ( <string_spec>, <string_spec> [,<expression>[, <expression>] ] )

<assignment_statement> ::=
  SET <variable_name> = <expression>

B

<between_predicate> ::=
   <expression> [NOT] BETWEEN <expression> AND <expression>

<bool_predicate> ::=
   <column_spec> [ IS [NOT] <TRUE | FALSE>]

<boolean_factor> ::=
   [NOT] <predicate>
| [NOT] (<search_condition>)

<boolean_term> ::=
   <boolean_factor>
| <boolean_term> AND <boolean_factor>

C

<call_statement> ::=
   CALL <dbproc_name> [(<expression>,...)] [WITH COMMIT]

<cascade_option> ::=
  CASCADE
| RESTRICT

<case_else_clause> ::=
   ELSE <statement>

<case_function> ::=
   <simple_case_function>
| <searched_case_function>

<case_statement> ::=
   <simple_case_statement>
| <searched_case_statement>

<character> ::=
   <digit>
| <letter>
| <extended_letter>
| <hex_digit>
| <language_specific_character>
| <special_character>

<close_statement> ::=
   CLOSE [<result_table_name>]

<column_attributes> ::=
   [<key_or_not_null_spec>] [<default_spec>] [UNIQUE] [<constraint_definition>]
    [REFERENCES <referenced_table> [(<referenced_column>)] [<delete_rule>]]

<column_change_definition> ::=
   COLUMN <column_name> NOT NULL
| COLUMN <column_name> DEFAULT NULL
| COLUMN <column_name> ADD <default_spec>
| COLUMN <column_name> ALTER <default_spec>
| COLUMN <column_name> DROP DEFAULT

<column_definition> ::=
   <column_name> <data_type> [<column_attributes>]
| <column_name> <domain_name> [<column_attributes>]

<column_list> ::=
   <column_name>
| <column_list>, <column_name>

<column_name> ::=
   <identifier>

<column_spec> ::=
   <column_name>
| <table_name>.<column_name>
| <reference_name>.<column_name>
| <result_table_name>.<column_name>

<comment> ::=
   <string_literal>
| <parameter_name>

<comment_on_statement> ::=
   COMMENT ON <object_spec> IS <comment>

<commit_statement> ::=
   COMMIT [WORK]

<comp_op> ::=
  <
| >
| <>
| !=
| =
| <=
| >=
| = | < | > (for machines with EBCDIC Code)
| ~= | ~< | ~> (for machines with ASCII Code)

<comparison_predicate> ::=
   <expression> <comp_op> <expression>
| <expression> <comp_op> <subquery>
| <expression_list> <equal_or_not> (<expression_list>)
| <expression_list> <equal_or_not> <subquery>

<connect_option> ::=
   SQLMODE <INTERNAL | ANSI | DB2 | ORACLE>
| ISOLATION LEVEL <unsigned_integer>
| TIMEOUT <unsigned_integer>

<connect_statement> ::=
   CONNECT <parameter_name> IDENTIFIED BY <parameter_name> [<connect_option>...]
| CONNECT <parameter_name> IDENTIFIED BY <password> [<connect_option>...]
| CONNECT <user_name> IDENTIFIED BY <parameter_name> [<connect_option>...]
| CONNECT <user_name> IDENTIFIED BY <password> [<connect_option>...]

<constraint_definition> ::=
   CHECK <search_condition>
| CONSTRAINT <search_condition>
| CONSTRAINT <constraint_name> CHECK <search_condition>

<constraint_name> ::=
   <identifier>

<conversion_function> ::=
   NUM (<expression>)
| CHR (<expression>[,<unsigned_integer>])
| HEX (<expression>)
| HEXTORAW (<expression>)
| CHAR (<expression>[,<datetimeformat>])

<create_dbproc_statement> ::=
   CREATE DBPROC <procedure_name> [(<formal_parameter>,..)] [RETURNS CURSOR] AS <routine>

<create_domain_statement> ::=
  CREATE DOMAIN <domain_name> <data_type> [<default_spec>] [<constraint_definition>]

<create_index_statement> ::=
   CREATE [UNIQUE] INDEX <index_name> ON <table_name> (<column_name> [ASC | DESC],...)

<create_role_statement> ::=
   CREATE ROLE <role_name> [IDENTIFIED BY <password>]

<create_sequence_statement> ::=
   CREATE SEQUENCE [<owner>.]<sequence_name>
    [INCREMENT BY <integer>]
    [START WITH <integer>]
    [MAXVALUE <integer> | NOMAXVALUE]
    [MINVALUE <integer> | NOMINVALUE]
    [CYCLE | NOCYCLE]
    [CACHE <unsigned_integer> | NOCACHE]
    [ORDER|NOORDER]

<create_synonym_statement> ::=
  CREATE [PUBLIC] SYNONYM [<owner>.]<synonym_name> FOR <table_name>

<create_table_statement> ::=
   CREATE TABLE <table_name> (<column_definition>
    [,<table_description_element>,...]) [IGNORE ROLLBACK] [<sample_definition>]
| CREATE TABLE <table_name> [(<table_description_element>,...)]
    [IGNORE ROLLBACK] [<sample_definition>] AS <query_expression> [<duplicates_clause>]
| CREATE TABLE <table_name> LIKE <table_name> [IGNORE ROLLBACK]

<create_table_temp> :: =
   <create_table_statement> for creating temporary tables,
    that is, the table name table_name in the CREATE TABLE statement
    must have the format TEMP.<identifier>.

<create_trigger_statement> ::=
   CREATE TRIGGER <trigger_name> FOR <table_name> AFTER <trigger_event,..>
    EXECUTE (<routine>) [WHENEVER <search_condition>]

<create_user_statement> ::=
   CREATE USER <user_name> PASSWORD <password>
    [<user_mode>]
    [TIMEOUT <unsigned_integer>]
    [COSTWARNING <unsigned_integer>]
    [COSTLIMIT <unsigned_integer>]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ASCII | EBCDIC | UNICODE>]
| CREATE USER <user_name> PASSWORD <password> LIKE <source_user>
| CREATE USER <user_name> PASSWORD <password> USERGROUP <usergroup_name>

<create_usergroup_statement> ::=
  CREATE USERGROUP <usergroup_name>
    [<usergroup_mode>]
    [TIMEOUT <unsigned_integer>]
    [COSTWARNING <unsigned_integer>]
    [COSTLIMIT <unsigned_integer>]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ASCII | EBCDIC | UNICODE>]

<create_view_statement> ::=
  CREATE [OR REPLACE] VIEW <table_name> [(<alias_name>,...)]
    AS <query_expression> [WITH CHECK OPTION]

D

<data_typ> ::=
  CHAR[ACTER] [(<unsigned_integer>)] [ASCII | BYTE | EBCDIC | UNICODE]
| VARCHAR [(<unsigned_integer>)] [ASCII | BYTE | EBCDIC | UNICODE]| LONG [VARCHAR] [ASCII | BYTE | EBCDIC | UNICODE]
| BOOLEAN
| FIXED (<unsigned_integer> [,<unsigned_integer>])
| FLOAT (<unsigned_integer>)
| INT[EGER]
| SMALLINT
| 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> ::=
  <expression>

<datetimeformat> ::=
  EUR
| INTERNAL
| ISO
| JIS
| USA

<dbproc_name> ::=
  [<owner>.]<procedure_name>

<declare_cursor_statement> ::=
  DECLARE <result_table_name> CURSOR FOR <select_statement>

<default_predicate> ::=
  <column_spec> <comp_op> DEFAULT

<default_spec> ::=
  DEFAULT <literal >
| DEFAULT NULL
| DEFAULT USER
| DEFAULT USERGROUP
| DEFAULT DATE
| DEFAULT TIME
| DEFAULT TIMESTAMP
| DEFAULT TRUE
| DEFAULT FALSE
| DEFAULT TRANSACTION
| DEFAULT STAMP
| DEFAULT SERIAL[(<unsigned_integer>)]

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 machines with EBCDIC code)
| ~= | ~< | ~> (for machines with ASCII code)

<derived_column> ::=
  <expression> [ [AS] <result_column_name >]
| <result_column_name> = <expression>

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

digit_sequence> ::=
  <digit>...

<distinct_function>::=
  <set_function_name> ( DISTINCT <expression > )

<distinct_spec> ::=
  DISTINCT
| ALL

<domain_name> ::=
  [<owner>.]<identifier>

<double_quotes> ::=
  "

<drop_dbproc_statement> ::=
  DROP DBPROC <dbproc_name>

<drop_definition> ::=
  DROP <column_name>,... [<cascade_option >] [RELEASE SPACE]
| DROP (<column_name>,...) [<cascade_option>] [RELEASE SPACE]
| DROP CONSTRAINT <constraint_name>
| DROP PRIMARY KEY

<drop_domain_statement> ::=
  DROP DOMAIN <domain_name>

<drop_index_statement> ::=
  DROP INDEX <index_name> [ON <table_name>]

<drop_role_statement> ::=
  DROP ROLE <role_name>

<drop_sequence_statement> ::=
  DROP SEQUENCE [<owner>.]<sequence_name>

<drop_synonym_statement> ::=
  DROP [PUBLIC] SYNONYM [<owner>.]<synonym_name>

<drop_table_statement> ::=
  DROP TABLE <table_name> [<cascade_option>]

<drop_trigger_statement> ::=
  DROP TRIGGER <trigger_name> OF <table_name>

<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

E

<equal_or_not> ::=
  <>
| =
| Ø = (for machines with EBCDIC code)
| ~= (for machines with ASCII code)

<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> ::=
  <expression>
| DEFAULT
| STAMP

<extended_letter> ::=
  #
| @
| $

<extended_value_spec> ::=
  <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> )

F

<factor> ::=
  [<sign>] <value_spec>
| [<sign>] <column_spec>
| [<sign>] <function_spec>
| [<sign>] <set_function_spec>
| <scalar_subquery>
| <expression>

<fetch_statement> ::=
  FETCH [FIRST | LAST | NEXT | PREV | <position> | SAME] [<result_table_name>]
    INTO <parameter_spec>,...

<final_select> ::=
  <select_statement>

<first_character> ::=
  <letter>
| <extended_letter>
| <language_specific_character>

<first_password_character> ::=
  <letter>
| <extended_letter>
| <language_specific_letter>
| <digit>

<fixed_point_literal> ::=
  [<sign>]<digit_sequence>[.<digit_sequence>]
| [sign]<digit_sequence>.
| [sign].<digit_sequence>

<floating_point_literal> ::=
  <mantissa>E<exponent>
| <mantissa>e<exponent>

<formal_parameter> ::=
  IN <argument> <data_type>
| OUT <argument> <data_type>
| INOUT <argument> <data_type>

<from_clause> ::=
  FROM <from_table_spec>,...

<from_table_spec> ::=
  <table_name> [<reference_name>]
| <result_table_name> [<reference_name>]
| (<query_expression>) [<reference_name>]
| <joined_table>

<function_spec> ::=
  <arithmetic_function>
| <trigonometric_function>
| <string_function>
| <date_function>
| <time_function>
| <extraction_function>
| <special_function>
| <conversion_function>

G

<grant_statement> ::=
  GRANT <priv_spec>,... TO <grantee>,... [WITH GRANT OPTION]
| GRANT EXECUTE ON <dbproc_name>  TO <grantee>,...
| GRANT SELECT ON <sequence_name> TO <grantee>,... [WITH GRANT OPTION]

<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_usergroups> ::=
  <usergroup_name>,...
| *

<granted_users> ::=
  <user_name>,...
| *

<grantee> ::=
  PUBLIC
| <user_name>
| <usergroup_name>
| <role_name>

<group_clause> ::=
  GROUP BY <expression>,...

H

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

<hex_literal> ::=
  x''
| X''
| x'<hex_digit_seq>'
| X'<hex_digit_seq>'

<hours> ::=
  <expression>

I

<identifier> ::=
  <simple_identifier>
| <double quotes><special_identifier><double_quotes>

<identifier_tail_character> ::=
  <letter>
| <extended_letter>
| <language_specific_character>
| <digit>
| <underscore>

<if_statement> ::=
  IF <search_condition> THEN <statement> [ELSE <statement>]

<in_predicate> ::=
  <expression> [NOT] IN <subquery>
| <expression> [NOT] IN <expression_list>
| <expression_list> [NOT] IN <subquery>
| <expression_list> [NOT] IN (<expression_list>,...)

<index_name> ::=
  <identifier>

<indicator_name> ::=
  <parameter_name>

<initial_select> ::=
  <query_spec>

<insert_expression> ::=
  <extended_expression>
| <subquery>

<insert_statement> ::=
  INSERT [INTO] <table_name> [(<column_name>,...)]
    VALUES (<insert_expression>,...) [<duplicates_clause>]
| INSERT [INTO] <table_name> [(<column_name>,...)]
    <query_expression> [<duplicates_clause>]
| INSERT [INTO] <table_name> SET <set_insert_clause>,... [<duplicates_clause>]

<integer> ::=
  [sign]<unsigned_integer>

J

<join_predicate> ::=
  <expression> [<outer_join_indicator>] <comp_op> <expression> [<outer_join_indicator>]

<join_spec> ::=
  ON <search_condition>

<joined_table> ::=
  <from_table_spec> CROSS JOIN <from_table_spec>
| <from_table_spec> [INNER] JOIN <from_table_spec> <join_spec>
| <from_table_spec> [<LEFT|RIGHT|FULL> [OUTER]] JOIN
    <from_table_spec> <join_spec>

K

<key_definition> ::
  PRIMARY KEY (<column_name>,...)

<key_or_not_null_spec> ::=
  [PRIMARY] KEY
| NOT NULL [WITH DEFAULT]

<key_spec> ::=
  <column_name> = <value_spec>

<key_word> ::=
  <not_reserved_key_word>
| <reserved_keyword>

L

<language_specific_character> ::=
  <every letter that occurs in a Northern, Central, or Southern European language
  and is not included in the <letter> list>
| <for UNICODE-enabled databases: every character that is not included in the ASCII code list from 0 to 127>

<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> ::=
  <expression>
| '<pattern_element>...'

<like_predicate> ::=
  <expression> [NOT] LIKE <like_expression> [ESCAPE <expression>]

<literal> ::=
  <string_literal>
| <numeric_literal>

<local_variable> ::=
  <variable_name> <data_type>

<local_variable_list> ::=
  <local_variable>
| <local_variable_list>;<local_variable>

<local_variables> ::=
  VAR <local_variable_list>;

<lock_option> ::=
  WITH LOCK [(IGNORE)|(NOWAIT)] [EXCLUSIVE | OPTIMISTIC] [ISOLATION LEVEL <unsigned_integer>]

<lock_spec> ::=
  TABLE <table_name>,...
| <row_spec>...
| TABLE <table_name>,... <row_spec>...

<lock_statement> ::=
  LOCK [(WAIT)|(NOWAIT)] <lock_spec> IN SHARE MODE
| LOCK [(WAIT)|(NOWAIT)] <lock_spec> IN EXCLUSIVE MODE
| LOCK [(WAIT)|(NOWAIT)] <row_spec>... OPTIMISTIC
| LOCK [(WAIT)|(NOWAIT)] <lock_spec> IN SHARE MODE <lock_spec> IN EXCLUSIVE MODE

M

<mantissa> ::=
  <fixed_point_literal>

<mapchar_set_name> ::=
  <identifier>

<match_char> ::=
  Every character except
    %
  | X'1F'
  | <underscore>
  | X'1E'

<match_set> ::=
   <underscore>
| X'1E'
| <match_char>

<match_string> ::=
  %
| X'1F'

<minutes> ::=
  <expression>

<modify_definition> ::=
  MODIFY (<column_name> [<data_type>] [<column_attributes>]...)

<monitor_statement> ::=
  MONITOR INIT

N

<named_query_expression> ::=
  <named_query_term>
| <named_query_expression> UNION [ALL] <query_term>
| <named_query_expression> EXCEPT [ALL] <query_term>

<named_query_primary> ::=
  <named_query_spec>
| (<named_query_expression>)

<named_query_spec> ::=
  SELECT [<distinct_spec>] <result_table_name> (<select_column>,...) <table_expression>

<named_query_term> ::=
  <named_query_primary>
| <named_query_term> INTERSECT [ALL] <query_primary>

<named_select_statement> ::=
  <named_query_expression> [<order_clause>] [<update_clause>] [<lock_option>] [FOR REUSE]

<new_index_name> ::=
  <index_name>

<new_table_name> ::=
  <table_name>

<next_stamp_statement> ::=
  NEXT STAMP [INTO] <parameter_name>

<not_reserved_key_word> ::=

A CTION	ACTIVATE	ADABAS	ADD	ADDRESS
ADD_MONTHS	AFTER	ANALYZE	AND	ANSI
APPEND	ARCHIVE	AS	ASC	AT
AUTO	AUTOSAVE
B ACKUP_PAGES	BAD	BEFORE	BEGIN	BEGINLOAD
BEGINPROC	BETWEEN	BLOCK	BLOCKSIZE	BOTH
BREAK	BUFFER	BUFFERPOOL	BWHIERACHY	BY
C ACHE	CACHELIMIT	CACHES	CALL	CANCEL
CASCADE	CAST	CATALOG	CATCH	CHECKPOINT
CLEAR	CLOSE	CLUSTER	COMMENT	COMMIT
COMPLETE	COMPUTE	CONFIG	CONNECT	CONSTRAINTS
CONTAINER	CONTINUE	COSTLIMIT	COSTWARNING	CREATE
CURRENT_DATE	CURRENT_SCHEMA	CURRENT_TIME	CURRENT_TIMESTAMP	CURRVAL
CURSOR	CYCLE
D ATA	DAYS	DB2	DBA	DBFUNCTION
DBPROC	DBPROCEDURE	DB_ABOVE_LIMIT	DB_BELOW_LIMIT	DECLARE
DEFAULTCODE	DEGREE	DESC	DESCRIBE	DEVICE
DIAGNOSE	DIMENSION	DISABLE	DIV	DO
DOMAIN	DROP	DSETPASS	DUPLICATES	DYNAMIC
E DITPROC	ELSE	ENABLE	END	ENDLOAD
ENDPROC	ERROR	ESCAPE	ESTIMATE	EUR
EVENT	EXCLUSIVE	EXECUTE	EXPLAIN	EXPLICIT
EXTRACT
F ACT	FALSE	FETCH	FILE	FLUSH
FORCE	FOREIGN	FORMAT	FREEPAGE	FVERSION
G ET	GRANT
H IGH	HOLD	HOURS
I DENTIFIED	IF	IMPLICIT	IN	INCREMENT
INDEXNAME	INDICATOR	INFO	INIT	INITRANS
INOUT	INPROC	INSTANCE	INSTR	IS
ISO	ISOLATION
J AVA	JIS
K EEP
L ABEL	LANGUAGE	LAST_DAY	LEADING	LEVEL
LIKE	LOAD	LOCAL	LOCK	LOGFULL
LOGWRITER	LOG_ABOVE_LIMIT	LOW
M AXTRANS	MAXVALUE	MEDIANAME	MEDIUM	MICROSECONDS
MIGRATE	MINUS	MINUTES	MINVALUE	MODE
MODIFY	MONITOR	MONTHS	MONTHS_BETWEEN
N AME	NEW	NEW_TIME	NEXTVAL	NEXT_DAY
NLSSORT	NLS_DATE_FORMAT	NLS_DATE_LANGUAGE	NLS_LANGUAGE	NLS_SORT
NOCACHE	NOCYCLE	NOLOG	NOMAXVALUE	NOMINVALUE
NONE	NOORDER	NOREWIND	NORMAL	NOSORT
NOWAIT	NUMBER	NVL
O BID	OFF	ONLY	OPEN	OPTIMISTIC
OPTIMIZE	OPTION	OR	ORACLE	OUT
OUTER	OVERWRITE
P ACKAGE	PAGE	PAGES	PARAM	PARSE
PARSEID	PASSWORD	PCTFREE	PCTUSED	PERCENT
PING	PIPE	POS	PRECISION	PREPARE
PRIV	PRIVILEGES	PROC	PROCEDURE	PSM
PUBLIC
Q UICK
R ANGE	RAW	RAWTOHEX	READ	RECURSIVE
REFERENCES	REGISTER	RELEASE	REMOTE	REMOVE
RENAME	RESOURCE	RESTART	RESTORE	RESTRICT
RESUME	RETURN	RETURNS	REUSE	REVOKE
ROLE	ROLLBACK	ROW	ROWNUM	ROWS
S AME	SAMPLE	SAPR3	SAVE	SAVEPOINT
SCHEMA	SECONDS	SEGMENT	SELECTIVITY	SEQUENCE
SERVERDB	SESSION	SHARE	SHUTDOWN	SIMILAR
SOUNDS	SQLID	SQLMODE	STANDARD	STANDBY
START	STARTPOS	STAT	STATE	STOP
STORAGE	SUBPAGES	SUBTRANS	SUSPEND	SWITCH
SYNCHRONIZE	SYNONYM	SYSDATE
T ABID	TABLESPACE	TAKEOVER	TAPE	TEMP
THEN	TIMEOUT	TOPIC	TO_CHAR	TO_DATE
TO_NUMBER	TRACE	TRAILING	TRIGGER	TRUE
TRY	TYPE
U NIQUE	UNKNOWN	UNLOAD	UNLOCK	UNTIL
UNUSED	USA	USAGE	USERID
V ALIDPROC	VARCHAR2	VARYING	VERIFY	VERSION
VIEW	VOLUME	VSIZE	VTRACE
W AIT	WHENEVER	WHILE	WORK	WRITE
WRITER
Y EARS

 

<null_predicate> ::=
  <expression> IS [NOT] NULL

<numeric_literal> ::=
  <fixed_point_literal >
| <floating_point_literal>

O

<object_spec> ::=
  COLUMN <table_name>.<column_name>
| DBPROC[EDURE] <dbproc_name>
| DOMAIN <domain_name>
| FOREIGN KEY <table_name>.<referential_constraint_name>
| INDEX <index_name> ON <table_name>
| SEQUENCE <sequence_name>
| [PUBLIC] SYNONYM <synonym_name>
| TABLE <table_name>
| TRIGGER <trigger_name>.<table_name>
| USER <user_name>
| USERGROUP <usergroup_name>
| <parameter_name>

<old_index_name> ::=
  <index_name>

<old_table_name> ::=
  <table_name>

<open_cursor_statement> ::=
  OPEN <result_table_name>

<order_clause> ::=
  ORDER BY <sort_spec>,...

<outer_join_inidicator> ::=
  (+)

<owner> ::=
  <user_name>
| <usergroup_name>
| TEMP

P

<parameter_name> ::=
  :<identifier>
| :<identfier>(<identifier>)
| :<identfier>(.<identifier>.)

<parameter_spec> ::=
  <parameter_name> [<indicator_name>]

<password> ::=
  <identifier>
| <first_password_character>[<identifier_tail_character>...]

<pattern_element> ::=
  <match_string>
| <match_set>

<position> ::=
  POS (<unsigned_integer>)
| POS (<parameter_spec>)
| ABSOLUTE <integer>
| ABSOLUTE <parameter_spec>
| RELATIVE <integer>
| RELATIVE <parameter_spec>

<predicate> ::=
  <between_predicate>
| <bool_predicate>
| <comparison_predicate>
| <default_predicate>
| <exists_predicate>
| <in_predicate>
| <join_predicate>
| <like_predicate>
| <null_predicate>
| <quantified_predicate>
| <rowno_predicate>
| <sound_predicate>

<priv_spec> ::=
  ALL [PRIV[ILEGES]] ON [TABLE] <table_name>,...
| <privilege>,...  ON [TABLE] <table_name>,...
| <role_name>

<privilege> ::=
  INSERT
| UPDATE [(<column_name>,...)]
| SELECT [(<column_name>,...)]
| SELUPD [(<column_name>,...)]
| DELETE
| INDEX
| ALTER
| REFERENCES [(<column_name>,...)]

<procedure_name> ::=
  <identifier>

Q

<quantified_predicate> ::=
  <expression> <comp_op> <quantifier> <expression_list>
| <expression> <comp_op> <quantifier> <subquery>
| <expression_list> <equal_or_not> <quantifier> (<expression_list>,...)
| <expression_list> <equal_or_not> <quantifier> <subquery>

<quantifier> ::=
  ALL
| SOME
| ANY

<query_expression> ::=
  <query_term>
| <query_expression> UNION [ALL] <query_term>
| <query_expression> EXCEPT [ALL] <query_term>

<query_primary> ::=
  <query_spec>
| (<query_expression>)

<query_spec> ::=
  SELECT [<distinct_spec>] <select_column>,... <table_expression>

<query_statement> ::=
  <declare_cursor_statement>
| <recursive_declare_cursor_statement>
| <named_select_statement>
| <select_statement>

<query_term> ::=
  <query_primary>
| <query_term> INTERSECT [ALL] <query_primary>

R

<recursive_declare_cursor_statement> ::=
  DECLARE <result_table_name> CURSOR FOR WITH RECURSIVE <reference_name>     (<alias_name>,...) AS (<initial_select> UNION ALL <recursive_select>) <final_select>

<recursive_select> ::=
  <query_spec>

<reference_name> ::=
  <identifier>

<referenced_column> ::=
  <column_name>

<referenced_table> ::=
  <table_name>

<referencing_column> ::=
  <column_name>

<referential_constraint_definition> ::=
  FOREIGN KEY [<referential_constraint_name>] (<referencing_column>,...)
    REFERENCES <referenced_table> [(<referenced_column>,...)] [<delete_rule>]

<referential_constraint_name> ::=
  <identifier>

<regular_token> ::=
  <literal>
| <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_index_statement> ::=
  RENAME INDEX <old_index_name> [ON <table_name>] TO <new_index_name>

<rename_synonym_statement> ::=
  RENAME [PUBLIC] SYNONYM <old_synonym_name> TO <new_synonym_name>

<rename_table_statement> ::=
  RENAME TABLE <old_table_name> TO <new_table_name>

<rename_user_statement> ::=
  RENAME USER <user_name> TO <new_user_name>

<rename_usergroup_statement> ::=
  RENAME USERGROUP <usergroup_name> TO <new_usergroup_name>

<rename_view_statement> ::=
  RENAME VIEW <old_table_name> TO <new_table_name>

<reserved_key_word> ::=

A BS	ABSOLUTE	ACOS	ADDDATE	ADDTIME
ALL	ALPHA	ALTER	ANY	ASCII
ASIN	ATAN	ATAN2	AVG
B INARY	BIT	BOOLEAN	BYTE
C ASE	CEIL	CEILING	CHAR	CHARACTER
CHECK	CHR	COLUMN	CONCAT	CONSTRAINT
COS	COSH	COT	COUNT	CROSS
CURDATE	CURRENT	CURTIME
D ATABASE	DATE	DATEDIFF	DAY	DAYNAME
DAYOFMONTH	DAYOFWEEK	DAYOFYEAR	DBYTE	DEC
DECIMAL	DECODE	DEFAULT	DEGREES	DELETE
DIGITS	DISTINCT	DOUBLE
E BCDIC	EXCEPT	EXISTS	EXP	EXPAND
F IRST	FIXED	FLOAT	FLOOR	FOR
FROM	FULL
G ET_OBJECTNAME	GET_OWNER	GRAPHIC	GREATEST	GROUP
H AVING	HEX	HEXTORAW	HOUR
I FNULL	IGNORE	INDEX	INITCAP	INNER
INSERT	INT	INTEGER	INTERNAL	INTERSECT
INTO
J OIN
K EY
L AST	LCASE	LEAST	LEFT	LENGTH
LFILL	LINK	LIST	LN	LOCATE
LOG	LOG10	LONG	LONGFILE	LOWER
LPAD	LTRIM
M AKEDATE	MAKETIME	MAPCHAR	MAX	MBCS
MICROSECOND	MIN	MINUTE	MOD	MONTH
MONTHNAME
N ATURAL	NCHAR	NEXT	NO	NOROUND
NOT	NOW	NULL	NUM	NUMERIC
O BJECT	OF	ON	ORDER
P ACKED	PI	POWER	PREV	PRIMARY
R ADIANS	REAL	REJECT	RELATIVE	REPLACE
RFILL	RIGHT	ROUND	ROWID	ROWNO
RPAD	RTRIM
S ECOND	SELECT	SELUPD	SERIAL	SET
SHOW	SIGN	SIN	SINH	SMALLINT
SOME	SOUNDEX	SPACE	SQRT	STAMP
STATISTICS	STDDEV	SUBDATE	SUBSTR	SUBSTRING
SUBTIME	SUM	SYSDBA
T ABLE	TAN	TANH	TIME	TIMEDIFF
TIMESTAMP	TIMEZONE	TO	TOIDENTIFIER	TRANSACTION
TRANSLATE	TRIM	TRUNC	TRUNCATE
U CASE	UID	UNICODE	UNION	UPDATE
UPPER	USER	USERGROUP	USING	UTCDATE
UTCDIFF
V ALUE	VALUES	VARCHAR	VARGRAPHIC	VARIANCE
W EEK	WEEKOFYEAR	WHEN	WHERE	WITH
Y EAR
Z ONED

<result_column_name> ::=
  <identifier>

<result_table_name> ::=
  <identifier>

<revoke_statement> ::=
  REVOKE <priv_spec>,... FROM <grantee>,... [<cascade_option>]
| REVOKE EXECUTE ON <dbproc_name> FROM <grantee>,...
| REVOKE SELECT ON <sequence_name> FROM <grantee>,... [<cascade_option>]

<role_name> ::=
  <identifier>

<rollback_statement> ::=
  ROLLBACK [WORK]

<routine> ::=
  [<local_variables>] <statement_list>;

<routine_sql_statement> ::=
  <call_statement>
| <close_statement>
| <create_table_temp>
| <declare_cursor_statement>
| <delete_statement>
| <fetch_statement>
| <insert_statement>
| <lock_statement>
| <select_statement>
| <named_select_statement>
| <single_select_statement>
| <subtrans_statement>
| <update_statement>

<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 < <unsigned_integer>
| ROWNO < <parameter_spec>
| ROWNO <= <unsigned_integer>
| ROWNO <= <parameter_spec>

S

<sample_definition> ::=
  SAMPLE <unsigned_integer>  ROWS
| SAMPLE <unsigned_integer> PERCENT

<scalar_subquery> ::=
  <subquery>

<search_and_result_spec> ::=
  <search_expression>, <result_expression>

<search_condition> ::=
  <boolean_term>
| <search_condition> OR <boolean_term>

<searched_case_function> ::=
  WHEN <search_condition> THEN <result_expression>
    [...]
  [ELSE <default_expression>]
END

<searched_case_statement> ::=
  CASE
    <searched_case_when_clause>…
    [<case_else_clause>]
  END [CASE]

<searched_case_when_clause> ::=
  WHEN <search_condition> THEN <statement>

<seconds> ::=
  <expression>

<select_column> ::=
  <table_columns>
| <derived_column>
| <rowno_column>
| <stamp_column>

<select_statement> ::=
  <query_expression> [<order_clause>] [<update_clause>] [<lock_option>]
    [FOR REUSE]

<sequence_name> ::=
  <identifier>

<set_function_name> ::=
  COUNT
| MAX
| MIN
| SUM
| AVG
| STDDEV
| VARIANCE

<set_function_spec> ::=
  COUNT (*)
| <distinct_function>
| <all_function>

<set_insert_clause> ::=
  <column_name> = <extended_value_spec>

<set_statement> ::=
  SET ROLE ALL [EXCEPT <role_name>]
| SET ROLE NONE
| SET ROLE <role_name> [IDENTIFIED BY <password>]
| SET ISOLATION LEVEL <unsigned_integer>

<set_update_clause> ::=
  <column_name> = <extended_expression >
| <column_name>,... = (<extended_expression>,...)
| (<column_name>,...) = (<extended_expression>,...)
| <column_name> = <subquery>
| (<column_name>,...) = <subquery>

<sign> ::=
  +
| -

<simple_case_function> ::=
  CASE <check_expression>,
    WHEN <search_expression> THEN <result_expression>
      [...]
    [ELSE <default_expression>]
  END

<simple_case_statement> ::=
  CASE <expression>
    <simple_case_when_clause>...
    [<case_else_clause>]
  END [CASE]

<simple_case_when_clause> ::=
  WHEN <literal>[, ...] THEN <statement>

<simple_identifier> ::=
  <first_character>[<identifier_tail_character>...]

<single_select_statement> ::=
  SELECT [<distinct_spec>] <select_column>,... INTO <parameter_spec>,...
    FROM <from_table_spec>,...[<where_clause>] [<group_clause>]
    [<having_clause>] [<lock_option>]

<sort_spec> ::=
  <unsigned_integer> [ASC | DESC]
| <expression> [ASC | DESC]

<sound_predicate> ::=
  <expression> [NOT] SOUNDS [LIKE] <expression>

<source_user> ::=
  <user_name>

<special_character> ::=
  every character except
    <digit>
  | <letter>
  | <extended_letter>
  | <hex_digit>
  | <language_specific_character >
  | <character for the end of a line in a file>

<special_function> ::=
  VALUE (<expression>,<expression>,...)
| GREATEST (<expression>,<expression>,...)
| LEAST (<expression>,<expression>,...)
| DECODE (<check_expression>,<search_and_result_spec>,...[,<default_expression>])
| case_function

<special_identifier> ::=
  <special_identifier_character>...

<special_identifier_character> ::=
  Any character

<sql_comment> ::=
  /*<comment text >*/
| --<comment text >

<stamp_column> ::=
  STAMP [<result_column_name>]
| <result_column_name> = STAMP

<statement> ::=
  BEGIN <statement_list> END
| BREAK
| CONTINUE
| CONTINUE EXECUTION
| <if_statement>
| <while_statement>
| <assignment_statement>
| <case_statement>
| RETURN
| STOP (<expression> [,<expression>] )
| TRY <statement_list>; CATCH <statement>
| <routine_sql_statement>

<statement_list> ::=
  <statement>
| <statement_list> ; <statement>

<string_function> ::=
  <string_spec> || <string_spec>
| <string_spec> & <string_spec>
| SUBSTR (<string_spec>,<expression>[,<expression>])
| LFILL (<string_spec>,<string_literal>[,<unsigned_integer>])
| RFILL (<string_spec>,<string_literal>[,<unsigned_integer>])
| LPAD (<string_spec>,<expression>,<string_literal>[,<unsigned_integer>])
| RPAD (<string_spec>,<expression>,<string_literal>[,<unsigned_integer>])
| 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>)
| GET_OBJECTNAME (<string_literal)
| GET_OWNER (<string_literal>)

<string_literal> ::=
  ''
| '<character>...'
| <hex_literal>

<string_spec> ::=
  <expression >

<subquery> ::=
  (<query_expression>)

<subtrans_statement> ::=
  SUBTRANS BEGIN
| SUBTRANS END
| SUBTRANS ROLLBACK

<synonym_name> ::=
  <identifier>

T

<table_columns> ::=
  *
| <table_name>.*
| <reference_name>.*

<table_description_element> ::=
  <column_definition>
| <constraint_definition>
| <referential_constraint_definition>
| <key_definition>
| <unique_definition>

<table_expression> ::=
  <from_clause> [<where_clause>] [<group_clause>] [<having_clause>]

<table_name> ::=
  [<owner>.]<identifier>

<term> ::=
  <factor>
| <term> * <factor>
| <term> / <factor>
| <term> DIV <factor>
| <term> MOD <factor>

time_expression> ::=
  <expression>

<time_or_timestamp_expresion> ::=
  <expression>

<time_function> ::=
  ADDTIME (<time_or_timestamp_expression>, <time_expression> )
| SUBTIME ( <time_or_timestamp_expression>, <time_expression> )
| TIMEDIFF ( <time_or_timestamp_expression>, <time_or_timestamp_expression> )
| MAKETIME (<hours>, <minutes>, <seconds> )

<trigger_event> ::
  INSERT
| UPDATE [(<column_list>)]
| DELETE

<trigger_name> ::=
  <identifier>

<trigonometric_function> ::=
  COS ( <expression> )
| SIN ( <expression> )
| TAN ( <expression> )
| COT ( <expression> )
| COSH ( <expression> )
| SINH ( <expression> )
| TANH ( <expression> )
| ACOS ( <expression> )
| ASIN ( <expression> )
| ATAN ( <expression> )
| ATAN2 ( <expression>, <expression> )
| RADIANS ( <expression> )
| DEGREES ( <expression> )

U

<underscore> ::=
  _

<unique_definition> ::=
  [CONSTRAINT <index_name>] UNIQUE (<column_name>,...)

<unlock_statement> ::=
  UNLOCK <row_spec>... IN SHARE MODE
| UNLOCK <row_spec>... IN EXCLUSIVE MODE
| UNLOCK <row_spec>... IN SHARE MODE <row_spec>... IN EXCLUSIVE MODE
| UNLOCK <row_spec>... OPTIMISTIC

<unsigned_integer> ::=
  <numeric_literal>

<update_clause > ::=
  FOR UPDATE [OF <column_name>,...] [NOWAIT]

<update_statement> ::=
  UPDATE [OF] <table_name> [<reference_name>] SET <set_update_clause>,...
    [KEY <key_spec>,...] [WHERE <search_condition>]
| UPDATE [OF] <table_name> [<reference_name>] (<column_name>,...)
    VALUES (<extended_value_spec>,...) [KEY <key_spec>,...]
    [WHERE <search_condition>]
| UPDATE [OF] <table_name> [<reference_name>] SET <set_update_clause>,...
    WHERE CURRENT OF <result_table_name>
| UPDATE [OF] <table_name> [<reference_name>] (<column_name>,...)
    VALUES (<extended_value_spec>,...) WHERE CURRENT OF <result_table_name>

<update_statistics_statement> ::=
  UPDATE STAT[ISTICS] COLUMN <table_name>.<column_name>
    [ESTIMATE [<sample_definition>]]
| UPDATE STAT[ISTICS] COLUMN (<column_name>,...) FOR <table_name>
    [ESTIMATE [<sample_definition>]]
| UPDATE STAT[ISTICS] COLUMN (*) FOR <table_name>
    [ESTIMATE [<sample_definition>]]
| UPDATE STAT[ISTICS] <table_name> [ESTIMATE [<sample_definition>]]
| UPDATE STAT[ISTICS] [<owner>.][<identifier>]* [ESTIMATE [<sample_definition>]]

<user_mode> ::=
  DBA
| RESOURCE
| STANDARD

<user_name> ::=
  <identifier>

<usergroup_mode> ::=
  RESOURCE
| STANDARD

<usergroup_name> ::=
  <identifier>

V

<value_spec > ::=
  <literal>
| <parameter_spec>
| NULL
| USER
| USERGROUP
| SYSDBA
| UID
| [<owner >.]<sequence_name>.NEXTVAL
| [<owner>.]<sequence_name>.CURRVAL
| <table_name>.CURRVAL
| DATE
| TIME
| TIMESTAMP
| UTCDATE
| TIMEZONE
| UTCDIFF
| TRUE
| FALSE
| TRANSACTION

<variable_name> ::=
  <identifier>

<where_clause> ::=
  WHERE <search_condition>

<while_statement> ::=
  WHILE <search_condition> DO <statement>