SQL Syntax

The syntax notation used in this SQL syntax description is BNF. The following conventions apply:
SQL Syntax Notation	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.
`<! text !>`	Texts enclosed in angled brackets and exclamation points indicate that the syntactical unit is explained by means of a text. Do not use angled brackets and exclamation points 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 \| ... \| clauses`	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 one after the other and separated by spaces.
`clause...`	The clause can be repeated as often as required. The individual repetitions are to be recorded in direct sequence.
The following overview lists the syntax rules required for the SQL statements in INTERNAL SQL mode, in alphabetical order.
For a detailed description of SQL statements in INTERNAL SQL mode, see the SQL Reference Manual documentation.
For examples of using SQL syntax, see the SQL Tutorial.
Be aware of Resctrictions for SQL Statements.
Significant changes to the syntax as compared with older database versions are described in the section SQL Syntax Changes.
Syntax Syntax
<add_definition> ::=
  ADD <column_definition>,...
| ADD (<column_definition>,...)
| ADD <constraint_definition>
| ADD <key_definition>
| ADD <referential_constraint_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 <user_name new_password>

<alter_table_statement> ::=
  ALTER TABLE <table_name> <add_definition>
| ALTER TABLE <table_name> <alter_definition>
| ALTER TABLE <table_name> <column_change_definition>
| ALTER TABLE <table_name> <drop_definition>
| ALTER TABLE <table_name> <modify_definition>
| ALTER TABLE <table_name> <referential_constraint_definition>
| ALTER TABLE <table_name> <sample_definition>
| ALTER TABLE <table_name> [NOT] CACHE
| ALTER TABLE <table_name> [NOT] NOCACHE

<alter_user_statement> ::=
  ALTER USER <user_name> [<user_mode>]
    [TIMEOUT <unsigned_integer> | TIMEOUT NULL]
    [COSTLIMIT <unsigned_integer> | COSTLIMIT NULL]
    [DEFAULT ROLE ALL [EXCEPT <role_name>
   | DEFAULT ROLE NONE
   | DEFAULT ROLE <role_name>]
    [NOT] EXCLUSIVE]
    [DEFAULTCODE <ascii_or_unicode>]
    [<connect_mode>]

<alter_usergroup_statement> ::=
  ALTER USERGROUP <usergroup_name> [usergroup_mode]
    [TIMEOUT <unsigned_integer> | TIMEOUT NULL]
    [COSTLIMIT <unsigned_integer> | COSTLIMIT NULL]
    [DEFAULT ROLE ALL [EXCEPT <role_name>]
   | DEFAULT ROLE NONE
   | DEFAULT ROLE <role_name>]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ascii_or_unicode>]
    [<connect_mode>]

<argument> ::=
  <identifier>

<argument1> ::=
  <identifier>

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

<ascii_or_unicode> ::=
  ASCII
| UNICODE

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

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

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

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

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

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

<check_expression> ::=
  <expression>

<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> ADD <default_spec>
| COLUMN <column_name> ALTER <default_spec>
| COLUMN <column_name> DEFAULT NULL
| COLUMN <column_name> DROP DEFAULT
| COLUMN <column_name> NOT NULL

<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 computers with ASCII code  !>
| ~< <!  for computers with ASCII code  !>
| ~> <!  for computers 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_mode> ::=
  ENABLE CONNECT
| DISABLE CONNECT

<connect_option> ::=
  SQLMODE <internal_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> ::=
  CHAR(<expression>[,<datetimeformat>])
| CHR(<expression>[,<unsigned_integer>])
| HEX(<expression>)
| HEXTORAW(<expression>)
| INTTORAW(<expression>)
| NUM(<expression>)

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

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

<create_function_statement> ::=
  CREATE [PUBLIC] FUNCTION <dbfunction_name>
    [(<formal_parameter1>,...)] RETURNS <data_type>
    [DETERMINISTIC] AS <routine>

<create_index_statement> ::=
  CREATE [UNIQUE] INDEX <index_name>
    ON <table_name> (<index_spec>)

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

<create_schema_statement> ::=
  CREATE SCHEMA <schema_name_clause> [<schema_element> ...]

<create_sequence_statement> ::=
  CREATE SEQUENCE [<schema_name>.]<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 [<schema_name>.]<synonym_name>
    FOR <table_name>
| CREATE [PUBLIC] SYNONYM [<schema_name>.]<synonym_name>
    FOR <sequence_name>

<create_system_trigger_statement> ::=
  CREATE SYSTEM TRIGGER [<schema_name>.]<trigger_name>
    AFTER RESTART EXECUTE (<routine>)

<create_table_statement> ::=
  CREATE TABLE <table_name>
    (<table_descriptino_element> [,<table_description_element>,...])
    [IGNORE ROLLBACK]
    [<sample_definition>]
    [CACHE] [NOCACHE]
| 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 in the CREATE TABLE statement
    must have the form 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>]
    [COSTLIMIT <unsigned_integer>]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ascii_or_unicode>]
    [<connect_mode>]
| 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>]
    [COSTLIMIT <unsigned_integer>]
    [[NOT] EXCLUSIVE]
    [DEFAULTCODE <ascii_or_unicode>]
    [<connect_mode>]

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

<data_type> ::=
  CHAR[ACTER] [(<unsigned_integer>)] [ASCII | BYTE | UNICODE]
| VARCHAR [(<unsigned_integer>)] [ASCII | BYTE | UNICODE]
| CLOB [ASCII | UNICODE]
| BLOB
| BOOLEAN
| FIXED (<unsigned_integer> [,<unsigned_integer>])
| FLOAT (<unsigned_integer>)
| INT[EGER]
| SMALLINT
| DATE
| TIME
| TIMESTAMP

<date_function> ::=
  ADDDATE    (<date_or_timestamp_expression>,<expression>)
| ADD_MONTHS (<date_or_timestamp_expression>,<expression>)
| DATEDIFF   (<date_or_timestamp_expression>,<date_or_timestamp_expression>)
| DAYNAME    (<date_or_timestamp_expression>)
| DAYOFMONTH (<date_or_timestamp_expression>)
| DAYOFWEEK  (<date_or_timestamp_expression>)
| DAYOFYEAR  (<date_or_timestamp_expression>)
| MAKEDATE   (<expression>,<expression>)
| MONTHNAME  (<date_or_timestamp_expression>)
| SUBDATE    (<date_or_timestamp_expression>,<expression>)
| WEEKOFYEAR (<date_or_timestamp_expression>)

<date_or_timestamp_expression> ::=
  <expression>

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

<dbfunction_call> ::=
  <dbfunction_name>([<expression>,...])

<dbfunction_name> ::=
  [<schema_name>.]<identifier>

<dbproc_name> ::=
  [<schema_name>.]<identifier>

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

<default_expression> ::=
  <expression>

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

<default_spec> ::=
  DEFAULT <literal>
| DEFAULT NULL
| DEFAULT USER
| DEFAULT USERGROUP
| DEFAULT SYSDBA
| DEFAULT DATE
| DEFAULT TIME
| DEFAULT TIMESTAMP
| DEFAULT UTCDATE
| DEFAULT UTCDIFF
| DEFAULT TIMEZONE
| 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>,...] <!  This SQL clause is
          no longer recommended to be used
          and might be removed from future versions.  !>
    [WHERE <search_condition>]
    [IGNORE TRIGGER]
    [NOWAIT]
| DELETE [FROM] <table_name >
    [<reference_name>]
    WHERE CURRENT OF <result_table_name>
    [NOWAIT]

<delimiter_token> ::=
  <vertical_slash>
| , | . | + | - | * | / | < | > | <> | != | = | <= | >=
| ~= <!  for computers with ASCII code  !>
| ~< <!  for computers with ASCII code  !>
| ~> <!  for computers with ASCII code  !>

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

<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> ::=
  [<schema_name>.]<identifier>

<double_quotes> ::=
  "

<drop_dbproc_statement> ::=
  DROP DBPROC[EDURE] <dbproc_name>

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

<drop_domain_statement> ::=
  DROP DOMAIN <domain_name>

<drop_function_statement> ::=
  DROP [PUBLIC] FUNCTION <dbfunction_name>

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

<drop_role_statement> ::=
  DROP ROLE <role_name>

<drop_schema_statement> ::=
  DROP SCHEMA <schema_name> [<cascade_option>]

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

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

<drop_system_trigger_statement> ::=
  DROP SYSTEM TRIGGER [<schema_name>.]<trigger_name>

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

<drop_table_temp> ::=
  DROP TABLE TEMP.<identifier>

<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

<equal_or_not> ::=
  <>
| =
| ~= <!  for computers 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>)
| -(<expression>)

<expression_list> ::=
  (<expression>,...)

<extended_expression> ::=
  <expression>
| DEFAULT
| STAMP

<extended_letter> ::=
  #
| @
| $

<extended_value_spec> ::=
  DEFAULT
| STAMP
| <value_spec>

<extraction_function> ::=
  DATE        (<expression>)
| DAY         (<date_or_timestamp_expression>)
| HOUR        (<time_or_timestamp_expression>)
| MICROSECOND (<expression>)
| MINUTE      (<time_or_timestamp_expression>)
| MONTH       (<date_or_timestamp_expression>)
| SECOND      (<time_or_timestamp_expression>)
| TIME        (<expression>)
| TIMESTAMP   (<expression>[,<expression>])
| YEAR        (<date_or_timestamp_expression>)

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

<formal_parameter1> ::=
  <argument1> <data_type>

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

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

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

<grant_statement> ::=
  GRANT <priv_spec>,... TO <grantee>,... [WITH GRANT OPTION]
| GRANT <schema_priv_spec> TO <grantee>,...
| GRANT EXECUTE ON <dbproc_name> TO <grantee>,...
| GRANT EXECUTE ON <dbfunction_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> ::=
  <user_name>
| <usergroup_name>
| <role_name>
| PUBLIC

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

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

<hours> ::=
  <expression>

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

<identifier_tail_character> ::=
  <digit>
| <letter>
| <extended_letter>
| <language_specific_character>
| <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_column_name> ::=
  <column_name> [ASC|DESC]

<index_name> ::=
  <identifier>

<index_spec> ::=
  <index_column_name>,...
| <dbfunction_name> (<column_name>,...) [ASC|DESC]

<indicator_name> ::=
  <parameter_name>

<initial_select> ::=
  <query_spec>

<inner_transaction_statement> ::=
  INNER TRANSACTION BEGIN
| INNER TRANSACTION COMMIT
| INNER TRANSACTION ROLLBACK

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

<insert_statement> ::=
  INSERT [INTO] <table_name>
    [(<column_name>,...)]
    VALUES (<insert_expression>,...)
    [<duplicates_clause>]
    [IGNORE TRIGGER]
    [NOWAIT]
| INSERT [INTO] <table_name>
    [(<column_name>,...)]
    <query_expression>
    [<duplicates_clause>]
    [IGNORE TRIGGER]
    [NOWAIT]
| INSERT [INTO] <table_name> SET <set_insert_clause>,...
    [duplicates_clause]
    [IGNORE TRIGGER]
    [NOWAIT]
<!  This SQL clause is no longer recommended to be used
    and might be removed from future versions.  !>

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

<internal_oracle> ::=
  INTERNAL
| ORACLE

<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 [OUTER] | RIGHT [OUTER] | FULL [OUTER]] JOIN
    <from_table_spec> <join_spec>

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

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

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

<keyword> ::=
  <not_reserved_keyword>
| <reserved_keyword>

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

<limit_clause> ::=
  LIMIT <row_count>
| LIMIT <offset>,<row_count>

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

<local_variable> ::=
  <variable_name> <routine_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

<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_column_definition> ::=
  <column_name> <data_type> <column_attributes>
| <column_name> <data_type>
| <column_name> <column_attributes>

<modify_definition> ::=
  MODIFY (<modify_column_definition>,...)

<monitor_statement> ::=
  MONITOR INIT

<new_index_name> ::=
  <index_name>

<new_password> ::=
  <password>

<new_schema_name> ::=
  <schema_name>

<new_synonym_name> ::=
  <synonym_name>

<new_table_name> ::=
  <table_name>

<new_user_name> ::=
  <user_name>

<new_usergroup_name> ::=
  <usergroup_name>

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

<not_reserved_keyword> ::=
<!  <table_with_not_reserved_keywords>  !>

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

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

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

<offset> ::=
  <unsigend_integer>
| <parameter_name>

<old_index_name> ::=
  <index_name>

<old_password> ::=
  <password>

<old_synonym_name> ::=
  <synonym_name>

<old_table_name> ::=
  <table_name>

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

<outer_join_indicator> ::=
  (+) <!  This SQL clause is
          no longer recommended to be used
          and might be removed from future versions.  !>


<parameter_name> ::=
  :<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> ::=
  ALTER
| DELETE
| INDEX
| INSERT
| REFERENCES [(<column_name>,...)]
| SELECT [(<column_name>,...)]
| SELUPD [(<column_name>,...)]
| UPDATE [(<column_name>,...)]

<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>] [<top_spec>] <select_column>,... <table_expression>

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

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

<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>
| <keyword>
| <identifier>
| <parameter_name>

<release_savepoint_statement> ::=
  RELEASE SAVEPOINT <sql_savepoint_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_schema_statement> ::=
  RENAME SCHEMA <schema_name> TO <new_schema_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_keyword> ::=
<!  <table_with_reserved_keywords>  !>

<result_column_name> ::=
  <identifier>

<result_expression> ::=
  <expression>

<result_table_name> ::=
  <identifier>

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

<role_name> ::=
  <identifier>

<rollback_statement> ::=
  ROLLBACK [WORK]

<rollback_to_statement> ::=
  ROLLBACK TO [SAVEPOINT] <sql_savepoint_name>

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

<routine_data_type> ::=
  <data_type>
| CURSOR
| PREPAREDSTATEMENT

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

<row_count> ::=
  <unsigned_integer>
| <parameter_name>

<row_spec> ::=
  ROW <table_name> KEY <key_spec>,...
| ROW <table_name> CURRENT OF <result_table_name>

<rowno_column> ::=
  ROWNO [[AS] <result_column_name>]

<rowno_predicate> ::=
  ROWNO <unsigned_integer>
| ROWNO <parameter_spec>
| ROWNO = <unsigned_integer>
| ROWNO = <parameter_spec>

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

<savepoint_statement> ::=
  SAVEPOINT <sql_savepoint_name>

<scalar_subquery> ::=
  <subquery>

<schema_authorization_identifier> ::=
  <identifier>

<schema_element> ::=
  <create_table_statement>
| <create_view_statement>
| <create_dbproc_statement>
| <create_function_statement>
| <create_sequence_statement>

<schema_name> ::=
  <identifier>

<schema_name_clause> ::=
  <schema_name>
| <schema_name> AUTHORIZATION <schema_authorization_identifier>

<schema_priv_spec> ::=
  <schema_privilege> ON <schema_name>,...

<schema_privilege> ::=
  CREATEIN
| DROPIN

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

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

<search_expression> ::=
  <expression>

<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>] [<limit_clause>] [<update_clause>]
    [<lock_option>] [FOR REUSE]

<sequence_name> ::=
  <identifier>

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

<set_function_spec> ::=
  COUNT (*)
| <all_function>
| <distinct_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 CURRENT_SCHEMA = <schema_name>

<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> ::=
  <case_function>
| DECODE (<check_expression>,<search_and_result_spec>,...[,<default_expression>])
| GREATEST (<expression>,<expression>,...)
| LEAST (<expression>,<expression>,...)
| VALUE (<expression>,<expression>,...)

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

<special_identifier_character> ::=
<!  any character  !>

<sql_comment> ::=
  /*<sql_comment_text>*/
| --<sql_comment_text>

<sql_comment_text> ::=
<!  comment text  !>

<sql_savepoint_name> ::=
  <identifier>

<sql_statement> ::=
  <alter_index_statement>
| <alter_password_statement>
| <alter_table_statement>
| <alter_user_statement>
| <alter_usergroup_statement>
| <call_statement>
| <close_statement>
| <comment_on_statement>
| <commit_statement>
| <connect_statement>
| <create_dbproc_statement>
| <create_domain_statement>
| <create_function_statement>
| <create_index_statement>
| <create_role_statement>
| <create_schema_statement>
| <create_sequence_statement>
| <create_synonym_statement>
| <create_system_trigger_statement>
| <create_table_statement>
| <create_trigger_statement>
| <create_user_statemen>t
| <create_usergroup_statement>
| <create_view_statement>
| <delete_statement>
| <drop_dbproc_statement>
| <drop_domain_statement>
| <drop_function_statement>
| <drop_index_statement>
| <drop_role_statement>
| <drop_schema_statement>
| <drop_sequence_statement>
| <drop_synonym_statement>
| <drop_system_trigger_statement>
| <drop_table_statement>
| <drop_trigger_statement>
| <drop_user_statement>
| <drop_usergroup_statement>
| <drop_view_statement>
| <exists_table_statement>
| <explain_statement>
| <fetch_statement>
| <grant_statement>
| <grant_user_statement>
| <grant_usergroup_statement>
| <inner_transaction_statement>
| <insert_statemen>t
| <lock_statement>
| <monitor_statement>
| <next_stamp_statement>
| <query_statement>
| <release_statement>
| <rename_column_statement>
| <rename_index_statement>
| <rename_schema_statement>
| <rename_synonym_statement>
| <rename_table_statement>
| <rename_user_statement>
| <rename_usergroup_statement>
| <rename_view_statement>
| <revoke_statement>
| <rollback_statement>
| <rollback_to_statement>
| <savepoint_statement>
| <set_statement>
| <single_select_statement>
| <subtrans_statement>
| <unlock_statement>
| <update_statement>
| <update_statistics_statement>

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

<statement> ::=
  BEGIN <statement_list> END
| BREAK
| CONTINUE
| CONTINUE EXECUTE
| EXECUTE <expression>
| <if_statement>
| <while_statement>
| <assignment_statement>
| <case_statement>
| OPEN :<local_variable> FOR <select_statement>
| PREPARE <local_variable> FOR <expression>
| RETURN [<expression>]
| STOP (<expression> [,<expression>])
| TRY <statement_list>; CATCH <statement>
| <routine_sql_statement>

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

<string_function> ::=
  ALPHA(<string_spec>[,<unsigned_integer>])
| ASCII(<string_spec>)
| CONCAT(<string_spec>,<string_spec>)
| EXPAND(<string_spec>,<unsigned_integer>)
| GET_OBJECTNAME (<string_literal>)
| GET_SCHEMA(<string_literal>)
| INITCAP(<string_spec>)
| LFILL(<string_spec>,<string_literal>[,<unsigned_integer>])
| LOWER(<string_spec>)
| LPAD(<string_spec>,<expression>,<string_literal>[,<unsigned_integer>])
| LTRIM(<string_spec>[,<string_spec>])
| MAPCHAR(<string_spec>[,<unsigned_integer>][,<mapchar_set_name>])
| REPLACE(<string_spec>,<string_spec>[,<string_spec>])
| RFILL(<string_spec>,<string_literal>[,<unsigned_integer>])
| RPAD(<string_spec>,<expression>,<string_literal>[,<unsigned_integer>])
| RTRIM(<string_spec>[,<string_spec>])
| SOUNDEX(<string_spec>)
| SQLMODE()
| SUBSTR(<string_spec>,<expression>[,<expression>])
| TRANSLATE(<string_spec>,<string_spec>,<string_spec>)
| TRIM(<string_spec>[,<string_spec>])
| UPPER(<string_spec>)
| <string_spec> || <string_spec>
| <string_spec> & <string_spec>

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

<string_spec> ::=
  <expression>

<subquery> ::=
  (<query_expression>)

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

<synonym_name> ::=
  <identifier>

<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> ::=
  [<schema_name>.]<identifier>

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

<time_expression> ::=
  <expression>

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

<time_or_timestamp_expression> ::=
  <expression>

<token> ::=
  <regular_token>
| <delimiter_token>

<top_spec> ::=
  TOP <unsigned_integer>
| TOP <parameter_name>

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

<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>,...] <!  This SQL clause is
          no longer recommended to be used
          and might be removed from future versions.  !>
    [WHERE <search_condition>]
    [NOWAIT]
    [IGNORE TRIGGER]
| UPDATE [OF] <table_name>
    [<reference_name>]
    SET <set_update_clause>,...
    WHERE CURRENT OF <result_table_name>
    [NOWAIT]
| UPDATE [OF] <table_name>
    [<reference_name>]
    (<column_name>,...)
    VALUES (<extended_value_spec>,...)
    [KEY <key_spec>,...]
    [WHERE search_condition]
    [NOWAIT]
    [IGNORE TRIGGER]
<!  This SQL clause is no longer recommended to be used
    and might be removed from future versions.  !>
| UPDATE [OF] <table_name>
    [<reference_name>]
    (<column_name>,...)
    VALUES (<extended_value_spec>,...)
    WHERE CURRENT OF <result_table_name>
    [NOWAIT]
<!  This SQL clause is no longer recommended to be used
    and might be removed from future versions.  !>

<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] [<schema_name>.][<identifier>]* [ESTIMATE [<sample_definition>]]
| UPDATE STAT[ISTICS] AS PER SYSTEM TABLE [ESTIMATE [<sample_definition>]

<user_mode> ::=
  DBA
| RESOURCE
| STANDARD

<user_name> ::=
  <identifier>

<usergroup_mode> ::=
  RESOURCE
| STANDARD

<usergroup_name> ::=
  <identifier>

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

<variable_name> ::=
  <identifier>

<vertical_slash> ::=
  |

<where_clause> ::=
  WHERE <search_condition>

<while_statement> ::=
  WHILE <search_condition> DO <statement>
End of the code.