A Comprehensive Website for Oracle Learning

{INCREMENT BY integer | {MAXVALUE integer | NOMAXVALUE} | {MINVALUE integer | NOMINVALUE} | {CYCLE | NOCYCLE} | {CACHE integer | NOCACHE} | {ORDER | NOORDER}]�;

|| Top ||

ALTER SESSION

ALTER SESSION {archive_log_clause | checkpoint_clause | check_datafiles_clause | DUMP ACTIVE SESSION HISTORY [MINUTES integer ] distributed_recov_clauses FLUSH {SHARED_POOL | BUFFER_CACHE} end_session_clauses SWITCH LOGFILE {SUSPEND | RESUME} | quiesce_clauses | shutdown_dispatcher_clause | REGISTER | SET alter_system_set_clause� | RESET alter_system_reset_clause� };

|| Top ||

ALTER TABLE

ALTER TABLE [schema.]table

[enable_diable_clause | {ENABLE | DIABLE} {TABLE LOCK | ALL TRIGGERS}]�;

|| Top ||

ALTER TABLESPACE

ALTER TABLESPACE tablespace

{DEFAULT [table_compression] storage_clause | MINIMUM EXTENT integer [K|M] | RESIZE size_clause | COALESCE | RENAME TO new_tablespace_name | {BEGIN | END} BACKUP | datafile_tempfile_clauses | tablespace_logging_clauses | tablespace_group_clauses | tablespace_state_clauses | autoextend_clause | flashback_mode_clause | tablespace_retention_clause};

|| Top ||

ALTER TRIGGER

ALTER TRIGGER [schema.]trigger

{ENABLE | DISABLE | RENAME TO new_name | COMPILE [DEBUG] [compiler_parameters_clause]� [REUSE SETTING]};

|| Top ||

ALTER TYPE

ALTER TYPE [schema.]type

{compile_type_clause | replace_type_clause | {alter_method_spec | alter_attribute_definition | alter_collection_clauses | [NOT] {INSTANTIABLE | FINAL}} [dependent_handling_clause]};

|| Top ||

ALTER USER

