everythingOracle.bizhat.com

 

'Everything you wanted
to know about Oracle'

Training References Syntax Tell A Friend Contact Us

 

 

10g Syntax


 

CREATE

ALTER

DROP

OTHERS

CREATE CLUSTER
CREATE CONTEXT
CREATE CONTROLFILE
CREATE DATABASE
CREATE DATABASE LINK
CREATE DIMENSION
CREATE DIRECTORY
CREATE DISKGROUP
CREATE FUNCTION
CREATE INDEX
CREATE INDEXTYPE
CREATE JAVA
CREATE LIBRARY
CREATE MATERIALIZED VIEW
CREATE MATERIALIZED VIEW LOG
CREATE OPERATOR
CREATE OUTLINE
CREATE PACKAGE
CREATE PACKAGE BODY
CREATE PFILE
CREATE PROCEDURE
CREATE PROFILE
CREATE ROLE
CREATE ROLLBACK SEGMENT
CREATE SCHEMA AUTHORIZATION
CREATE SEQUENCE
CREATE SPFILE
CREATE SYNONYM
CREATE TABLE
CREATE TABLESPACE
CREATE TRIGGER
CREATE TYPE
CREATE TYPE BODY
CREATE USER
CREATE VIEW

ALTER CLUSTER
ALTER DATABASE
ALTER DIMENSION
ALTER DISKGROUP
ALTER FUNCTION
ALTER INDEX
ALTER INDEXTYPE
ALTER JAVA
ALTER MATERIALIZED VIEW
ALTER MATERIALIZED VIEW LOG
ALTER OPERATOR
ALTER OUTLINE
ALTER PACKAGE
ALTER PROCEDURE
ALTER PROFILE
ALTER RESOURCE COST
ALTER ROLE
ALTER ROLLBACK SEGMENT
ALTER SEQUENCE
ALTER SESSION
ALTER TABLE
ALTER TABLESPACE
ALTER TRIGGER
ALTER TYPE
ALTER USER
ALTER VIEW

 

 

 

 

 

 

DROP CLUSTER
DROP CONTEXT
DROP DATABASE
DROP DATABASE LINK
DROP DIMENSION
DROP DIRECTORY
DROP DISKGROUP
DROP FUNCTION
DROP INDEX
DROP INDEXTYPE
DROP JAVA
DROP LIBRARY
DROP MATERIALIZED VIEW
DROP MATERIALIZED VIEW LOG
DROP OPERATOR
DROP OUTLINE
DROP PACKAGE
DROP PROCEDURE
DROP PROFILE
DROP ROLE
DROP ROLLBACK SEGMENT
DROP SEQUENCE
DROP SYNONYM
DROP TABLESPACE
DROP TRIGGER
DROP TYPE
DROP TYPE BODY
DROP USER
DROP VIEW

 

 

 

 

ANALYZE
ASSOCIATE STATISTICS WITH
AUDIT
CALL
COMMENT ON
COMMIT
DELETE
DISASSOCIATE STATISTICS
EXPLAIN PLAN
FLASHBACK DATABASE
FLASHBACK TABLE
GRANT
INSERT
LOCK TABLE
MERGE
NOAUDIT
PURGE
RENAME
REVOKE
ROLLBACK
SAVEPOINT
SELECT
SET CONSTRAINT[S]
SET ROLE
SET TRANSACTION
TRUNCATE
UPDATE

 

 

 

 

 

 

 

ALTER CLUSTER

ALTER CLUSTER [schema.]cluster

{physical_attributes_clause | SIZE size_clause | allocate_extent_clause | deallocate_unused_clause | {CACHE | NOCHACHE}}…

[parallel_clause];

||  Top   ||

 

ALTER DATABASE

ALTER DATABASE [database]

{startup_clauses | recovery_clauses | database_file_clauses | logfile_clauses | controlfile_clauses | standby_database_clauses | default_settings_clauses | redo_thread_clauses | security_clause};

||  Top   ||

 

ALTER DIMENSION

ALTER DIMENSION [schema.]dimension

