SQLステートメント(日本語)
Table of Contents

ALTER CLUSTER

    ALTER CLUSTER [ schema. ]cluster
      { physical_attributes_clause
      | SIZE size_clause
      | allocate_extent_clause
      | deallocate_unused_clause
      | { CACHE | NOCACHE }
      }
        [ physical_attributes_clause
        | SIZE size_clause
        | allocate_extent_clause
        | deallocate_unused_clause
        | { CACHE | NOCACHE }
        ]...
      [ parallel_clause ]

ALTER DATABASE

    ALTER DATABASE [ database ]
      { startup_clauses
      | recovery_clauses
      | database_file_clauses
      | logfile_clauses
      | controlfile_clauses
      | standby_database_clauses
      | default_settings_clauses
      | instance_clauses
      | security_clause
      } 
 
startup_clauses:
   MOUNT
   MOUNT CLONE DATABASE
   MOUNT PARALLEL
   CONVERT
   OPEN [READ ONLY]
   OPEN [READ WRITE] RESETLOGS|NORESETLOGS [MIGRATE]
 
default_settings_clauses:
   [NATIONAL] CHARACTER SET char_set
 
standby_database_clauses:
   MOUNT STANDBY DATABASE
   ACTIVATE STANDBY DATABASE
 
archivelog options:
   ARCHIVELOG
   NOARCHIVELOG
 
recovery_clauses:
   BACKUP CONTROLFILE TO 'filename' [REUSE]
   BACKUP CONTROLFILE TO TRACE [RESETLOGS] [AS 'filename' [REUSE]]
   CREATE STANDBY CONTROLFILE AS 'filename' [REUSE]
   RECOVER recover_clause
   RECOVER MANAGED STANDBY standby_recover_clause
   END BACKUP
 
database_file_clauses:
   CREATE DATAFILE 'filename' AS filespec
   DATAFILE 'filename' ONLINE
   DATAFILE 'filename' OFFLINE [DROP]
   DATAFILE 'filename' RESIZE int K | M
   DATAFILE 'filename' AUTOEXTEND OFF
   DATAFILE 'filename' AUTOEXTEND ON [NEXT int K | M] [MAXSIZE int K | M | UNLIMITED]
   DATAFILE 'filename' END BACKUP
   RENAME FILE 'data_file_name' TO 'data_file_name'
 
   TEMPFILE 'filename' ONLINE
   TEMPFILE 'filename' OFFLINE
   TEMPFILE 'filename' DROP [INCLUDING DATAFILES]
   TEMPFILE 'filename' RESIZE int K | M
   TEMPFILE 'filename' AUTOEXTEND OFF
   TEMPFILE 'filename' AUTOEXTEND ON [NEXT int K | M] [MAXSIZE int K | M | UNLIMITED]
 
controlfile_clauses:
   BACKUP CONTROLFILE TO [TRACE| 'backup_controlfile_name']
   CREATE STANDBY CONTROLFILE AS 'filename' [REUSE]
 
redo log options:
   ADD LOGFILE [THREAD int] [GROUP int] filespec
   ADD LOGFILE MEMBER 'filename' [REUSE] TO GROUP int
   ADD LOGFILE MEMBER 'filename' [REUSE] TO 'filename'
   DROP LOGFILE GROUP int
   DROP LOGFILE ('filename')
   DROP LOGFILE MEMBER 'filename'
   RENAME FILE 'redolog_file_name' TO 'redolog_file_name'
   CLEAR [UNARCHIVED] LOGFILE GROUP int [UNRECOVERABLE DATAFILE]
   CLEAR [UNARCHIVED] LOGFILE ('filename') [UNRECOVERABLE DATAFILE]
 
Parallel server options:
   SET DBLOW = 'text'
   SET DBHIGH = 'text'
   SET DBMAC = ON | OFF
   ENABLE [PUBLIC] THREAD int
   DISABLE THREAD int
 
Backwards compatibility options:
   RENAME GLOBAL_NAME TO database [domain]
   RESET COMPATIBILITY