ALTER USER {user {IDENTIFIED {BY password [REPLACE old_password] | EXTERNALLY | GLOBALLY AS �external_name�} | DEFAULT TABLESPACE tablespace | TEMPORARY TABLESPACE {tablespace | tablespace_group_name} | QUOTA {integer [ K | M ] | UNLIMITED } ON tablespace � | PROFILE profile | DEFAULT ROLE {role, � | ALL [ EXCEPT role, � | NONE } | PASSWORD EXPIRE | ACCOUNT { LOCK | UNLOCK}} � proxy_clause;

|| Top ||

ALTER VIEW

ALTER VIEW [schema.]view

{ADD out_of_line_constraint | MODIFY CONSTRAINT constraint {RELY | NORELY} | DROP {CONSTRAINT constraint | PRIMARY KEY | UNIQUE (column, �) | COMPILE};

|| Top ||

ANALYZE

ANALYZE {TABLE [schema.]table

[PARTITION (partition) | SUBPARTITION (subpartition)] | INDEX [schema.]index [PARTITION (partition) | SUBPARTITION (subpartition)] | CLUSTER [schema.]cluster}{validation_clauses | LIST CHAINED ROWS [into_clause] | DELETE [SYSTEM] STATISTICS | compute_statistics_clause | estimate_statistics_clause};

|| Top ||

ASSOCIATE STATISTICS WITH

ASSOCIATE STATISTICS WITH {column_association | function_association};

|| Top ||

AUDIT

AUDIT {sql_statement_clause | schema_object_clause} [BY{SESSION | ACCESS}] [WHENEVER [NOT] SUCCESSFUL];

|| Top ||

CALL

CALL {routine_clause | object_access_expression}[INTO :host_variable [[INDICATOR] :indicator_variable]];

|| Top ||

COMMENT ON

COMMENT ON {TABLE [schema.]{table | view} | COLUMN [schema.]{table. | view. | materialized_view.}column | OPERATOR [schema.] operator | INDEXTYPE [schema.]indextype | MATERIALIZED VIEW materialized_view} IS �text�;

|| Top ||

COMMIT

COMMIT [WORK] [COMMENT �text� | FORCE �text� [,integer]];

|| Top ||

CREATE CLUSTER

CREATE CLUSTER [schema.]cluster

(column datatype [SORT], �) [{physical_attributes_clause | SIZE size_clause | TABLESPACE tablespace | {INDEX | [SINGLE TABLE] HASHKEYS integer [HASH is expr]}}]�

[parallel_clause] [NOROWDEPENDENCIES | ROWDEPENDENCIES] [CACHE | NOCACHE];

|| Top ||

CREATE CONTEXT

CREATE OR REPLACE CONTEXT namespace

USING [schema.]package [INITIALIZED {EXTERNALLY | GLOBALLY} | ACCESSED GLOBALLY];

|| Top ||

CREATE CONTROLFILE

CREATE CONTROLFILE [REUSE] [SET] DATABASE database [logfile_clause] {RESETLOGS | NORESETLOGS} [DATAFILE file_specification, file_specification, �] [{MAXLOGFILES integer | MAXLOGMEMBERS integer | MAXLOGHISTORY integer | MAXDATAFILES integer | {ARCHIVELOG | NOARCHIVELOG} | FORCE LOGGING}�] [character_set_clause];

|| Top ||

CREATE DATABASE

CREATE DATABASE [database]

{USER SYS IDENTIFIED BY password | USER SYSTEM IDENTIFIED BY password | CONTROLFILE REUSE | MAXDATAFILES integer | MAXINSTANCES integer | CHARACTER SET charset | NATIONAL CHARACTER SET charset | SET DEFAULT {BIGFILE | SMALLFILE} TABLESPACE | database_logging_clauses | tablespace_clauses | set_time_zone_clause}�;

|| Top ||

CREATE DATABASE LINK

CREATE [SHARED] [PUBLIC] DATABASE LINK dblink

[CONNECT TO {CURRENT_USER | user IDENTIFIED BY password [dblink_authentication]} | dblink_authentication ] [USING �connect_string�];

|| Top ||

CREATE DIMENSION

CREATE DIMENSION [schema.]dimension level_clause � {hierarchy_clause | attribute_clause | extended_attribute_clause}�;

|| Top ||

CREATE DIRECTORY

CREATE [OR REPLACE] DIRECTORY directory AS �path_name�;

|| Top ||

CREATE DISKGROUP

CREATE DISKGROUP diskgroup_name

[{HIGH | NORMAL | EXTERNAL} REDUNDANCY]

[FAILGROUP failgroup_name] DISK qualified_disk_clause, �

[FAILGROUP failgroup_name] DISK qualified_disk_clause, �;

|| Top ||

CREATE FUNCTION

CREATE [OR REPLACE] FUNCTION [schema.]function

[(argument [IN | OUT | IN OUT] [NOCOPY] datatype, argument�)]

RETURN datatype [{invoker_rights_clause | DETERMINISTIC | parallel_enable_clause}�

{{AGGREGATE | PIPELINED} USING [schema.]implementation_type | [PIPELINED] {IS | AS} {pl/sql_function_body | call_spec}};

|| Top ||

CREATE INDEX

CREATE [UNIQUE | BITMAP] INDEX [schema.]index

ON {cluster_index_clause | table_index_clause | bitmap_join_index_clause};

|| Top ||

CREATE INDEXTYPE

CREATE [OR REPLACE] INDEXTYPE [schema.]indextype

FOR [[schema.]operator (parameter_type,�),] � using_type_clause;

|| Top ||

CREATE JAVA

CREATE [OR REPLACE] [AND {RESOLVE | COMPILE}][NOFORCE]

JAVA {{SOURCE | RESOURCE} NAMED [schema.]primary_name | CLASS [SCHEMA schema]} [invoker_rights_clause][RESOLVER ((match_string[,]{schema_name | -})[((match_string[,]{schema_name | -})]�]

{USING {BFILE (directory_object_name, server_file_name) | {CLOB | BLOB | BFILE} subquery | �key_for_BLOB�} | AS source_text};

|| Top ||

CREATE LIBRARY

CREATE [OR REPLACE] LIBRARY [schema.]library

{IS | AS} �filename� [AGENT �agent_dblink�];

|| Top ||

CREATE MATERIALIZED VIEW

CREATE MATERIALIZED VIEW [schema.]materialized_view

[OF [schema.]object_type] [(scoped_table_ref_constraint)]{ON PREBUILT TABLE [{WITH | WITHOUT} REDUCED PRECISION] | physical_properties materialized_view_props} [USING INDEX [physical_attributes_clause | TABLESPACE tablespace]� | USING NO INDEX] [create_mv_refresh] [FOR UPDATE] [{DISABLE | ENABLE} QUERY REWRITE] AS subquery;

|| Top ||

CREATE MATERIALIZED VIEW LOG

CREATE MATERIALIZED VIEW LOG ON [schema.]table

[physical_attributes_clause | TABLESPACE tablespace | logging_clause | {CACHE | NOCACHE}]�][parallel_clause][table_partitioning_clauses][WITH {OBJECT ID |PRIMARY KEY | ROWID | SEQUENCE | (column [, column]�)}�

[new_values_clause]];

|| Top ||

CREATE OPERATOR

CREATE [OR REPLACE] OPERATOR [schema.]operator binding_clause;

|| Top ||

CREATE OUTLINE

CREATE [OR REPLACE] [PUBLIC | PRIVATE] OUTLINE [outline] [FROM [PUBLIC | PRIVATE] source_outline][FOR CATEGORY category] [ON statement];

|| Top ||

CREATE PACKAGE

CREATE [OR REPLACE] PACKAGE [schema.]package

[invoker_rights_clause]

{IS | AS} pl/sql_package_spec;

|| Top ||

CREATE PACKAGE BODY

CREATE [OR REPLACE] PACKAGE BODY [schema.]package

{IS | AS} pl/sql_package_body;

|| Top ||

CREATE PFILE

CREATE PFILE [= �pfile_name�] FROM SPFILE [= �spfile_name�];

|| Top ||

CREATE PROCEDURE

CREATE [OR REPLACE] PROCEDURE [schema.]procedure

[(argument [IN | OUT | IN OUT] [NOCOPY] datatype [, argument �] �)]

[invoker_rights_clause] {IS | AS} {pl/sql_subprogram_body | call_spec};

|| Top ||

CREATE PROFILE

CREATE PROFILE profile LIMIT

{resource_parameters | password_parameters}�;

|| Top ||

CREATE ROLE

CREATE ROLE role [NOT IDENTIFIED | IDENTIFIED {BY password | USING [schema.]package | EXTERNALLY | GLOBALLY}];

|| Top ||

CREATE ROLLBACK SEGMENT

CREATE [PUBLIC] ROLLBACK SEGMENT rollback_segment [{TABLESPACE tablespace | storage_clause}�];

|| Top ||

CREATE SCHEMA AUTHORIZATION

CREATE SCHEMA AUTHORIZATION schema {create_table_statement | create_view_statement | grant_statement}�;

|| Top ||

CREATE SEQUENCE

CREATE SEQUENCE [schema.]sequence

[INCREMENT BY integer | START WITH integer | {MAXVALUE integer | NOMAXVALUE} | {MINVALUE integer | NOMINVALUE} | {CYCLE | NOCYCL} | {ORDER | NOORDER}]�;

|| Top ||

CREATE SPFILE

CREATE SPFILE [=�spfile_name�] FROM PFILE [=�pfile_name�;

|| Top ||

CREATE SYNONYM

CREATE [OR REPLACE] [PUBLIC] SYNONYM [schema.]synonym

FOR [schema.]object[@dblink];

|| Top ||

CREATE TABLE

CREATE [GLOBAL TEMPORARY] TABLE [schema.]table

[(relational_properties)]

[ON COMMIT {DELETE | PRESERVE} ROWS] [physical_properties] [table_properties];

|| Top ||

CREATE TABLESPACE

CREATE [BIGFILE | SMALLFILE] {permanent_tablespace_clause | temporary_tablespace_clause | undo_tablespace_clause};

|| Top ||

CREATE TRIGGER

CREATE [OR REPLACE] TRIGGER [schema.]trigger

{BEFORE | AFTER | INSTEAD OF} {dml_event_clause | {ddl_event [OR ddl_event]�} ON {[schema.]SCHEMA | DATABASE}}[WHEN (condition)]

{pl/sql_block | call_procedure_statement};

|| Top ||

CREATE TYPE

{create_incomplete_type | create_object_type | create_varray_type | create_nested_table_type}

|| Top ||

CREATE TYPE BODY

CREATE [OR REPLACE] TYPE BODY [schema.]type_name

{IS | AS} {subprogram_declaration | map_order_func_declaration}

[;{subprogram_declaration | map_order_func_declaration}]�

END;

|| Top ||

CREATE USER

CREATE USER user IDENTIFIED {BY password | EXTERNALLY | GLOBALLY AS �external_name�}[DEFAULT TABLESPACE tablespace | TEMPORARY TABLESPACE {tablespace | tablespace_group} | QUOTA {integer [K|M] | UNLIMITED } ON tablespace� | PROFILE profile | PASSWORD EXPIRE | ACCOUNT {LOCK | UNLOCK}]�;

|| Top ||

CREATE VIEW

CREATE [OR REPLACE] [[NO] FORCE] VIEW [schema.]view

[(alias[inline_constraint]�| out_of_line_constraint [inline_constraint]�]�) | object_view_clause | XMLType_view_clause] AS subquery [subquery_restriction_clause];

|| Top ||

DELETE

DELETE [hint] [FROM] {dml_table_expression_clause | ONLY (dml_table_expression_clause)}[t-alias][where_clause][returning_clause];

|| Top ||

DISASSOCIATE STATISTICS

DISASSOCIATE STATISTICS FROM {COLUMNS [schema.]table.column, [[schema.]table.column]� | FUNCTIONS [schema.]function, [[schema.]function]� | PACKAGES [schema.]package, [[schema.]package]� | TYPES [schema.]type, [[schema.]type]� | INDEXES [schema.]index, [[schema.]index]� | INDEXTYPES [schema.]indextype, [[schema.]indextype]� } [FORCE];

|| Top ||

DROP CLUSTER

DROP CLUSTER [schema.]cluster

[INCLUDING TABLES [CASCADE CONSTRAINTS]];

|| Top ||

DROP CONTEXT

DROP CONTEXT namespace;

|| Top ||

DROP DATABASE

DROP DATABASE;

|| Top ||

DROP DATABASE LINK

DROP [PUBLIC] DATABASE LINK dblink;

|| Top ||

DROP DIMENSION

DROP DIMENSION [schema.]dimension;

|| Top ||

DROP DIRECTORY

DROP DIRECTORY directory_name;

|| Top ||

DROP DISKGROUP

DROP DISKGROUP diskgroup_name

[{INCLUDING | EXCLUDING} CONTENTS];

|| Top ||

DROP FUNCTION

DROP FUNCTION [schema.]function_name;

|| Top ||

DROP INDEX

DROP INDEX [schema.]index [FORCE];

|| Top ||

DROP INDEXTYPE

DROP INDEXTYPE [schema.]indextype [FORCE];

|| Top ||

DROP JAVA

DROP JAVA {SOURCE | CLASS | RESOURCE} [schema.]object_name;

|| Top ||

DROP LIBRARY

DROP LIBRARY library_name;

|| Top ||

DROP MATERIALIZED VIEW

DROP MATERIALIZED VIEW [schema.]materialized_view

[PRESERVE TABLE];

|| Top ||

DROP MATERIALIZED VIEW LOG

DROP MATERIALIZED VIEW LOG ON [schema.]table;

|| Top ||

DROP OPERATOR

DROP OPERATOR [schema.]operator [FORCE];

|| Top ||

DROP OUTLINE

DROP OUTLINE outline;

|| Top ||

DROP PACKAGE

DROP PACKAGE [BODY] [schema.]package;

|| Top ||

DROP PROCEDURE

DROP PROCEDURE [schema.]procedure;

|| Top ||

DROP PROFILE

DROP PROFILE profile [CASCADE];

|| Top ||

DROP ROLE

DROP ROLE role;

|| Top ||

DROP ROLLBACK SEGMENT

DROP ROLLBACK SEGMENT rollback_segment;

|| Top ||

DROP SEQUENCE

DROP SEQUENCE [schema.]sequence_name;

|| Top ||

DROP SYNONYM

DROP [PUBLIC] SYNONYM [schema.]synonym [FORCE];

|| Top ||

DROP TABLESPACE

DROP TABLESPACE tablespace_name

[INCLUDING CONTENTS [ AND DATAFILES] [CASCADE CONSTRAINTS]];

|| Top ||

DROP TRIGGER

DROP TRIGGER [schema.]trigger_name;

|| Top ||

DROP TYPE

DROP TYPE [schema.]type_name [FORCE | VALIDATE];

|| Top ||

DROP TYPE BODY

DROP TYPE BODY [schema.]type_name;

|| Top ||

DROP USER

DROP USER user [CASCADE];

|| Top ||

DROP VIEW

DROP VIEW [schema.]view [CASCADE CONSTRAINTS];

|| Top ||

EXPLAIN PLAN

[SET STATEMENT_ID = �text�]

[INTO [schema.]table[@dblink]] FOR sql_statement;

|| Top ||

FLASHBACK DATABASE

FLASHBACK [STANDBY] DATABASE [database_name]

{TO {SCN | TIMESTAMP} expr | TO BEFORE {SCN | TIMESTAMP} expr};

|| Top ||

FLASHBACK TABLE

FLASHBACK TABLE [schema.]table, [[schema.]table], � TO {{SCN TIMESTAMP} expr [{ENABLE | DISABLE} TRIGGERS ] | BEFORE DROP [RENAME TO table] };

|| Top ||

GRANT

GRANT {grant_system_privileges | grant_object_privileges};

|| Top ||

INSERT

INSERT [hint] {single_table_insert | multi_table_insert};

|| Top ||

LOCK TABLE

LOCK TABLE [schema.]{table | view}

[{PARTITION (partition) | SUBPARTITION (subpartition)} | @dblink]�

IN lockmode MODE [NOWAIT];

|| Top ||

MERGE

MERGE [hint] INTO [schema.]table [t_alias]

USING [schema.]{table | view | subquery} [t_alias] ON (condition)

[merge_update_clause][merge_insert_clause];

|| Top ||

NOAUDIT

{sql_statement_clause� | schema_object_clause�}

[WHENEVER [NOT] SUCCESSFUL];

|| Top ||

PURGE

PURGE {{TABLE table | INDEX index} | {RECYCLEBIN | DBA_RECYCLEBIN} | TABLESPACE tablespace [USER user]};

|| Top ||

RENAME

RENAME old_name TO new_name;

|| Top ||

REVOKE

REVOKE {revoke_system_privileges | revoke_object_privileges};

|| Top ||

ROLLBACK

ROLLBACK [WORK] [TO [SAVEPOINT] savepoint | FORCE �text�];

|| Top ||

SAVEPOINT

SAVEPOINT savepoint;

|| Top ||

SELECT

Subquery [for_update_clause];

|| Top ||

SET CONSTRAINT[S]

SET {CONSTRAINT | CONSTRAINTS}

{constraint,� | ALL} {IMMEDIATE | DEFERRED};

|| Top ||

SET ROLE

SET ROLE {role [IDENTIFIED BY password]}� | ALL [EXCEPT role,�] | NONE;

|| Top ||

SET TRANSACTION

SET TRANSACTION {{READ {ONLY | WRITE} | ISOLATION LEVEL {SERIALIZABLE | READ COMMITTED} | USE ROLLBACK SEGMENT rollback_segment} [NAME �text�] | NAME �text�};

|| Top ||

TRUNCATE

TRUNCATE {TABLE [schema.]table [{PRESERVE | PURGE} MATERIALIZED VIEW LOG] | CLUSTER [schema.]cluster} [{DROP | REUSE} STORAGE];

|| Top ||

UPDATE

UPDATE [hint] {dml_table_expression_clause | ONLY (dml_table_expression_clause)} [t_alias] update_set_clause [where_clause][returning_clause];

|| Top ||

[activite_standby_db_clause]

ACTIVATE [PHYSICAL | LOGICAL] STANDBY DATABASE [SKIP [STANDBY LOGFILE]]

|| Top ||

[add_binding_clause]

ADD BINDING (parameter_type,�) RETURN (return_type) [implementation_clause] using_function_clause

|| Top ||

[add_column_clause]

ADD (column datatype [DEFAULT expr][{inline_constraint� | inline_ref_constraint�}),� [column_properties]

|| Top ||

[add_disk_clause]

ADD [[FAILGROUP failgroup_name] DISK qualified_disk_clause,�]�

|| Top ||

[add_hash_index_partition]

ADD PARTITION [partition_name][TABLESPACE tablespace_name][parallel_clause]

|| Top ||

[add_hash_partition_clause]

ADD PARTITION [partition] partitioning_storage_clause [update_index_clauses] [parallel_clause]

|| Top ||

[add_hash_subpartition]

ADD subpartition_spec [update_index_clauses][parallel_clause]

|| Top ||

[add_list_partition_clause]

ADD PARTITION [partition] list_values_clause [table_partition_description] [update_index_clauses]

|| Top ||

[add_list_subpartition]

ADD subpartition_spec [update_index_clauses]

|| Top ||

[add_logfile_clauses]

ADD [STANDBY] LOGFILE {[INSTANCE �instance_name� | THREAD integer]

[[GROUP integer] redo_log_file_spec],� | [MEMBER �filename� [REUSE]],� TO logfile_descriptor,�}

|| Top ||

[add_overflow_clause]

ADD OVERFLOW [segment_attributes_clause] [(PARTITION [segment_attributes_clause], PARTITION�]�)]

|| Top ||

[add_range_partition_clause]

ADD PARTITION [partition] range_values_clause [table_partition_description] [update_index_clauses]

|| Top ||

[add_table_partition]

{add_range_partition_clause | add_hash_partition_clause | add_list_parition_clause}

|| Top ||

[alias_file_name]

+diskgroup [(template_name)] /alias_name

|| Top ||

[allocate_extent_clause]

ALLOCATE EXTENT ({SIZE size_clause | DATAFILE �filename� | INSTANCE integer}�)

|| Top ||

[alter_attribute_definition]

{ADD | MODIFY} ATTRIBUTE ({attribute [datatype]},�) | DROP ATTRIBUTE (attribute,�)

|| Top ||

[alter_collection_clauses]

MODIFY {LIMIT integer | ELEMENT TYPE datatype}

|| Top ||

[alter_datafile_clause]

DATAFILE {�filename� | filenumber},� {ONLINE | OFFLINE [FOR DROP] | RESIZE size_clause | autoextend_clause | END BACKUP}

|| Top ||

[alter_external_table_clauses]

{add_column_clause | modify_column_clauses | drop_column_clause | parallel_clause | external_data_properties | REJECT LIMIT {integer | UNLIMITED} | PROJECT COLUMN {ALL | REFERENCED}}�

|| Top ||

[alter_index_partitioning]

{modify_index_default_attrs | add_hash_index_partition | modify_index_partition | rename_index_partition | drop_index_partition | split_index_partition | coalesce_index_partition | modify_index_subpartition}

|| Top ||

[alter_iot_clauses]

{index_org_table_clause | alter_overflow_clause | alter_mapping_table_clauses | COALESCE}

|| Top ||

[alter_mapping_table_clauses]

MAPPING TABLE {UPDATE BLOCK REFERENCES | allocate_extent_clause | deallocate_unused_clause}

|| Top ||

[alter_method_spec]

[{ADD | DROP}{map_order_function_spec | subprogram_spec}]�

|| Top ||

[alter_mv_refresh]

REFRESH {{FAST | COMPLETE | FORCE} | ON {DEMAND | COMMIT}| {START WITH | NEXT} date | WITH PRIMARY KEY | USING {DEFAULT MASTER ROLLBACK SEGMENT | MASTER ROLLBACK SEGMENT rollback_segment} | USING {ENFORCED | TRUSTED} CONSTRAINTS}

|| Top ||

[alter_overflow_clause]

{OVERFLOW {allocate_extent_clause | deallocate_unused_clause}� | add_overflow_clause}

|| Top ||

[alter_session_set_clause]

SET <parameter_name = parameter_value> �

|| Top ||

[alter_system_reset_clause]

parameter_name [SCOPE = {MEMORY | SPFILE | BOTH}] SID = �sid�

|| Top ||

[alter_system_set_clause]

parameter_name = parameter_value, � [COMMENT �text�] [DEFERRED] [SCOPE = {MEMORY | SPFILE | BOTH}] [SID = {�sid� | *}]

|| Top ||

[alter_table_partitioning]

{ modify_table_default_attrs | set_subpartition_template | modify_table_partition | modify_table_subpartition | move_table_partition | move_table_subpartition | add_table_partition | coalesce_table_partition | drop_table_partition | drop_table_subpartition | rename_partition_subpart | truncate_partition_subpart | split_table_partition | split_table_subpartition | merge_table_partitions | merge_table_subpartitions | exchange_partition_subpart}

|| Top ||

[alter_table_properties]

{physical_attributes_clause | logging_clause | table_compression | supplemental_table_logging | allocate_extent_clause | deallocate_unused_clause | shrink_clause | {CACHE | NOCACHE} | upgrade_table_clause | records_per_block_clause | parallel_clause | row_movement_clause}� | RENAME TO new_table_name} [alter_iot_clauses]

|| Top ||

[alter_tempfile_clause]

TEMPFILE {�filename�,�}{RESIZE size_clause | autoextend_clause | DROP [INCLUDING DATAFILES] | ONLINE | OFFLINE}

|| Top ||

[alter_varray_col_properties]

MODIFY VARRY varray_item (modify_LOB_parameters)

|| Top ||

[analytic_clause]

[query_partition_clause][order_by_clause [windowing_clause]]

|| Top ||

[archive_log_clause]

ARCHIVE LOG [INSTANCE �instance_name� | THREAD integer]

{{SEQUENCE integer | CHANGE integer | CURRENT [NOSWITCH] | GROUP integer | LOGFILE �filename� [USING BACKUP CONTROLFILE] | NEXT | ALL | START} [TO �location�] | STOP}

|| Top ||

[array_DML_clause]

[WITH | WITHOUT] ARRAY DML [(schema.]type, [schema].varray_type),�]

|| Top ||

[attribute_clause]

ATTRIBUTE level DETERMINES (dependent_column,�)

|| Top ||

[auditing_by_clause]

BY proxy,� | user,�

|| Top ||

[auditing_on_clause]

ON [schema.]object | DIRECTORY directory_name | DEFAULT

|| Top ||

[autoextend_clause]

AUTOEXTEND OFF | ON [NEXT size_clause] [maxsize_clause]

|| Top ||

[binding_clause]

BINDING [(parameter_type,�) RETURN return_type [implementation_clause] using_function_clause],�

|| Top ||

[bitmap_join_index_clause]

[schema.]table (column [ASC | DESC], column�) FROM [table [t_alias]],� WHERE condition [local_partitioned_index] index_attributes

|| Top ||

[build_clause]

BUILD {IMMEDIATE | DEFERRED}

|| Top ||

[c_declaration]

C [NAME name] LIBRARY lib_name [AGENT IN (argument,�)] [WITH CONTEXT] [PARAMETERS (parameter,�)]

|| Top ||

[call_spec]

LANGUAGE {java_declaration | c_declaration}

|| Top ||

[cancel_clause]

CANCEL [IMMEDIATE] [WAIT | NOWAIT]

|| Top ||

[cell_assignment]

measure_column {condition | expr | single_column_for_loop},� | multi_column_for_loop

|| Top ||

[cell_reference_options]

[{IGNORE | KEEP} NAV] [UNIQUE {DIMENSION | SINGLE REFERENCE}]

|| Top ||

[character_set_clause]

CHARACTER SET character_set

|| Top ||

[check_datafiles_clause]

CHECK DATAFILES [GLOBAL | LOCAL]

|| Top ||

[check_diskgroup_clauses]

{CHECK ALL | DISK disk_name, � | DISKS IN FAILGROUP failgroup_name, � | FILE filename, �}� [REPAIR | NOREPAIR]

|| Top ||

[checkpoint_clause]

CHECKPOINT [GLOBAL | LOCAL]

|| Top ||

[clauster_index_clause]

CLUSTER [schema.]cluster index_attributes

|| Top ||

[coalesce_index_partition]

COALESCE PARTITION [parallel_clause]

|| Top ||

[coalesce_table_partition]

COALESCE PARTITION [update_index_clause] [parallel_clause]

|| Top ||

[column_association]

COLUMNS [schema.]table.column, � using_statististics_type

|| Top ||

[column_clauses]

{add_column_clause | modify_column_clause | drop_column_clause}� | rename_column_clause | modify_collection_retrieval � | modify_LOB_storage_clause | alter_varray_col_properties

|| Top ||

[column_properties]

{object_type_col_properties | nested_table_col_properties | {varray_col_properties | LOB_storage_clause} ([LOB_partition_storage],�) | XMLType_column_properties}�

|| Top ||

[commit_switchover_clause]

{PREPARE | COMMIT} TO SWITCHOVER [ TO {{PHYSICAL STANDBY [{WITH | WITHOUT} SESSION SHUTDOWN {WAIT | NOWAIT}] | LOGICAL STANDBY} | CANCEL]

|| Top ||

[compile_type_clause]

COMPILE [DEBUG] [SPECIFICATION | BODY] [compiler_parameters_clause�] [REUSE SETTINGS]

|| Top ||

[compiler_parameters_clause]

parameter_name = parameter_value

|| Top ||

[composite_partitioning]

PARTITION BY RANGE (column_list) [subpartition_by_list | subpartition_by_hash] [(PARTITION [partition] range_values_clause table_partition_description],�)

|| Top ||

[compute_statistics_clause]

COMPUTE [SYSTEM] STATISTICS [for_clause]

|| Top ||

[conditional_insert_clause]

[ALL | FIRST] [WHEN condition

THEN [insert_into_clause [values_clause] [error_logging_clause]]�]�

ELSE [insert_into_clause [values_clause] [error_logging_clause]]�]�

|| Top ||

[constraint]

{inline_constraint | out_of_line_constraint | inline_ref_constraint | out_of_line_ref_constraint}

|| Top ||

[constraint_clauses]

{ADD {out_of_line_constraint� | out_of_line_ref_constraint} | MODIFY {CONSTRAINT constraint | PRIMARY KEY | UNIQUE (column,�)} constraint_state | RENAME CONSTRAINT old_name TO new_name | drop_constraint_clause}

|| Top ||

[constraint_state]

[[NOT] DEFERRABLE] [INITIALLY {IMMEDIATE | DEFERRED}] [RELY | NORELY] [using_index_clause] [ENABLE | DISABLE] [VALIDATE | NOVALIDATE] [exceptions_clause]

|| Top ||

[constructor_declaration]

[FINAL] [INSTANTIABLE] CONSTRUCTOR FUNCTION datatype [[SELF IN OUT datatype, ] parameter,� RETURN SELF AS RESULT {IS | AS} {pl/sql_block | call_spec}

|| Top ||

[constractor_spec]

[FINAL] [INSTANTIABLE] CONSTRUCTOR FUNCTION datatype [[SELF IN OUT datatype, ] parameter,� RETURN SELF AS RESULT [{IS | AS} call_spec]

|| Top ||

[context_clause]

[WITH INDEX CONTEXT, SCAN CONTEXT implementation_type [COMPUTE ANCILLARY DATA]][WITH COLUMN CONTEXT]

|| Top ||

[controlfile_clauses]

{CREATE [ LOGICAL | PHYSICAL ] STANDBY CONTROLFILE AS �filename� [RENAME] | BACKUP CONTROLFILE TO {�filename� [REUSE] | trace_file_clause} }

|| Top ||

[create_datafile_clause]

CREATE DATAFILE {�filename� | filenumber}� [AS {file_specification, � | NEW}]

|| Top ||

[create_incomplete_type]

CREATE [OR REPLACE] TYPE [schema.]type_name;

|| Top ||

[create_mv_refresh]

{REFRESH {{FAST | COMPLETE | FORCE} | ON {DEMAND | COMMIT} | {START WITH | NEXT} date | WITH {PRIMARY KEY | ROWID} | USING {DEFAULT [MASTER | LOCAL] ROLLBACK SEGMENT} | [DEFAULT [ MASTER | LOCAL] ROLLBACK SEGMENT rollback_segment]� | USING {ENFORCED | TRUNCATED} CONSTRAINTS}� | NEVER REFRESH}

|| Top ||

[create_nested_table_type]

CREATE [OR REPLACE] TYPE [schema.]type_name [OID �object_identifier�] {IS | AS} TABLE OF datatype;

|| Top ||

[create_object_type]

CREATE [OR REPLACE] TYPE [schema.]type_name [OID �object_identifier�][invoker_rights_clause]{{IS | AS} OBJECT | UNDER [schema.]supertype} [sqlj_object_type][(attribute datatype [sqlj_object_type_attr][,attribute datatype [sqlj_object_type_attr]� [,element_spec[, element_spec]�)][[NOT] FINAL] [[NOT]INSTANTIABLE];

|| Top ||

[create_varray_type]

CREATE [OR REPLACE] TYPE [schema.]type_name [OID �object_identifier�] {IS | AS} {VARRAY | VARYING ARRAY} (limit) OF datatype;

|| Top ||

[database_file_clauses]

{RENAME FILE �filename�,� TO �filename� | create_datafile_clause | alter_datafile_clause | alter_tempfile_clause}

|| Top ||

[database_logging_clauses]

{LOGFILE [GROUP integer] file_specification, GROUP �

| MAXLOGFILES integer | MAXLOGMEMBERS integer | MAXLOGHISTORY integer | {ARCHIVELOG | NOARCHIVELOG} | FORCE LOGGING}

|| Top ||

[datafile_tempfile_clauses]

{ADD {DATAFILE | TEMPFILE} [file_specification,�] | RENAME DATAFILE �filename�,� TO �filename�,� | {DATAFILE | TEMPFILE}{ONLINE | OFFLINE}}

|| Top ||

[datafile_tempfile_spec]

[�filename�][SIZE size_clause][REUSE][autoextend_clause]

|| Top ||

[dblink]

database[.domain[.domain]�][@connect_descriptor]

|| Top ||

[dblink_authentication]

AUTHENTICATED BY user IDENTIFIED BY password

|| Top ||

[deallocate_unused_clause]

DEALLOCATE UNUSED [KEEP size_clause]

|| Top ||

[default_cost_clause]

DEFAULT COST (cpu_cost, io_cost, network_cost)

|| Top ||

[default_selectivity_clause]

DEFAULT SELECTIVITY default_selectivity

|| Top ||

[default_tablespace]

DEFAULT TABLESPACE tablespace [DATAFILE datafile_tempfile_spec] extent_management_clause

|| Top ||

[default_settings_clauses]

{SET DEFAULT {BIGFILE | SMALLFILE} TABLESPACE | DEFAULT TABLESPACE tablespace | DEFAULT TEMPORARY TABLESPACE {tablespace | tablespace_group_name} | RENAME GLOBAL_NAME TO database.domain[.domain]� | {ENABLE BLOCK CHANGE TRACKING [USING FILE �filename� [REUSE]] | DISABLE BLOCK CHANGE TRACKING} | flashback_mode_clause | set_time_zone_clause}

|| Top ||

[default_temp_tablespace]

[BIGFILE | SMALLFILE] DEFAULT TEMPORARY TABLESPACE tablespace [TEMPFILE file_specification,�] extent_management_clause

|| Top ||

[dependent_handling_clause]

{INVALIDATE | CASCADE [{[NOT] INCLUDING TABLE DATA | CONVERT TO SUBSTITUTABLE}][[FORCE] exceptions_clause]}

|| Top ||

[dimension_join_clause]

JOIN KEY (child_key_column,�) REFERENCES parent_level [JOIN KEY (child_key_column,�) REFERENCES�

|| Top ||

[disk_clauses]

{diskgroup_name {add_disk_clause | drop_disk_clauses | resize_disk_clauses} | {diskgroup_name | ALL} undrop_disk_clause}

|| Top ||

[diskgroup_alias_clauses]

{ADD ALIAS alias_name FOR filename, alias_name� | DROP ALIAS aliase_name,� | RENAME ALIAS old_alias_name TO new_alias_name, old_...}

|| Top ||

[diskgroup_availability]

{MOUNT | DISMOUNT [FORCE | NOFORCE]}

|| Top ||

[diskgroup_clauses]

{diskgroup_name {rebalance_diskgroup_clause | check_diskgroup_clauses | diskgroup_template_clauses | diskgroup_directory_clauses | diskgroup_alias_clauses | drop_diskgroup_file_clause} | {diskgroup_name | ALL} diskgroup_availability}

|| Top ||

[diskgroup_directory_clauses]

{ADD DIRECTORY filename,� | DROP DIRECTORY filename [FORCE | NOFORCE]]� | RENAME DIRECTORY old_dir_name TO new_dir_name, old_dir_name�

|| Top ||

[diskgroup_file_spec]

[�{fully_qualified_file_name | numeric_file_name | incorporate_file_name | alias_file_name}�][SIZE size_clause][REUSE][autoextend_clause]

|| Top ||

[diskgroup_template_clauses]

{{ADD | ALTER} TEMPLATE qualified_template_clause,� | DROP TEMPLATE template_name,�}

|| Top ||

[distributed_recov_clauses]

{ENABLE | DISABLE} DISTRIBUTED RECOVERY

|| Top ||

[dml_event_clause]

{DELETE | INSERT | UPDATE [OF column,�]}OR {DELETE�}� ON {[schema.]table | [NESTED TABLE nested_table_column OF] [schema.]view} [referencing_clause][FOR EACH ROW]

|| Top ||

[dml_table_expression_clause]

{[schema.]{table[{PARTITION (partition) | SUBPARTITION (subpartition)} |@dblink] | {view | materialized view}[@dblink]} | (subquery [subquery_restriction_clause]) | table_collection_exprression}

|| Top ||

[domain_index_clause]

INDEXTYPE IS indextype [parallel_clause][PARAMETERS (ODCI_parameters�)]

|| Top ||

[drop_binding_clause]

DROP BINDING (parameter_type,�) [FORCE]

|| Top ||

[drop_column_clause]

{SET UNUSED {COLUMN (column,�)} [{CASCADE CONSTRAINTS | INVALIDATE} [CASCADE CONSTRAINTS | INVALIDATE]�] | DROP {COLUMN (column,�) ,�)} [{CASCADE CONSTRAINTS | INVALIDATE} [CASCADE CONSTRAINTS | INVALIDATE]�] [CHECKPOINT integer] | DROP {UNUSED COLUMNS | COLUMNS CONTINUE} [CHECKPOINT integer]}

|| Top ||

[drop_constraint_clause]

DROP {{PRIMARY KEY | UNIQUE (column,�)}[CASCADE][{KEEP | DROP} INDEX] | CONSTRAINT constraint [CASCADE]}

|| Top ||

[drop_disk_clauses]

DROP {DISK disk_name[FORCE | NOFORCE], disk_name� | DISKS IN FAILGROUP failgroup_name [FORCE | NOFORCE], failgroup_name�}

|| Top ||

[drop_diskgroup_file_clause]

DROP FILE filename,�

|| Top ||

[drop_index_partition]

DROP PARTITION partition_name

|| Top ||

[drop_logfile_clauses]

DROP [STANBY] LOGFILE {logfile_descriptor, logfile_descriptor,� | MEMBER �filename�,�filename�,�}

|| Top ||

[drop_table_partition]

DROP PARTITION partition [update_index_clauses [parallel_clause]]

|| Top ||

[drop_table_subpartition]

DROP SUBPARTITION subpartition [update_index_clauses [parallel_clause]]

|| Top ||

[element_spec]

[inheritance_clauses]{subprogram_spec | constructor_spec | map_order_function_spec}� [, pragma_clause]

|| Top ||

[else_clause]

ELSE else_expr

|| Top ||

[enable_disable_clause]

{ENABLE | DISABLE} [VALIDATE | NOVALIDATE] {UNIQUE (column,�) | PRIMARY KEY | CONSTRAINT}[using_index_clause][exceptions_clause][CASCADE][{KEEP | DROP} INDEX]

|| Top ||

[end_session_clauses]

{DISCONNECT SESSION �integer1,integer2� [POST_TRANSACTION] | KILL SESSION �integer1, integer2�} [IMMEDIATE]

|| Top ||

[estimate_statistics_clause]

ESTIMATE [SYSTEM] STATISTICS [for_clause][SAMPLE integer {ROWS | PERCENT}]

|| Top ||

[exceptions_clause]

EXCEPTIONS INTO [schema.]table

|| Top ||

[exchange_partition_subpart]

EXCHANGE {PARTITION partition | SUBPARTITION subpartition} WITH TABLE table [{INCLUDING | EXCLUDING} INDEXES] [{WITH | WITHOUT} VALIDATION] [exceptions_clause] [update_index_clauses [parallel_clause]]

|| Top ||

[expr]

{simple_expression | compound_expression | case_expression | cursor_expression | datetime_expression | function_expression | interval_expression | object_access_expression | model_expression | type_constructor_expression | variable_expression}

|| Top ||

[expression_list]

{(expr,�)

|| Top ||

[extended_attribute_clause]

ATTRIBUTE attribute LEVEL level DETERMINES (dependent_column,�) LEVEL�

|| Top ||

[extent_management_clause]

EXTENT MANAGEMENT {DICTIONARY | LOCAL [AUTOALLOCATE | UNIFORM [SIZE size_clause]]}

|| Top ||

[external_data_properties]

DEFAULT DIRECTORY directory [ACCESS PARAMETERS {(opaque_format_spec) | USING CLOB subquery}} LOCATION ([directory:]�location_specifier�,[directory:]�)

|| Top ||

[external_table_clause]

([TYPE access_driver_type] external_data_properties)[REJECT LIMIT {integer | UNLIMITED}]

|| Top ||

[file_specification]

{datafile_tempfile_spec | diskgroup_file_spec | redo_log_file_spec}

|| Top ||

[finish_clause]

[DISCONNECT [FROM SESSION]] [parallel_clause] FINISH [SKIP [STANDBY LOGFILE]][WAIT | NOWAIT]

|| Top ||

[flashback_mode_clause]

FLASHBACK {ON | OFF}

|| Top ||

[flashback_query_clause]

[VERSIONS BETWEEN {SCN | TIMESTAMP} {expr | MINVALUE} AND {expr | MAXVALUE}] AS OF {SCN | TIMESTAMP} expr

|| Top ||

[for_clause]

{FOR {TABLE | ALL [INDEXED] COLUMNS [SIZE integer] | COLUMNS [SIZE integer] {column | attribute} [SIZE integer]}� | ALL [LOCAL] INDEXES}�

|| Top ||

[for_update_clause]

FOR UPDATE [OF[[schema.]{table | view}.]column, [schema.]�

[NOWAIT | WAIT integer]

|| Top ||

[full_database_recovery]

[STANDBY] DATABASE [{UNTIL {CANCEL | TIME date | CHANGE integer} | USING BACKUP CONTROLFILE}�

|| Top ||

[fully_qualified_file_name]

+diskgroup_name/db_name/file_type/file_type_tag.filenumber.incarnation_number

|| Top ||

[function_association]

{FUNCTIONS [schema.]function, [schema.]� | PACKAGES [schema.]package, [schema.]� | TYPES [schema.]type, [schema.]� | INDEXES [schema.]index, [schema.]� | INDEXTYPES [schema.]indextype, [schema.]�} {using_statistics_type | {default_cost_clause,[default_selectivity_clause]}}

|| Top ||

[function_declaration]

FUNCTION name (parameter datatype, parameter�) RETURN datatype {IS | AS}{pl/sql_block | call_spec}

|| Top ||

[function_spec]

FUNCTION name (parameter datatype, parameter�) return_clause

|| Top ||

[general_recovery]

RECOVER [AUTOMATIC][FROM �location�]{{full_database_recovery | partial_database_recovery | LOGFILE �filename�}[{TEST | ALLOW integer CORRUPTION | parallel_clause}� | CONTINUE [DEFAULT] | CANCEL}

|| Top ||

[global_partitioned_index]

GLOBAL PARTITION BY {RANGE (column_list)(index_partitioning_clause) | HASH (column_list) {individual_hash_partitions | hash_partitions_by_quantity}}

|| Top ||

[grant_object_privileges]

{{object_privilege | ALL [PRIVILEGES]}(column,�)},� on_object_clause TO grantee_clause [WITH HIERARCHY OPTION][WITH GRANT OPTION]

|| Top ||

[grant_system_privileges]

{system_privilege | role | ALL PRIVILEGES},� TO grantee_clause [IDENTIFIED BY password][WITH ADMIN OPTION]

|| Top ||

[grantee_clause]

{user | role | PUBLIC},�

|| Top ||

[group_by_clause]

GROUP BY {expr | rollup_cube_clause | grouping_sets_clause},� [HAVING condition]

|| Top ||

[grouping_expression_list]

expression_list,�

|| Top ||

[grouping_sets_clause]

GROUPING SETS ({rollup_cube_clause | grouping_expression_list})

|| Top ||

[hash_partitioning]

PARTITION BY HASH (column,�) {individual_hash_partitions | hash_partitions_by_quantity}

|| Top ||

[hash_partitions_by_quantity]

PARTITIONS hash_partitions_by_quantity [STORE IN (tablespace,�)] [OVERFLOW STORE IN (tablespace,�)]

|| Top ||

[hierarchical_query_clause]

[START WITH condition] CONNECT BY [NOCYCLE] condition

|| Top ||

[hierarchy_clause]

HIERARCHY hierarchy (child_level CHILD OF parent_level CHILD OF � [dimension_join_clause])

|| Top ||

[implementation_clause]

{ANCILLARY TO [primary_operator (parameter_type,�)]�) | context_clause}

|| Top ||

[incomplete_file_name]

+diskgroup_name [(template_time)]

|| Top ||

[index_attributes]

{physical_attributes_clause | logging_clause | ONLINE | COMPUTE STATISTICS | TABLESPACE {tablespace | DEFAULT} | key_compression | {SORT | NOSORT} | REVERSE | parallel_clause}�

|| Top ||

[index_expr]

{column | column_expression}

|| Top ||

[index_org_overflow_clause]

[INCLUDING column_name] OVERFLOW [segment_attributes_clause]

|| Top ||

[index_org_table_clause]

{mapping_table_clause | PCTTHRESHOLD integer | key_compression}� [index_org_overflow_clause]

|| Top ||

[index_partition_description]

PARTITION [partition {segment_attributes_clause | key_compression}�]

|| Top ||

[index_partitioning_clause]

PARTITION [partition] VALUES LESS THAN (value, value,�) [segment_attributes_clause]

|| Top ||

[index_properties]

{{global_partitioned_index | local_partitioned_index} | index_attributes}� | domain_index_clause

|| Top ||

[index_subpartition_clause]

STORE IN (tablespace, tablespace,�) | (SUBPARTITION [subpartition [TABLESPACE tablespace]], SUBPARTITION�)

|| Top ||

[individual_hash_paritions]

(PARTITION partition partitioning_storage_clause, PARTITION�)

|| Top ||

[inheritance_clauses]

[[NOT] {OVERRIDING | FINAL | INSTANTIABLE}]�

|| Top ||

[inline_constraint]

CONSTRAINT constraint_name {[NOT] NULL | UNIQUE | PRIMARY KEY | references_clause | CHECK (condition)} [constraint_state]

|| Top ||

[inline_ref_constraint]

{SCOPE IS [schema.]scope_table | WITH ROWID | [CONSTRAINT constraint_name] references_clause [constraint_state]}

|| Top ||

[inner_cross_join_clause]

table_reference {[INNER] JOIN table_reference {ON condition | USING (column, column,�)} | {CROSS | NATURAL [INNER]} JOIN table_reference}

|| Top ||

[insert_into_clause]

INTO dml_table_expression_clause [t_alias] [(column,�)]

|| Top ||

[integer]

[+|-] digit�

|| Top ||

[interval_day_to_second]

INTERVAL �{integer | integer time_expr | time_expr}� {{DAY | HOUR | MINUTE} [(leading_precision)] | SECOND [(leading_precision, fractional_seconds_precision)]}[TO {DAY | HOUR | MINUTE | SECOND [(fractional_seconds_precision)]}]

|| Top ||

[interval_year_to_month]

INTERVAL �integer [- integer]�{YEAR | MONTH} [(precision)][TO {YEAR | MONTH}]

|| Top ||

[into_clause]

INTO [schema.]table

|| Top ||

[invoker_rigths_clause]

AUTHID {CURRENT_USER | DEFINER}

|| Top ||

[java_declaration]

JAVA NAME �string�

|| Top ||

[join_clause]

{inner_cross_join_clause | outer_join_clause}

|| Top ||

[key_compression]

{COMPRESS [integer] | NOCOMPRESS}

|| Top ||

[level_clause]

LEVEL level IS (level_table.level_column,�)

|| Top ||

[list_partitioning]

PARTITION BY LIST (column) (PARTITION [partition] list_values_clause table_partition_description, PARTITION �)

|| Top ||

[list_values_clause]

VALUES ({value | NULL},�) | DEFAULT

|| Top ||

[LOB_parameters]

{TABLESPACE tablespace | {ENABLE | DISABLE} STORAGE IN ROW | storage_clause | CHUNK integer | PCTVERSION integer | RETENTION | FREEPOOLS integer | {CACHE | {NOCACHE | CACHE READS} [logging_clause]}}�

|| Top ||

[LOB_partition_storage]

PARTITION partition {LOB_storage_clause | varray_col_properties}� (SUBPARTITION subpartition {LOB_storage_clause | varray_col_properties}�)

|| Top ||

[LOB_storage_clause]

LOB {(LOB_item,�) STORE AS (LOB_parameters) | (LOB_item) STORE AS {LOB_segname (LOB_parameters) | LOB_segname | (LOB_parameters)}}

|| Top ||

[local_partitioned_index]

LOCAL [on_range_partitioned_table | on_list_partitioned_table | on_hash_partitioned_table | on_comp_parttioned_table]

|| Top ||

[logfile_clause]

[GROUP integer]file_specification, GROUP�]

|| Top ||

[logfile_clauses]

{{ARCHIVELOG [MANUAL] | NOARCHIVELOG} | [NO] FORCE LOGGING | RENAME FILE �filename�,� TO �filename� | CLEAR [UNARCHIVED] LOGFILE logfile_descriptor,� [UNRECOVERABLE DATAFILE] | add_logfile_clauses | drop_logfile_clauses | supplemental_db_logging}

|| Top ||

[logfile_descriptor]

{GROUP integer | (�filename�,�) | �filename�}

|| Top ||

[logging_clause]

{LOGGING | NOLOGGING}

|| Top ||

[main_model]

[MAIN main_model_name] model_column_clauses [cell_reference_options] model_rules_clause

|| Top ||

[managed_standby_recovery]

RECOVER MANAGED STANDBY DATABASE [recover_clause | cancel_clause | finish_clause]

|| Top ||

[map_order_func_declaration]

{MAP | ORDER} MEMBER function_declaration

|| Top ||

[map_order_function_spec]

{MAP | ORDER} MEMBER function_spec

|| Top ||

[mapping_table_clauses]

{MAPPING TABLE | NOMAPPING}

|| Top ||

[materialized_view_props]

[column_properties][table_partitioning_clauses][CACHE | NOCACHE][parallel_clause][build_clause]

|| Top ||

[maximize_standby_db_clause]

SET STANDBY DATABASE TO MAXIMIZE {PROTECTION | AVAILABILITY | PERFORMANCE}

|| Top ||

[maxsize_clause]

MAXSIZE {UNLIMITED | size_clause}

|| Top ||

[merge_insert_clause]

WHEN NOT MATCHED THEN INSERT [(column,�)] VALUES ({expr,� | DEFAULT}) [where_clause]

|| Top ||

[merge_table_partitions]

MERGE PARTITIONS partition_1, partition_2 [INTO partition_spec][update_index_clauses][parallel_clause]

|| Top ||

[merge_table_subpartitions]

MERGE SUBPARTITIONS subpart_1, subpart_2 [INTO subpartition_spec][update_index_clauses][parallel_clause]

|| Top ||

[merge_update_clause]

WHEN MATCHED THEN UPDATE SET column={expr | DEFAULT}, column� [where_clause][DELETE where_clause]

|| Top ||

[model_clause]

MODEL [cell_reference_options][return_rows_clause][reference_model]� main_model

|| Top ||

[model_column]

expr [[AS] c_alias]

|| Top ||

[model_column_clauses]

[query_partition_clause [c_alias]] DIMENSION BY (model_column,�) MEASURES (model_column,�)

|| Top ||

[model_rules_clause]

RULES [UPSERT | UPDATE][{AUTOMATIC | SQUENTIAL} ORDER][ITERATE (number) [UNTIL (condition)]] ([UPDATE | UPSERT] cell_assignment [order_by_clause] = expr)�

|| Top ||

[modify_col_properties]

([column [datatype][DEFAULT expr][inline_constraint�][LOB_storage_clause]],�)

|| Top ||

[modify_col_substitutable]

COLUMN column [NOT] SUBSTRITUTABLE AT ALL LEVELS [FORCE]

|| Top ||

[modify_collection_retrieval]

MODIFY NESTED TABLE collection_item RETURN AS {LOCATOR | VALUE}

|| Top ||

[modify_column_clauses]

MODIFY {modify_col_properties | modify_col_substitutable}

|| Top ||

[modify_hash_partition]

MODIFY PARTITION partition {partition_attributes | alter_mapping_table_clause | [REBUILD] UNUSABLE LOCAL INDEXES}

|| Top ||

[modify_hash_subpartition]

{{allocate_extent_clause | deallocate_unused_clause | shrink_clause | [{LOB LOB_item | VARRAY varray} modify_LOB_parameters]�} | [REBUILD] UNUSABLE LOCAL INDEXES}

|| Top ||

[modify_index_default_attrs]

MODIFY DEFAULT ATTRIBUTES [FOR PARTITION partition]{physical_atributes_clause | TABLESPACE {tablespace | DEFAULT} | logging_clause}�

|| Top ||

[modify_index_partition]

MODIFY PARTITION partition {deallocate_unused_clause | allocate_extent_clause | physical_attributes_clause | logging_clause | key_compression}� | PARAMETERS (�ODCI_parameters�) | COALESCE | UPDATE BLOCK REFERENCES | UNUSABLE

|| Top ||

[modify_index_subpartition]

MODIFY SUBPARTITION partition {UNUSABLE | allocate_extent_clause | deallocate_unused_clause}

|| Top ||

[modify_list_partition]

MODIFY PARTITION partition {partition_attributes | {ADD | DROP} VALUES (partition_value,�) | [REBUILD] UNUSABLE LOCAL INDEXES}

|| Top ||

[modify_list_subpartition]

{allocate_extent_clause | deallocate_unused_clause | shrink_clause | ]{LOB LOB_item | VARRAY varray} modify_LOB_parameters]� | [REBUILD] UNUSABLE LOCAL INDEXES | {ADD | DROP} VALUES (value,�)}

|| Top ||

[modify_LOB_parameters]

[{storage_clause | PCTVERSION integer | RETENTION | FREEPOOLS integer | REBUILD FREEPOOLS | {CACHE | {NOCACHE | CACHE READS}[logging_clause]} | allocate_extent_clause | deallocate_unused_clause | shrink_clause]�

|| Top ||

[modify_LOB_storage_clause]

MODIFY LOB (LOB_item) (modify_LOB_parameters)

|| Top ||

[modify_range_partition]

MODIFY PARTITION partition {partition_attributes | {add_hash_subpartition | add_list_subpartition} | COALESCE SUBPARTITION [update_index_clauses][parallel_clause] | alter_mapping_table_clause | [REBUILD] UNUSABLE LOCAL INDEXES}

|| Top ||

[modify_table_default_attrs]

MODIFY DEFAULT ATTRIBUTES [FOR PARTITION partition] [segment_attributes_clause] [table_compression] [PCTTHRESHOLD integer] [key_compression] [alter_overflow_clause] [{LOB (LOB_item) | VARRAY varrary} (LOB_parameters)]�]

|| Top ||

[modify_table_partition]

{modify_range_partition | modify_hash_partition | modify_list_partition}

|| Top ||

[modify_table_subpartition]

{modify_range_partition | modify_hash_subpartition | modify_list_subpartition}

|| Top ||

[move_table_clause]

MOVE [ONLINE] [segment_attributes_clause] [table_compression] [index_org_table_clause] {LOB_storage_clause | varrary_col_properties}� [parallel_clause]

|| Top ||

[move_table_partition]

MOVE PARTITION partition [MAPPING TABLE] [table_partition_description] [update_index_clauses] [parallel_clause]

|| Top ||

[move_table_subpartition]

MOVE SUBPARTITION subpartition_spec [update_index_clauses] [parallel_clause]

|| Top ||

[multi_column_for_loop]

FOR (dimension_column,�) IN ((literal,�)(literal,�)�) | subquery

|| Top ||

[multi_table_insert]

{ALL [insert_into_clause [values_clause]]� | conditional_insert_clause} subquery

|| Top ||

[multiset_except]

nested_table1 MULTISET EXCEPT [ALL | DISTINCT] nested_table2

|| Top ||

[multiset_interset]

nested_table1 MULTISET INTERSECT [ALL | DISTINCT] nested_table2

|| Top ||

[multiset_union]

nested_table1 MULTISET UNION [ALL | DISTINCT] nested_table2

|| Top ||

[nested_table_col_properties]

NESTED TABLE {nested_item | COLUMN_VALUE} [substritutable_column_clause] STORE AS storage_table [((object_properties) | [physical_properties] | [column_properties]]�)] [RETURN AS {LOCATOR | VALUE}]

|| Top ||

[new_values_clause]

{INCLUDING | EXCLUDING} NEW VALUES

|| Top ||

[number]

[+ | -] {digit�[.]digit� | [e[+ | -] digit�] | [f | d]

|| Top ||

[numeric_file_name]

+diskgroup_name.filenumber.incarnation_number

|| Top ||

[object_properties]

{column | attribute} [DEFAULT expr] [inline_constraint [inline_constraint]� | inline_ref_constraint] | {out_of_line_constraint | out_of_line_ref_constraint | supplemental_logging_props}

|| Top ||

[object_table]

CREATE [GLOBAL TEMPORARY] TABLE [schema.]table OF [schema.]object_type [object_table_substitution] [(object_properties)] [ON COMMIT {DELETE | PRESERVE} ROWS] [OID_clause] [OID_index_clause] [physical_properties] [table_properties];

|| Top ||

[object_table_substitution]

[NOT] SUBSTITUTABLE AT ALL LEVELS

|| Top ||

[object_type_col_properties]

COLUMN column substitutable_column_clause

|| Top ||

[object_view_clause]

OF [schema.]type_name {WITH OBJECT IDENTIFIER {DEFAULT | (attribute,�) | UNDER [schema.]superview} ({out_of_line_constraint | attribute inline_constraint�}�)

|| Top ||

[OID_clause]

OBJECT IDENTIFIER IS {SYSTEM GENERATED | PRIMARY KEY}

|| Top ||

[OID_index_clause]

OIDINDEX [index] ({physical_attributes_clause | TABLESPACE tablespace}�)

|| Top ||

[on_comp_partitioned_table]

[STORE IN (tablespace,�)] (PARTITION [partition {segment_attribute_clause | key_compression}�] [index_subpartition_clause], PARTITION�)

|| Top ||

[on_hash_partitioned_table]

STORE IN (tablespace,�) | (PARTITION [partition [TABLESPACE tablespace]], PARTITION�)

|| Top ||

[on_list_partitioned_table]

(PARTITION [partition {segment_attribute_clause | key_compression}�], PARTITION�)

|| Top ||

[on_object_clause]

{schema.object | {DIRECTORY directory_name | JAVA {SOURCE | RESOURCE} [schema.]object}}

|| Top ||

[on_range_partitioned_table]

(PARTITION [partition {segment_attribute_clause | key_compression}�], PARTITION�)

|| Top ||

[order_by_clause]

ORDER [SIBLINGS] BY {expr | position | c_alias} [ASC | DESC] [NULLS FIRST | NULLS LAST], expr�}

|| Top ||

[out_of_line_constraint]

[CONSTRAINT constraint_name] {UNIQUE (column,�) | PRIMARY KEY (column,�) | FOREIGN KEY (column,�) references_clause | CHECK (condition)} [constraint_state]

|| Top ||

[out_of_line_ref_constraint]

{SCOPE FOR ({ref_col | ref_attr}) IS [schema.]scope_table | REF ({ref_col | ref_attr}) WITH ROWID | [CONSTRAINT constraint_name] FOREIGN KEY ({ref_col | ref_attr}) references_clause [constraint_state]}

|| Top ||

[outer_join_clause]

table_reference [query_partition_clause] {outer_join_type JOIN | NATURAL [outer_join_type] JOIN} table_reference [query_partition_clause] [ON condition | USING (column,�)]

|| Top ||

[outer_join_type]

{FULL | LEFT | RIGHT} [OUTER]

|| Top ||

[parallel_clause]

{NOPARALLEL | PARALLEL [integer] }

|| Top ||

[parallel_enable_clause]

PARALLEL_ENABLE [(PARTITION argument BY {ANY | {HASH | RANGE} (column,�)}) [streaming_clause]]

|| Top ||

[partial_database_recovery]

{TABLESPACE tablespace,� | DATAFILE {�filename� | �filenumber, �} | STANBY {TABLESPACE tablespace,� | DATAFILE {�filename� | �filenumber, �} UNTIL [CONSISTENT WITH] CONTROLFILE}

|| Top ||

[partition_attributes]

[{physical_attributes_clause | logging_clause | allocate_extent_clause | deallocate_unused_clause | shrink_clause }�] OVERFLOW [{physical_attributes_clause | logging_clause | allocate_extent_clause | deallocate_unused_clause}�] [table_compression] [{LOB LOB_item | VARRAY varray} modify_LOB_parameters LOB LOB_item�]

|| Top ||

[partition_extended_name]

[schema.]{table | view} [PARTITION (partition) | SUBPARTITION (subpartition)]

|| Top ||

[partition_level_subpartition]

{SUBPARTITIONS hash_subpartition_quantity [STORE IN (tablespace,�)] | (subpartition_spec,�)}

|| Top ||

[partition_spec]

PARTITION [partition] [table_partition_description]

|| Top ||

[partitioning_storage_clause]

[{TABLESPACE tablespace | OVERFLOW [TABLESPACE tablespace] | LOB (LOB_item) STORE AS {LOB_segname [(TABLESPACE tablespace)] | (TABLESPACE tablespace} | VARRAY varray_item STORE AS LOB LOB_segment}�]

|| Top ||

[password_parameters]

{{FAILED_LOGIN_ATTEMPTS | PASSWORD_LIFE_TIME | PASSWORD_REUSE_TIME | PASSWORD_LOCK_TIME | PASSWORD_GRACE_TIME} {expr | UNLIMITED | DEFAULT} | PASSWORD_VERIFY_FUNCTION {function | NULL | DEFAULT}}

|| Top ||

[permanent_tablespace_clause]

{MINIMUM EXTENT integer [K | M] | BLOCKSIZE integer [K] | logging_clause | FORCE LOGGING | DEFAULT [table_compression] storage_clause | {ONLINE | OFFLINE} | extent_management_clause | segment_management_clause | flashback_mode_clause}�

|| Top ||

[physical_attributes_clause]

{PCTFREE integer | PCTUSED integer | INITRANS integer | storage_clause}�

|| Top ||

[physical_properties]

{segment_attributes_clause [table_compression] | ORGANIZATION {HEAP [segment_attributes_clause] [table_compression] | INDEX [segment_attributes_clause] index_org_table_clause | EXTERNAL external_table_clause} | CLUSTER cluster (column,�)}

|| Top ||

[pragma_clause]

PRAGMA RESTRICT_REFERENCES ({method_name | DEFAULT}, {RNDS | WNDS | RNPS | WNPS | TRUST},�)

|| Top ||

[procedure_declaration]

PROCEDURE name (parameter datatype, �) {IS | AS} {pl/sql_block | call_spec}

|| Top ||

[procedure_spec]

PROCEDURE name (parameter datatype, �) {IS | AS} {call_spec}

|| Top ||

[proxy_authentication]

{AUTHENTICATION REQUIRED | AUTHENTICATED USING {PASSWORD | DISTINGUISHED NAME | CERTIFICATE [TYPE �type�] [VERSION �version�]}}

|| Top ||

[proxy_clause]

{GRANT | REVOKE} CONNECT THROUGH proxy [WITH ROLE role_name,� | ALL EXCEPT role_name, � | NO ROLES] [proxy_authentication]

|| Top ||

[qualified_disk_clause]

search_string [NAME disk_name] [SIZE size_clause] [FORCE | NOFORCE]

|| Top ||

[qualified_template_clause]

template_name ATTRIBUTE ([MIRROR | UNPROTECTED] [FINE | COASE])

|| Top ||

[query_partition_clause]

PARTITION BY (value_expr,�)

|| Top ||

[query_table_expression]

{query_name | [schema.]table {PARTITION (partition) | SUBPARTITION (subpartition)} | sample_clause | @dblink | {view | materialized view} [@dblink] | (subquery [subquery_restriction_clause]) | table_collection_expression}

|| Top ||

[quiesce_clauses]

QUIESCE RESRICTED | UNQUIESCE

|| Top ||

[range_partitioning]

PARTITION BY RANGE (column,�) (PARTITION [partition] range_values_clause table_partition_description, PARTITION�)

|| Top ||

[range_values_clause]

VALUES LESS THAN ({value | MAXVALUE},�)

|| Top ||

[rebalance_diskgroup_clause]

REBALANCE [POWER integer]

|| Top ||

[rebuild_clause]

REBUILD [{PARTITION partition | SUBPARTITION subpartition} | {REVERSE | NOREVERSE}] [parallel_clause | TABLESPACE tablespace | PARAMETERS (�ODCI_parameters�) | ONLINE | COMPUTE STATISTICS | physical_attributes_clause | key_compression | logging_clause]�

|| Top ||

[records_per_block_clause]

{MINIMIZE | NOMINIMIZE} RECORDS_PER_BLOCK

|| Top ||

[recover_clause]

{{DISCONNECT [FROM SESSION] | {TIMEOUT integer | NOTIMEOUT}} | {NODELAY | DEFAULT DELAY | DELAY integer} | NEXT integer | {EXPIRE integer | NO EXPIRE} | parallel_clause | USING CURRENT LOGFILE | UNTIL CHANGE integer | THROUGH { [THREAD integer] SEQUENCE integer | ALL ARCHIVELOG | {ALL | LAST | NEXT} SWITCHOVER}}�

|| Top ||

[recovery_clauses]

{general_recovery | managed_standby_recovery | BEGIN BACKUP | END BACKUP}

|| Top ||

[redo_log_file_spec]

(�filename�,�) [SIZE size_clause] [REUSE]

|| Top ||

[redo_thread_cluasues]

{ENABLE | DISABLE} {INSTANCE �instance_name� | [PUBLIC] THREAD integer}

|| Top ||

[reference_model]

REFERENCE reference_spreadsheet_name ON (subquery) spreadsheet_column_clauses [cell_refference_options]

|| Top ||

[references_clause]

REFERENCES [schema.]{object_table | view} [(column,�)] [ON DELETE {CASCADE | SET NULL}] [constraint_state]

|| Top ||

[referencing_clause]

REFERENCING {OLD [AS] old | NEW [AS] new | PARENT [AS] parent}�

|| Top ||

[register_logfile_clause]

|| Top ||

[relational_properties]

{column datatype [SORT] [DEFAULT expr] [inline_constraint � | inline_ref_constraint] | {out_of_line_constraint | out_of_line_ref_constraint | supplemental_logging_props}}�

|| Top ||

[relational_table]

CREATE [GLOBAL TEMPORARY] TABLE [schema.]table [(relational_properties)][ON COMMIT {DELETE | PRESERVE} ROWS] [physical_properties] [table_properties];

|| Top ||

[rename_column_clause]

RENAME COLUMN old_name TO new_name

|| Top ||

[rename_index_partition]

RENAME {PARTITION partition | SUBPARTITION subpartition} TO new_name

|| Top ||

[rename_partition_subpart]

RENAME {PARTITION | SUBPARTITION} current_name TO new_name

|| Top ||

[replace_type_clause]

REPLACE [invoker_rights_clause] AS OBJECT (attribute datatype,�,element_spec,�)

|| Top ||

[resize_disk_clauses]

RESIZE {ALL [SIZE size_clause] | DISK disk_name [SIZE size_clause], disk_name� | DISKS IN FAILGROUP failgroup_name [SIZE size_clause], failegroup�}

|| Top ||

[resource_parameters]

{SESSIONS_PER_USER | CPU_PER_SESSION | CPU_PER_CALL | CONNECT_TIME | IDLE_TIME | LOGICAL_READS_PER_SESSION | LOGICAL_READS_PER_CALL | COMPOSITE_LIMIT}{integer | UNLIMITED | DEFAULT} | PRIVATE_SGA {integer [K | M] | UNLIMITED | DEFAULT}

|| Top ||

[restricted_session_clauses]

{ENABLE | DISABLE} RESTRICTED SESSION

|| Top ||

[return_clause]

{RETURN datatype [{IS | AS} call_spec] | sqlj_object_type_sig}

|| Top ||

[return_rows_clause]

RETURN {UPDATED | ALL} ROWS

|| Top ||

[returning_clause]

RETURNING expr,� INTO data_item,�

|| Top ||

[revoke_object_privileges]

{object_privilege | ALL [PRIVILEGES]},� on_object_clause FROM grantee_clause [CASCADE CONSTRAINTS | FORCE]

|| Top ||

[revoke_system_privileges]

{system_privilege | role | ALL PRIVILEGES},� FROM grantee_clause

|| Top ||

[rollup_cube_clause]

{ROLLUP | CUBE} (grouping_expression_list)

|| Top ||

[routine_clause]

[schema.][type. | package.] {function | procedure | method} [@dblink_name] (argument,�)

|| Top ||

[row_movement_clause]

{ENABLE | DISABLE} ROW MOVEMENT

|| Top ||

[sample_clause]

SAMPLE [BLOCK] (sample_percent) [SEED (seed_value)]

|| Top ||

[schema_object_clause]

{object_option,� | ALL} auditing_on_clause

|| Top ||

[scoped_table_ref_constraint]

{SCOPE FOR ({ref_column | ref_attribute}) IS [schema.] {scope_table_name | c_alias}},�

|| Top ||

[searched_case_expression]

WHEN condition THEN return_expr WHEN�

|| Top ||

[security_clause]

GUARD {ALL | STANDBY | NONE}

|| Top ||

[segment_attributes_clause]

{physical_attributes_clause | TABLESPACE tablespace | logging_clause}�

|| Top ||

[segment_management_clause]

SEGMENT SPACE MANAGEMENT {MANUAL | AUTO}

|| Top ||

[select_list]

* | {query_name.* | [schema.]{table | view | materialized_view}.* | expr [AS] c_alias | {query_name�

|| Top ||

[set_subpartition_template]

SET SUBPARTITION TEMPLATE (SUBPARTITION subpartition [list_values_clause] [partitioning_storage_clause], SUBPARTITION �) | hash_subpartition_quantity

|| Top ||

[set_time_zone_clause]

SET TIME_ZONE �{ {+ | -} hh:mi | time_zone_region}�

|| Top ||

[shrink_clause]

SHRINK SPACE [COMPACT] [CASCADE]

|| Top ||

[shutdown_dispatcher_clause]

SHUTDOWN [IMMEDIATE] dispatcher_name

|| Top ||

[simple_case_expression]

expr WHEN comparison_expr THEN return_expr WHEN�

|| Top ||

[single_column_for_loop]

FOR dimension_column {IN ({literal,� | subquery}) | [LIKE pattern] FROM literal TO literal {INCREMENT | DECREMENT} literal}

|| Top ||

[single_table_insert]

insert_into_clause {values_clause [returning_clause] | subquery}

|| Top ||

[size_clause]

integer [K | M | G | T]

|| Top ||

[split_index_partition]

SPLIT PARTITION partition_name_old AT (value,�) INTO (index_partition_description,�) [parallel_clause] UPDATE MANUALLY problem importing file

|| Top ||

[split_table_partition]

SPLIT PARTITION current_partition {AT | VALUES} (value,�) INTO (partition_spec,�) [update_index_clauses] [parallel_clause] UPDATE MANUALLY problem importing file

|| Top ||

[split_table_subpartition]

SPLIT SUBPARTITION subpartition VALUES ({value | NULL},...) [INTO (subpartition_spec,�) [update_index_clauses] [parallel_clause] UPDATE MANUALLY problem importing file

|| Top ||

[sql_statement_clause]

{statement_option | ALL},� | {system_privilege | ALL PRIVILEGES},� [auditing_by_clause]

|| Top ||

[sqlj_object_type]

EXTERNAL NAME java_ext_name LANGUAGE JAVA USING (SQLData | CustomDatum | OraData)

|| Top ||

[sqlj_object_type_attr]

EXTERNAL NAME �field_name�

|| Top ||

[sqlj_object_type_sig]

RETURN {datatype | SELF AS RESULT} EXTERNAL {VARIABLE NAME �java_static_field_name� | NAME �java_method_sig�}

|| Top ||

[standby_database_clauses]

|| Top ||

[start_standby_clause]

START LOGICAL STANDBY APPLY [IMMEDIATE] [NODELAY] [NEW PRIMARY dblink | INITIAL [scn_value] | {SKIP FAILED TRANSACTION | FINISH}]

|| Top ||

[startup_clauses]

{MOUNT [{STANDBY | CLONE} DATABASE] | OPEN {[READ WRITE] [RESETLOGS | NORESETLOGS] [UPGRADE | DOWNGRADE] | READ ONLY}}

|| Top ||

[stop_standy_clause]

{STOP | ABORT} LOGICAL STANDBY APPLY

|| Top ||

[storage_clause]

STORAGE ({INITIAL integer [K | M] | NEXT integer [K | M] | MINEXTENTS integer | MAXEXTENTS {integer | UNLIMITED} | PCTINCREASE integer | FREELISTS integer | FREELIST GROUPS integer | OPTIMAL [integer [K | M] | NULL] | BUFFER_POOL {KEEP | RECYCLE | DEFAULT}�

|| Top ||

[streaming_clause]

{ORDER | CLUSTER} BY (column,�)

|| Top ||

[subpartition_by_hash]

SUBPARTITION BY HASH (column,�) [SUBPARTITIONS quantity [STORE IN (tablespace,�) | subpartition_template]

|| Top ||

[subpartition_by_list]

SUBPARTITION BY LIST (column) [subpartition_template]

|| Top ||

[subpartition_spec]

SUBPARTITION [subpartition] [list_valuses_clause] [partitioning_storage_clause]

|| Top ||

[subpartition_template]

SUBPARTITION TEMPLATE (SUBPARTITION subpartition [list_valuses_clause] [partitioning_storage_clause], SUBPARTITION subparition�) | hash_subpartition_quantity

|| Top ||

[subprogram_declaration]

{MEMBER | STATIC} {procedure_declaration | function_declaration | constructor_declaration}

|| Top ||

[subprogram_spec]

{MEMBER | STATIC} {procedure_spec | function_spec}

|| Top ||

[subquery]

[subquery_factoring_clause] SELECT [hint] [{{DISTINCT | UNIQUE} | ALL}] select_list FROM table_reference, � [where_clause] [hierarchical_query_clause] [group_by_clause] [HAVING condition] [model_clause] [{UNION [ALL] | INTERSECT | MINUS} {subquery)][order_by_clause]

|| Top ||

[subquery_factoring_clause]

WITH query_name AS (subquery), query_name�

|| Top ||

[subquery_restriction_clause]

WITH {READ ONLY | CHECK OPTION [CONSTRAINT constraint]}

|| Top ||

[substitutable_column_clause]

[ELEMENT] IS OF [TYPE] ([ONLY] type) | [NOT] SUBSTITUTABLE AT ALL LEVELS

|| Top ||

[supplemental_db_logging]

{ADD | DROP} SUPPLEMENTAL LOG {DATA | supplemental_id_key_clause}

|| Top ||

[supplemental_id_key_clause]

DATA ({ALL | PRIMARY KEY | UNIQUE | FOREIGN KEY},�) COLUMNS

|| Top ||

[supplemental_log_grp_clause]

GROUP log_group (column [NO LOG], column�) [ALWAYS]

|| Top ||

[supplemental_logging_props]

{supplemental_log_grp_clause | supplemental_id_key_clause}

|| Top ||

[supplemental_table_logging]

ADD SUPPLEMENTAL LOG {supplemental_log_grp_clause }, SUPPLEMENTAL LOG� | DROP SUPPLEMENTAL LOG {supplemental_id_key_clause | GROUP log_group}, SUPPLEMENTAL LOG�

|| Top ||

[table_collection_expression]

TABLE (collection_expression) [(+)]

|| Top ||

[table_compression]

{COMPRESS | NOCOMPRESS}

|| Top ||

[table_index_clause]

[schema.]table [t_alias] (index_expr [ASC | DESC], index_expr�) [index_properties]

|| Top ||

[table_partition_description]

[segment_attributes_clause] [table_compression | key_compression] [OVERFLOW [segment_attributes_clause]] [{LOB_storage_clause | varray_col_properties}�] [partition_level_subpartition]

|| Top ||

[table_partitioning_clauses]

{range_partitioning | hash_partitioning | list_partitioning | composite_partitioning}

|| Top ||

[table_properties]

[column_properties] [table_partitioning_clauses] [CACHE | NOCACHE] [parallel_clause] [ROWDEPENDENCIES | NOROWDEPENDENCIES] [enable_disable_clause] [row_movement_clause] [AS subquery]

|| Top ||

[table_reference]

ONLY (query_table_expression) [flashback_query_clause] [t_alias] | (join_clause)

|| Top ||

[tablespace_clauses]

|| Top ||

[tablespace_group_clause]

TABLESPACE GROUP {tablespace_group_name | ��}

|| Top ||

[tablespace_logging_clauses]

{logging_clause | [NO] FORCE LOGGING}

|| Top ||

[tablespace_retention_clause]

RETENTION {GUARANTEE | NOGUARANTEE}

|| Top ||

[tablespace_state_clauses]

{ONLINE | OFFLINE [NORMAL | TEMPORARY | IMMEDIATE]} | READ {ONLY | WRITE} | {PERMANENT | TEMPORARY}

|| Top ||

[temporary_tablespace_clause]

TEMPORARY TABLESPACE tablespace [TEMPFILE file_specification,�] [tablespace_group_clause] [extent_management_clause]

|| Top ||

[text]

[N | n] {�c�� | {Q | q} �c��}

|| Top ||

[trace_file_clause]

TRACE [AS �filename� [REUSE]] [RESETLOGS | NORESETLOGS]

|| Top ||

[truncate_partition_subpart]

TRUNCATE {PARTITION partition | SUBPARTITION subpartition} [{DROP | REUSE] STORAGE] [update_index_clauses [parallel_clause]]

|| Top ||

[undo_tablespace]

[BIGFILE | SMALLFILE] UNDO TABLESPACE tablespace [TABLESPACE file_specification,�]

|| Top ||

[undo_tablesapce_clause]

UNDO TABLESPACE tablespace [DATAFILE file_specification,�] [extent_management_clause] [tablespace_retention_clause]

|| Top ||

[undrop_disk_clause]

UNDROP DISKS

|| Top ||

[update_all_indexes_clause]

UPDATE INDEXES [(index ({update_index_partition | update_index_subpartition}),index�))]�

|| Top ||

[update_global_index_clause]

{UPDATE | INVALIDATE} GLOBAL INDEXES

|| Top ||

[update_index_clauses]

{update_global_index_clause | update_all_indexes_clause}

|| Top ||

[update_index_partition]

PARTITION [partition] [index_partition_description [index_subpartition_clause]], PARTITION�

|| Top ||

[update_index_subpartition]

SUBPARTITION [subpartition] [TABLESPACE tablespace], SUBPARTITION�

|| Top ||

[update_set_clause]

SET {(column,�) = (subquery) | column = {expr | (subquery) | DEFAULT}},� | VALUE (t_alias) = {expr | (subquery)}

|| Top ||

[upgrade_table_clause]

UPGRADE [[NOT] INCLUDING DATA] [column_properties]

|| Top ||

[using_function_clause]

USING [schema.][package. | type.]function_name

|| Top ||

[using_index_clause]

USING INDEX {[schema.]index | (create_index_statement) | index_properties}

|| Top ||

[using_statistics_type]

USING {[schema.]statistics_type | NULL}

|| Top ||

[using_type_clause]

USING [schema.]implementation_type [array_DML_clause]

|| Top ||

[validation_clauses]

{VALIDATE REF UPDATE [SET DANGLING TO NULL] | VALIDATE STRUCTURE [CASCADE] [into_clause] {OFFLINE | ONLINE}}

|| Top ||

[values_clause]

VALUES ({expr | DEFAULT},�)

|| Top ||

[varrary_col_properties]

VARRAY varray_item [substitutable_column_clause] STORE AS LOB LOB_segname (LOB_parameters) | substitutable_column_clause

|| Top ||

[where_clause]

WHERE condition

|| Top ||

[windowing_clause]

{ROWS | RANGE} {BETWEEN {UNBOUNDED PRECEDING | CURRENT ROW | value_expr {PRECEDING | FOLLOWING}} AND {UNBOUNDED FOLLOWING | CURRENT ROW | value_expr {PRECEDING | FOLLOWING}}

|| Top ||

[XML_attributes_clause]

XMLATTRIBUTES (value_expr [AS c_alias],value_expr�)

|| Top ||

[XMLSchema_spec]

[XMLSCHEMA XMLSchema_URL] ELEMENT {element | XMLSchema_URL # element}

|| Top ||

[XMLType_column_properties]

XMLTYPE [COLUMN] column [XMLType_storage] [XMLSchema_spec]

|| Top ||

[XMLType_storage]

STORE AS {OBJECT RELATIONAL} | CLOB LOB_segname (LOB_parameters) | LOB_parameters

|| Top ||

[XMLType_table]

CREATE TABLE [GLOBAL TEMPORARY] TABLE [schema.]table OF XMLTYPE [(object_properties)] [XMLTYPE XMLType_storage] [XMLSchema_spec] [ON COMMIT {DELETE | PRESERVE} ROWS] [OID_clause] [OID_index_clause] [physical_properties] [table_properties]

|| Top ||

[XMLType_view_clause]

OF XMLTYPE [XMLSchema_spec] WITH OBJECT IDENTIFIER {DEFAULT | (expr,�)}

|| Top ||