{ADD {level_clause | hierarchy_clause | attribute_clause | extended_attribute_clause}…

{DROP {LEVEL level [RESTRICT | CASCADE] | HIERARCHY hierarchy | ATTRIBUTE attribute [LEVEL level [COLUMN column …}… COMPILE;

||  Top   ||

 

ALTER DISKGROUP

ALTER DISKGROUP {disk_clauses | diskgroup_clauses} …;

||  Top   ||

 

ALTER FUNCTION

ALTER FUNCTION [schema.]function

COMPILE [DEBUG] [compiler_parameters_clause …] [REUSE SETTING];

||  Top   ||

 

ALTER INDEX

ALTER INDEX [schema.]index

{{deallocate_unused_clause | allocate_extent_clause | shrink_clause | parallel_clause | physical_attributes_clause | logging_clause}… | rebuild_clause | PARAMETERS (‘ODCI_parameters’) | {ENABLE | DISABLE} |UNUSABLE | RENAME TO new_name | COALESCE | {MONITORING | NOMONITORING} USAGE | UPDATE BLOCK REFERENCES | alter_index_partitioning};

||  Top   ||

 

ALTER INDEXTYPE

ALTER INDEXTYPE [schema.]indextype

{{ADD | DROP} [schema.]operator (parameter_types)}… [using_type_clause] | COMPILE};

||  Top   ||

 

ALTER JAVA

ALTER JAVA {SOURCE | CLASS} [schema.]object_name

[RESOLVER (match_string[,]{schema_name | - })…]

{{COMPILE | RESERVE} | invoker_rights_clause};

||  Top   ||

 

ALTER MATERIALIZED VIEW

ALTER MATERIALIZED VIEW [schema.](materialized_view)

[physical_attributes_clause | table_compression | LOB_storage_clause… | modify_LOB_storage_clause… | alter_table_partitioning | parallel_clause | allocate_extent_clause | shrink_clause | {CACHE | NOCACHE}] [alter_iot_clauses] [USING INDEX physical_allributes_clause] [MODIFY scoped_table_ref_constraint | alter_mv_refresh] [ {ENABLE | DISABLE} QUERY REWRITE | COMPILE | CONSIDER FRESH];

||  Top   ||

 

ALTER MATERIALIZED VIEW LOG

ALTER MATERIALIZED VIEW LOG [FORCE] ON [schema.]table

[physical_attribute_clause | alter_table_partitioning | parallel_clause | logging_clause

| allocate_extent_clause | shrink_clause | {CACHE | NOCACHE}]

[ADD {OBJECT ID | PRIMARY KEY | ROWID | SEQUENCE}[(column [, column]…)] (column [, column]…)}… [new_values_clause]];

||  Top   ||

 

ALTER OPERATOR

ALTER OPERATOR [schema.]operator

{add_binding_clause | drop_binging_clause | COMPILE};

||  Top   ||

 

ALTER OUTLINE

ALTER OUTLINE [PUBLIC | PRIVATE] outline

{REBUILD | RENAME TO new_outline_name | CHANGE CATEGORY TO new_category_name | {ENABLE | DISABLE}}…;

||  Top   ||

 

ALTER PACKAGE

ALTER PACKAGE [schema.]package

COMPILE [DEBUG] [PACKAGE | SPECIFICATION | BODY] [compiler_parameters_clause]… [REUSE SETTINGS];

||  Top   ||

 

ALTER PROCEDURE

ALTER PROCEDURE [schema.]procedure

COMPILE [DEBUG] [compiler_parameters_clause]… [REUSE SETTINGS];

||  Top   ||

 

ALTER PROFILE

ALTER PROFILE profile LIMIT

[resource_parameters | password_parameters]…;

||  Top   ||

 

ALTER RESOURCE COST

ALTER RESOURCE COST

{CPU_PER_SESSION | CONNECT_TIME | LOGICAL_READS_PER_SESSION | PRIVATE_SGA} integer …;

||  Top   ||

 

ALTER ROLE

ALTER ROLE role

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

||  Top   ||

 

ALTER ROLLBACK SEGMENT

ALTER ROLLBACK SEGMENT rollback_segment

{ONLINE | OFFLINE | storage_clause | SHRINK [ TO integer [K | M]]};

||  Top   ||

 

ALTER SEQUENCE

ALTER SEQUENCE [schema.]sequence

{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

[alter_table_properties | column_clauses | constraint_clauses | alter_table_partitioning | alter_external_table_clauses | move_table_clause]

[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

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]

REGISTER [OR REPLACE] [PHYSICAL | LOGICAL] LOGFILE [file_specification,…] FOR logminer_session_name

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

(activate_standby_db_clause | maximize_standby_db_clause | register_logfile_clause | commit_suitchover_clause | start_standby_clause | stop_standby_clause) [parallel_clause]

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

EXTENT MANGEMENT LOCAL | DATAFILE file_specification,… | SYSAUX DATAFILE file_specification,… | default_tablespace | default_temp_tablespace | undo_tablespace

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

     Reviews and Templates for FrontPage
     

Copyright © everythingOracle.bizhat.com 2006 All Rights Reserved.