ALTER DIMENSION

    ALTER DIMENSION [ schema. ]dimension
      { ADD
        { level_clause
        | hierarchy_clause
        | attribute_clause
        | extended_attribute_clause
        }
        [ ADD
          { level_clause
          | hierarchy_clause
          | attribute_clause
          | extended_attribute_clause
          }
        ]...
      | DROP
        { LEVEL level
        [ RESTRICT | CASCADE ]
        | HIERARCHY hierarchy
        | ATTRIBUTE attribute
        [ LEVEL level [ COLUMN column
                [, COLUMN column ]... ]
        }
        [ DROP
          { LEVEL level
          [ RESTRICT | CASCADE ]
          | HIERARCHY hierarchy
          | ATTRIBUTE attribute
          [ LEVEL level [ COLUMN column
                  [, COLUMN column ]... ]
          }
        ]...
      | COMPILE
      }

ALTER DISKGROUP

    ALTER DISKGROUP
        { diskgroup_name
        { add_disk_clause | drop_disk_clause }
            [, { add_disk_clause | drop_disk_clause } ]...
        | resize_disk_clauses
        } [ rebalance_diskgroup_clause ]
        | {rebalance_diskgroup_clause                                    
          | check_diskgroup_clause
          | diskgroup_template_clauses
          | diskgroup_directory_clauses
          | diskgroup_alias_clauses
          | drop_diskgroup_file_clause
          } 
        | { diskgroup_name
          [, diskgroup_name ]...
          | ALL 
          }
          { undrop_disk_clause
          | diskgroup_availability
          }
        }
    ALTER FUNCTION
    ALTER FUNCTION [ schema. ]function
      COMPILE [ DEBUG ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ]

ALTER INDEX

    ALTER INDEX [ schema. ]index
      { { deallocate_unused_clause
        | allocate_extent_clause
        | shrink_clause
        | parallel_clause
        | physical_attributes_clause
        | logging_clause
        }
          [ 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
      }

ALTER INDEXTYPE

    ALTER INDEXTYPE [ schema. ]indextype
      { { ADD | DROP }
        [ schema. ]operator (parameter_types)
          [, { ADD | DROP }
          [ schema. ]operator (parameter_types)
          ]...
        [ using_type_clause ]
      | COMPILE
      }

ALTER JAVA

    ALTER JAVA
      { SOURCE | CLASS } [ schema. ]object_name 
      [ RESOLVER 
          ( ( match_string [, ] { schema_name | - } ) 
        [ ( match_string [, ] { schema_name | - } )
        ]... 
          ) 
      ]
      { { COMPILE | RESOLVE }
      | invoker_rights_clause
      }

ALTER MATERIALIZED VIEW

    ALTER MATERIALIZED VIEW
      [ schema. ](materialized_view)
      [ physical_attributes_clause
      | table_compression
      | LOB_storage_clause
        [, LOB_storage_clause ]...
      | modify_LOB_storage_clause
        [, modify_LOB_storage_clause ]...
      | alter_table_partitioning
      | parallel_clause
      | logging_clause
      | allocate_extent_clause
      | shrink_clause
      | { CACHE | NOCACHE }
      ]
      [ alter_iot_clauses ]
      [ USING INDEX physical_attributes_clause ]
      [ MODIFY scoped_table_ref_constraint
      | alter_mv_refresh
      ]
      [ { ENABLE | DISABLE } QUERY REWRITE
      | COMPILE
      | CONSIDER FRESH
      ]

ALTER MATERIALIZED VIEW LOG

    ALTER MATERIALIZED VIEW LOG [ FORCE ]
      ON [ schema. ]table
      [ physical_attributes_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 ]... )
          }
        [, { { OBJECT ID
             | PRIMARY KEY
             | ROWID
             | SEQUENCE
             }
             [ (column [, column ]...) ]
           | (column [, column ]...)
           }
        ]...
          [ new_values_clause ]
      ]

ALTER OPERATOR

    ALTER OPERATOR [ schema. ]operator
      { add_binding_clause
      | drop_binding_clause
      | COMPILE
      }

ALTER OUTLINE

    ALTER OUTLINE
      [ PUBLIC | PRIVATE ] outline
      { REBUILD
      | RENAME TO new_outline_name
      | CHANGE CATEGORY TO new_category_name
      | { ENABLE | DISABLE }
      }
        [ REBUILD
        | RENAME TO new_outline_name
        | CHANGE CATEGORY TO new_category_name
        | { ENABLE | DISABLE }
        ]...

ALTER PACKAGE

    ALTER PACKAGE [ schema. ]package
      COMPILE [ DEBUG ]
      [ PACKAGE | SPECIFICATION | BODY ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ]

ALTER PROCEDURE

    ALTER PROCEDURE [ schema. ]procedure
      COMPILE [ DEBUG ]
      [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
      [ REUSE SETTINGS ]

ALTER PROFILE

    ALTER PROFILE profile LIMIT
      { resource_parameters | password_parameters }
        [ resource_parameters | password_parameters
        ]...

ALTER RESOURCE COST

    ALTER RESOURCE COST
      { CPU_PER_SESSION
      | CONNECT_TIME
      | LOGICAL_READS_PER_SESSION
      | PRIVATE_SGA
      }
      integer
        [ { CPU_PER_SESSION
          | CONNECT_TIME
          | LOGICAL_READS_PER_SESSION
          | PRIVATE_SGA
          }
          integer
        ] ...

ALTER ROLE

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

ALTER ROLLBACK SEGMENT

    ALTER ROLLBACK SEGMENT rollback_segment
      { ONLINE
      | OFFLINE
      | storage_clause
      | SHRINK [ TO size_clause ]
      }

ALTER SEQUENCE

    ALTER SEQUENCE [ schema. ]sequence
      { INCREMENT BY integer
      | { MAXVALUE integer | NOMAXVALUE }
      | { MINVALUE integer | NOMINVALUE }
      | { CYCLE | NOCYCLE }
      | { CACHE integer | NOCACHE }
      | { ORDER | NOORDER }
      }
        [ INCREMENT BY integer
        | { MAXVALUE integer | NOMAXVALUE }
        | { MINVALUE integer | NOMINVALUE }
        | { CYCLE | NOCYCLE }
        | { CACHE integer | NOCACHE }
        | { ORDER | NOORDER }
        ]...

ALTER SESSION

    ALTER SESSION
      { ADVISE { COMMIT | ROLLBACK | NOTHING }
      | CLOSE DATABASE LINK dblink
      | { ENABLE | DISABLE } COMMIT IN PROCEDURE
      | { ENABLE | DISABLE } GUARD
      | { ENABLE | DISABLE | FORCE } PARALLEL
        { DML | DDL | QUERY } [ PARALLEL integer ]
      | { ENABLE RESUMABLE
          [ TIMEOUT integer ] [ NAME string ]
        | DISABLE RESUMABLE
        }
      | alter_session_set_clause
      }

ALTER SYSTEM

    ALTER SYSTEM
      { archive_log_clause
      | checkpoint_clause
      | check_datafiles_clause
      | distributed_recov_clauses
      | FLUSH { SHARED_POOL | BUFFER_CACHE }
      | end_session_clauses
      | SWITCH LOGFILE
      | { SUSPEND | RESUME }
      | quiesce_clauses
      | alter_system_security_clauses
      | shutdown_dispatcher_clause
      | REGISTER
      | SET alter_system_set_clause
        [ alter_system_set_clause ]...
      | RESET alter_system_reset_clause
          [ alter_system_reset_clause ]...
      }

ALTER TABLE

    ALTER TABLE [ schema. ]table
      [ alter_table_properties
      | column_clauses
      | constraint_clauses
      | alter_table_partitioning
      | alter_external_table_clauses
      | move_table_clause
      ]
      [ enable_disable_clause
      | { ENABLE | DISABLE }
        { TABLE LOCK | ALL TRIGGERS }
        [ enable_disable_clause
        | { ENABLE | DISABLE }
          { TABLE LOCK | ALL TRIGGERS }
        ]...
      ]
constraint_clauses::=
ADD | MODIFY | DROP
[inline_constraint|
out_of_line_constraint|
inline_ref_constraint|
out_of_line_ref_constraint]
inline_constraint::=
[CONSTRAINT constraint_name] 
(
[NOT] NULL 
| UNIQUE 
| PRIMARY KEY 
| references_close 
| CHECK(condition) 
) 
[constraint_state]
out_of_line_constraint::=
[CONSTRAINT constraint_name] 
(
UNIQUE(column[, column ...])
| PRIMARY KEY(column[, column ...])
| FOREIGN KEY(column[, column ...]) references_close 
| CHECK(condition) 
) 
[constraint_state]
inline_ref_constraint::=
(
SCOPE IS [schema.]scope_table
| WITH ROWID
| [CONSTRAINT constraint_name] reference_close [constraint_state]
)
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) ) reference_close [constraint_state]
)
constraint_state::=
[NOT] DEFERRABLE
| INITIALLY (IMMEDIATE | DEFERRED)
| ENABLE | DISABLE
| VALIDATE | NOVALIDATE
| RELY | NORELY
| using_index_clause
| exceptions_clause
using_index_clause::=
USING INDEX 
[schema.] index 
| (create_index_statement)
| index_properties
index_attributes::=
[
physical_attributes_clause
| logging_clause
| ONLINE
| COMPUTE STATISTICS
| TABLESPACE ( tablespace | DEFAULT )
| key_compression
| SORT | NOSORT
| REVERSE
| parallel_clause
] ...
exceptions_clause::=
EXCEPTION INTO [schema.] table

Example:

-- check constraint
SQL> create table test (tid varchar2(10), constraint chk_test_tid check(to_number(tid) >0));
SQL> alter table test modify constraint chk_test_tid disable;
SQL> alter table test drop constraint chk_test_tid;

ALTER TABLESPACE

    ALTER TABLESPACE tablespace
      { DEFAULT
          [ table_compression ] storage_clause
      | MINIMUM EXTENT size_clause
      | RESIZE size_clause
      | COALESCE
      | RENAME TO new_tablespace_name
      | { BEGIN | END } BACKUP
      | datafile_tempfile_clauses
      | tablespace_logging_clauses
      | tablespace_group_clause
      | tablespace_state_clauses
      | autoextend_clause
      | flashback_mode_clause
      | tablespace_retention_clause
      }

ALTER TRIGGER

    ALTER TRIGGER [ schema. ]trigger
      { ENABLE
      | DISABLE
      | RENAME TO new_name
      | COMPILE [ DEBUG ]
          [ compiler_parameters_clause
        [ compiler_parameters_clause ] ... ]
          [ REUSE SETTINGS ]
      }

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

ALTER USER

    ALTER USER
      { user
        { IDENTIFIED
          { BY password [ REPLACE old_password ]
          | EXTERNALLY [ AS 'certificate_DN' ]
          | GLOBALLY [ AS '[directory_DN]' ]
          }
        | DEFAULT TABLESPACE tablespace
        | TEMPORARY TABLESPACE
         { tablespace | tablespace_group_name }
        | QUOTA { size_clause
            | UNLIMITED
            } ON tablespace
          [ QUOTA { size_clause
              | UNLIMITED
              } ON tablespace
          ]...
        | PROFILE profile
        | DEFAULT ROLE { role [, role ]...
               | ALL [ EXCEPT
                    role [, role ]... ]
               | NONE
               }
        | PASSWORD EXPIRE
        | ACCOUNT { LOCK | UNLOCK }
        }
          [  { IDENTIFIED
           { BY password [ REPLACE old_password ]
           | EXTERNALLY [ AS 'certificate_DN' ]
           | GLOBALLY [ AS '[directory_DN]' ]
           }
         | DEFAULT TABLESPACE tablespace
         | TEMPORARY TABLESPACE
              { tablespace | tablespace_group_name }
         | QUOTA { size_clause
             | UNLIMITED
             } ON tablespace
           [ QUOTA { size_clause
               | UNLIMITED
               } ON tablespace
           ]...
         | PROFILE profile
         | DEFAULT ROLE { role [, role ]...
                | ALL [ EXCEPT
                     role [, role ]... ]
                | NONE
                }
         | PASSWORD EXPIRE
         | ACCOUNT { LOCK | UNLOCK }
         }
          ]...
      | user [, user ]...
        proxy_clause

ALTER VIEW

    ALTER VIEW [ schema. ]view
      { ADD out_of_line_constraint
      | MODIFY CONSTRAINT constraint
          { RELY | NORELY }
      | DROP { CONSTRAINT constraint
         | PRIMARY KEY
         | UNIQUE (column [, column ]...)
         }
      | COMPILE
      }

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
      }

ASSOCIATE STATISTICS

    ASSOCIATE STATISTICS WITH
      { column_association | function_association }

AUDIT

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

CALL

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

COMMENT

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

COMMIT

    COMMIT [ WORK ]
      [
        [ COMMENT string ] 
        | [ WRITE 
        [ IMMEDIATE | BATCH ] [ WAIT | NOWAIT ]
        ]
      | FORCE string [, integer ]
      ]

CREATE CLUSTER

    CREATE CLUSTER [ schema. ]cluster
      (column datatype [ SORT ]
        [, column datatype [ SORT ] ]...
      )
      [ { physical_attributes_clause
        | SIZE size_clause
        | TABLESPACE tablespace
        | { INDEX
          | [ SINGLE TABLE ]
        HASHKEYS integer [ HASH IS expr ]
          }
        }
          [ physical_attributes_clause
          | SIZE size_clause
          | TABLESPACE tablespace
          | { INDEX
        | [ SINGLE TABLE ]
          HASHKEYS integer [ HASH IS expr ]
        }
          ]...
      ]
      [ parallel_clause ]
      [ NOROWDEPENDENCIES | ROWDEPENDENCIES ]
      [ CACHE | NOCACHE ]

CREATE CONTEXT

    CREATE [ OR REPLACE ] CONTEXT namespace
      USING [ schema. ] package
      [ INITIALIZED { EXTERNALLY | GLOBALLY }
      | ACCESSED GLOBALLY
      ]

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
        | MAXINSTANCES integer
        | { ARCHIVELOG | NOARCHIVELOG }
        | FORCE LOGGING
        }
          [ MAXLOGFILES integer
          | MAXLOGMEMBERS integer
          | MAXLOGHISTORY integer
          | MAXDATAFILES integer
          | MAXINSTANCES integer
          | { ARCHIVELOG | NOARCHIVELOG }
          | FORCE LOGGING
          ]...
      ]
      [ character_set_clause ]

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

CREATE DATABASE LINK

    CREATE [ SHARED ] [ PUBLIC ] DATABASE LINK dblink
      [ CONNECT TO
        { CURRENT_USER
        | user IDENTIFIED BY password [ dblink_authentication ]
        }
      | dblink_authentication
      ]
        [ CONNECT TO
          { CURRENT_USER
          | user IDENTIFIED BY password [ dblink_authentication ]
          }
        | dblink_authentication
        ]...
      [ USING connect_string ]

CREATE DIMENSION

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

CREATE DIRECTORY

    CREATE [ OR REPLACE ] DIRECTORY directory
      AS 'path_name'

CREATE DISKGROUP

    CREATE DISKGROUP diskgroup_name
      [ { HIGH | NORMAL | EXTERNAL } REDUNDANCY ]
      [ FAILGROUP failgroup_name ]
      DISK qualified_disk_clause
           [, qualified_disk_clause ]...
        [ [ FAILGROUP failgroup_name ]
          DISK qualified_disk_clause
           [, qualified_disk_clause ]...
        ]...

CREATE FUNCTION

    CREATE [ OR REPLACE ] FUNCTION [ schema. ]function
      [ (argument [ IN | OUT | IN OUT ]
         [ NOCOPY ] datatype
           [, argument [ IN | OUT | IN OUT ]
          [ NOCOPY ] datatype
           ]...
        )
      ]
      RETURN datatype
      [ { invoker_rights_clause
        | DETERMINISTIC
        | parallel_enable_clause
        }
          [ invoker_rights_clause
          | DETERMINISTIC
          | parallel_enable_clause
          ]...
      ]
      { { AGGREGATE | PIPELINED }
        USING [ schema. ]implementation_type
      | [ PIPELINED ]
        { IS | AS }
        { pl/sql_function_body | call_spec }
      }

CREATE INDEX

    CREATE [ UNIQUE | BITMAP ] INDEX [ schema. ]index
      ON { cluster_index_clause
         | table_index_clause
         | bitmap_join_index_clause
         }

CREATE INDEXTYPE

    CREATE [ OR REPLACE ] INDEXTYPE
      [ schema. ]indextype FOR
      [ schema. ]operator (paramater_type
                   [, paramater_type ]...)
        [, [ schema. ]operator (paramater_type
                    [, paramater_type ]...)
        ]...
      using_type_clause

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_char
      } 
 
    CREATE LIBRARY
    CREATE [ OR REPLACE ] LIBRARY [ schema. ]libname
      { IS | AS } 'filename' [ AGENT 'agent_dblink' ]

CREATE MATERIALIZED VIEW

    CREATE MATERIALIZED VIEW
      [ schema. ]materialized_view
      [ column_alias [, column_alias]... ]
      [ 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
        ]
          [ physical_attributes_clause
          | TABLESPACE tablespace
          ]...
      | USING NO INDEX
      ]
      [ create_mv_refresh ]
      [ FOR UPDATE ]
      [ { DISABLE | ENABLE }
        QUERY REWRITE
      ]
      AS subquery

CREATE MATERIALIZED VIEW LOG

    CREATE MATERIALIZED VIEW LOG
      ON [ schema. ] table
      [ physical_attributes_clause
      | TABLESPACE tablespace
      | logging_clause
      | { CACHE | NOCACHE }
        [ physical_attributes_clause
        | TABLESPACE tablespace
        | logging_clause
        | { CACHE | NOCACHE }
        ]...
      ]
      [ parallel_clause ]
      [ table_partitioning_clauses ]
      [ WITH { OBJECT ID
         | PRIMARY KEY
         | ROWID
         | SEQUENCE
         | (column [, column ]...)
         }
           [, { OBJECT ID
              | PRIMARY KEY
              | ROWID
              | SEQUENCE
              | (column [, column ]...)
              }
           ]...
        [ new_values_clause ]
      ]

CREATE OPERATOR

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

CREATE OUTLINE

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

CREATE PACKAGE

    CREATE [ OR REPLACE ] PACKAGE [ schema. ]package
       [ invoker_rights_clause ]
       { IS | AS } pl/sql_package_spec

CREATE PACKAGE BODY

    CREATE [ OR REPLACE ] PACKAGE BODY
       [ schema. ]package
       { IS | AS } pl/sql_package_body

CREATE PFILE

    CREATE PFILE [= 'pfile_name' ]
       FROM SPFILE [= 'spfile_name']

CREATE PROCEDURE

    CREATE [ OR REPLACE ] PROCEDURE [ schema. ]procedure
       [ (argument [ { IN | OUT | IN OUT } ]
               [ NOCOPY ]
               datatype [ DEFAULT expr ]
           [, argument [ { IN | OUT | IN OUT } ]
               [ NOCOPY ]
               datatype [ DEFAULT expr ]
           ]...
         )
       ] 
       [ invoker_rights_clause ]
       { IS | AS }
       { pl/sql_subprogram_body | call_spec }

CREATE PROFILE

    CREATE PROFILE profile
       LIMIT { resource_parameters
         | password_parameters
         }
           [ resource_parameters
           | password_parameters
           ]...

CREATE RESTORE POINT

    CREATE RESTORE POINT restore_point
       [ GUARANTEE FLASHBACK DATABASE ]

CREATE ROLE

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

CREATE ROLLBACK SEGMENT

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

CREATE SCHEMA

    CREATE SCHEMA AUTHORIZATION schema
       { create_table_statement
       | create_view_statement
       | grant_statement
       }
         [ create_table_statement
         | create_view_statement
         | grant_statement
         ]...

CREATE SEQUENCE

    CREATE SEQUENCE [ schema. ]sequence
       [ { INCREMENT BY | START WITH } integer
       | { MAXVALUE integer | NOMAXVALUE }
       | { MINVALUE integer | NOMINVALUE }
       | { CYCLE | NOCYCLE }
       | { CACHE integer | NOCACHE }
       | { ORDER | NOORDER }
       ]
         [ { INCREMENT BY | START WITH } integer
         | { MAXVALUE integer | NOMAXVALUE }
         | { MINVALUE integer | NOMINVALUE }
         | { CYCLE | NOCYCLE }
         | { CACHE integer | NOCACHE }
         | { ORDER | NOORDER }
         ]...

CREATE SPFILE

    CREATE SPFILE [= 'spfile_name' ]
      FROM PFILE [= 'pfile_name' ]

CREATE SYNONYM

    CREATE [ OR REPLACE ] [ PUBLIC ] SYNONYM
       [ schema. ]synonym 
       FOR [ schema. ]object [ @ dblink ]

CREATE TABLE

    { relational_table | object_table | XMLType_table }
    CREATE TABLESPACE
    CREATE
       [ BIGFILE | SMALLFILE ]
       { permanent_tablespace_clause
       | temporary_tablespace_clause
       | undo_tablespace_clause
       }

CREATE TRIGGER

    CREATE [ OR REPLACE ] TRIGGER [ schema. ]trigger
       { BEFORE | AFTER | INSTEAD OF }
       { dml_event_clause
       | { ddl_event [ OR ddl_event ]...
         | database_event [ OR database_event ]...
         }
         ON { [ schema. ]SCHEMA
        | DATABASE
        }
       }
       [ WHEN (condition) ]
       { pl/sql_block | call_procedure_statement }

CREATE TYPE

    { create_incomplete_type
    | create_object_type
    | create_varray_type
    | create_nested_table_type
    }
    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

CREATE USER

    CREATE USER user
       IDENTIFIED { BY password
              | EXTERNALLY [ AS 'certificate_DN' ]
              | GLOBALLY [ AS '[ directory_DN ]' ]
              }
       [ DEFAULT TABLESPACE tablespace
       | TEMPORARY TABLESPACE
        { tablespace | tablespace_group_name }
       | QUOTA size_clause
           | UNLIMITED
           }
           ON tablespace
         [ QUOTA size_clause
             | UNLIMITED
             }
             ON tablespace
         ]...
       | PROFILE profile
       | PASSWORD EXPIRE
       | ACCOUNT { LOCK | UNLOCK }
         [ DEFAULT TABLESPACE tablespace
         | TEMPORARY TABLESPACE
          { tablespace | tablespace_group_name }
         | QUOTA size_clause
             | UNLIMITED
             }
             ON tablespace
           [ QUOTA size_clause
               | UNLIMITED
               }
               ON tablespace
           ]...
         | PROFILE profile
         | PASSWORD EXPIRE
         | ACCOUNT { LOCK | UNLOCK }
         ]...
      ]

CREATE VIEW

    CREATE [ OR REPLACE ] [ [ NO ] FORCE ] VIEW
       [ schema. ]view
       [ (alias [ inline_constraint
              [ inline_constraint ]... ]
         | out_of_line_constraint
           [, alias [ inline_constraint
              [ inline_constraint ]... ]
           | out_of_line_constraint
           ]...
         )
       | object_view_clause
       | XMLType_view_clause
       ]
       AS subquery [ subquery_restriction_clause ]

DELETE

    DELETE [ hint ]
       [ FROM ]
       { dml_table_expression_clause
       | ONLY (dml_table_expression_clause)
       }
       [ t_alias ]
       [ where_clause ]
       [ returning_clause ] [error_logging_clause]

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 ]

DROP CLUSTER

    DROP CLUSTER [ schema. ]cluster
       [ INCLUDING TABLES [ CASCADE CONSTRAINTS ] ]

DROP CONTEXT

    DROP CONTEXT namespace

DROP DATABASE

    DROP DATABASE

DROP DATABASE LINK

    DROP [ PUBLIC ] DATABASE LINK dblink

DROP DIMENSION

    DROP DIMENSION [ schema. ]dimension

DROP DIRECTORY

    DROP DIRECTORY directory_name

DROP DISKGROUP

    DROP DISKGROUP diskgroup_name
       [ { INCLUDING | EXCLUDING }
         CONTENTS
       ]

DROP FUNCTION

    DROP FUNCTION [ schema. ]function_name

DROP INDEX

    DROP INDEX [ schema. ]index [ FORCE ]

DROP INDEXTYPE

    DROP INDEXTYPE [ schema. ]indextype [ FORCE ]

DROP JAVA

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

DROP LIBRARY

    DROP LIBRARY library_name

DROP MATERIALIZED VIEW

    DROP MATERIALIZED VIEW
       [ schema. ]materialized_view
       [ PRESERVE TABLE ]

DROP MATERIALIZED VIEW LOG

    DROP MATERIALIZED VIEW LOG
       ON [ schema. ]table

DROP OPERATOR

    DROP OPERATOR [ schema. ]operator [ FORCE ]

DROP OUTLINE

    DROP OUTLINE outline

DROP PACKAGE

    DROP PACKAGE [ BODY ] [ schema. ]package

DROP PROCEDURE

    DROP PROCEDURE [ schema. ]procedure

DROP PROFILE

    DROP PROFILE profile [ CASCADE ]

DROP RESTORE POINT

    DROP RESTORE POINT restore_point

DROP ROLE

    DROP ROLE role

DROP ROLLBACK SEGMENT

    DROP ROLLBACK SEGMENT rollback_segment

DROP SEQUENCE

    DROP SEQUENCE [ schema. ]sequence_name

DROP SYNONYM

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

DROP TABLE

    DROP TABLE [ schema. ]table
       [ CASCADE CONSTRAINTS ]
       [ PURGE ]

DROP TABLESPACE

    DROP TABLESPACE tablespace 
       [ INCLUDING CONTENTS [ {AND | KEEP} DATAFILES ]
         [ CASCADE CONSTRAINTS ]
       ]

DROP TRIGGER

    DROP TRIGGER [ schema. ]trigger

DROP TYPE

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

DROP TYPE BODY

    DROP TYPE BODY [ schema. ]type_name

DROP USER

    DROP USER user [ CASCADE ]

DROP VIEW

    DROP VIEW [ schema. ] view
       [ CASCADE CONSTRAINTS ]

EXPLAIN PLAN

    EXPLAIN PLAN
       [ SET STATEMENT_ID = string ]
       [ INTO [ schema. ]table [ @ dblink ] ]
       FOR statement

FLASHBACK DATABASE

    FLASHBACK [ STANDBY ] DATABASE [ database ]
       { TO { { SCN | TIMESTAMP } expr
        | RESTORE POINT restore_point
        }
       | TO BEFORE { SCN | TIMESTAMP} expr
               | RESETLOGS 
               }
       }

FLASHBACK TABLE

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

GRANT

    GRANT { grant_system_privileges
          | grant_object_privileges
          }

INSERT

    INSERT [ hint ]
       { single_table_insert | multi_table_insert }

LOCK TABLE

    LOCK TABLE
       [ schema. ] { table | view }
       [ { PARTITION (partition)
         | SUBPARTITION (subpartition)
         }
       | @ dblink
       ]
         [, [ schema. ] { table | view }
        [ { PARTITION (partition)
          | SUBPARTITION (subpartition)
          }
        | @ dblink
        ]
         ]...
       IN lockmode MODE
       [ NOWAIT ]

MERGE

    MERGE [ hint ]
       INTO [ schema. ] { table | view } [ t_alias ]
       USING [ schema. ] { table | view | subquery }
         [ t_alias ]
       ON ( condition )
       [ merge_update_clause ]
       [ merge_insert_clause ]
       [ error_logging_clause ]

NOAUDIT

    NOAUDIT 
       { sql_statement_clause
       | schema_object_clause
       | NETWORK
       }
       [ WHENEVER [ NOT ] SUCCESSFUL ]

PURGE

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

RENAME

    RENAME old_name
       TO new_name

REVOKE

    REVOKE { revoke_system_privileges
           | revoke_object_privileges
           }

ROLLBACK

    ROLLBACK [ WORK ]
       [ TO [ SAVEPOINT ] savepoint
       | FORCE string
       ]

SAVEPOINT

    SAVEPOINT savepoint

SELECT

    subquery [ for_update_clause ]

SET CONSTRAINT / SET CONSTRAINTS

    SET { CONSTRAINT | CONSTRAINTS }
        { constraint [, constraint ]...
        | ALL
        }
        { IMMEDIATE | DEFERRED }

SET ROLE

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

SET TRANSACTION

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

TRUNCATE

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

UPDATE

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

Reference:
http://download.oracle.com/docs/cd/B19306_01/server.102/b14195/sqlqr01.htm#i87990
http://otndnld.oracle.co.jp/document/products/oracle10g/102/doc_cd/server.102/B19201-02/clauses.html#4240
http://www.ss64.com/ora/database_a.html