Skip Headers
Oracle® Database SQL Quick Reference
10g Release 2 (10.2)

Part Number B14195-02
Go to Documentation Home
Home
Go to Book List
Book List
Go to Table of Contents
Contents
Go to Index
Index
Go to Master Index
Master Index
Go to Feedback page
Contact Us

Go to previous page
Previous
Go to next page
Next
View PDF

5 Subclauses

This chapter presents the syntax for the subclauses found in the syntax for SQL statements, functions, expressions and conditions.

This chapter includes the following section:

Syntax for Subclauses

The sections that follow show the syntax for each subclause found in:

activate_standby_db_clause

ACTIVATE
     [ PHYSICAL | LOGICAL ]
     STANDBY DATABASE
     [ FINISH APPLY ]

add_binding_clause

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

add_column_clause

ADD
   ( column_definition [, column_definition] ... )
   [ column_properties ]


add_disk_clause

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

add_hash_index_partition

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

add_hash_partition_clause

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

add_hash_subpartition

ADD subpartition_spec
   [ update_index_clauses ]
   [ parallel_clause ]

add_list_partition_clause

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

add_list_subpartition

ADD subpartition_spec
   [ update_index_clauses ]

add_logfile_clauses

ADD [ STANDBY ] LOGFILE
   { [ INSTANCE 'instance_name' ]
     [ GROUP integer ] redo_log_file_spec
       [, [ GROUP integer ] redo_log_file_spec ]...
   | MEMBER 'filename' [ REUSE ]
            [, 'filename' [ REUSE ] ]...
        TO logfile_descriptor
           [, logfile_descriptor ]...
   }

add_overflow_clause

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

add_range_partition_clause

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

add_table_partition

{ add_range_partition_clause
| add_hash_partition_clause
| add_list_partition_clause
}

alias_file_name

+diskgroup_name [ (template_name) ] /alias_name

allocate_extent_clause

ALLOCATE EXTENT
  [ ( { SIZE size_clause
      | DATAFILE 'filename'
      | INSTANCE integer
      }
        [ SIZE size_clause
        | DATAFILE 'filename'
        | INSTANCE integer
        ]...
    )
  ]

alter_attribute_definition

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

alter_collection_clauses

MODIFY { LIMIT integer
       | ELEMENT TYPE datatype
       }

alter_datafile_clause

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

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 }
}
  [ add_column_clause
  | modify_column_clauses
  | drop_column_clause
  | parallel_clause
  | external_data_properties
  | REJECT LIMIT { integer | UNLIMITED }
  | PROJECT COLUMN { ALL | REFERENCED }
  ]...

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
}

alter_iot_clauses

{ index_org_table_clause
| alter_overflow_clause
| alter_mapping_table_clauses
| COALESCE
}

alter_mapping_table_clauses

MAPPING TABLE
  { allocate_extent_clause
  | deallocate_unused_clause
  }

alter_method_spec

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

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
   }

alter_overflow_clause

{ OVERFLOW
     { allocate_extent_clause
     | shrink_clause
     | deallocate_unused_clause
     }
       [ allocate_extent_clause
       | shrink_clause
       | deallocate_unused_clause
       ]...
| add_overflow_clause
}

alter_session_set_clause

SET parameter_name = parameter_value
    [ parameter_name = parameter_value ]...

alter_system_reset_clause

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

alter_system_security_clauses

{ { ENABLE | DISABLE } RESTRICTED SESSION
| SET ENCRYPTION WALLET OPEN IDENTIFIED BY "password"
| SET ENCRYPTION WALLET CLOSE
| SET ENCRYPTION KEY [ "certificate_id" ] IDENTIFIED BY "password"
}

alter_system_set_clause

parameter_name =
   parameter_value [, parameter_value ]...
   [ COMMENT = string ]
   [ DEFERRED ]
   [ SCOPE = { MEMORY | SPFILE | BOTH } ]
   [ SID = { 'sid' | * } ]

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
}

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

alter_tempfile_clause

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

alter_varray_col_properties

MODIFY VARRAY varray_item
   ( modify_LOB_parameters )

analytic_clause

[ query_partition_clause ]
[ order_by_clause [ windowing_clause ] ]

archive_log_clause

ARCHIVE LOG
   [  INSTANCE 'instance_name' ]
   { { SEQUENCE integer
     | CHANGE integer
     | CURRENT [ NOSWITCH ]
     | GROUP integer
     | LOGFILE 'filename'
          [ USING BACKUP CONTROLFILE ]
     | NEXT
     | ALL
     | START
     }
     [ TO 'location' ]
   | STOP
   }

array_DML_clause

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

ASM_filename

{ fully_qualified_file_name
| numeric_file_name
| incomplete_file_name
| alias_file_name
}

attribute_clause

ATTRIBUTE level DETERMINES
   { dependent_column
   | ( dependent_column
       [, dependent_column ]... )
   }

auditing_by_clause

BY { proxy [, proxy ]...
   | user [, user ]...
   }

auditing_on_clause

ON { [ schema. ]object
   | DIRECTORY directory_name
   | DEFAULT
   }

autoextend_clause

AUTOEXTEND
   { OFF
   | ON [ NEXT size_clause ]
        [ maxsize_clause ]
   }

binding_clause

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

bitmap_join_index_clause

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

build_clause

BUILD { IMMEDIATE | DEFERRED }

C_declaration

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

call_spec

LANGUAGE { Java_declaration | C_declaration }

cancel_clause

CANCEL
 { IMMEDIATE | WAIT | NOWAIT }

cell_assignment

measure_column [ { { condition
                   | expr
                   | single_column_for_loop
                   }
                     [, { condition
                        | expr
                        | single_column_for_loop
                        }
                     ]...
                 | multi_column_for_loop
                 }
               ]

Note: The outer square brackets are part of the syntax.
      In this case, they do not indicate optionality.

cell_reference_options

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

character_set_clause

CHARACTER SET character_set

check_datafiles_clause

CHECK DATAFILES [ GLOBAL | LOCAL ]

check_diskgroup_clauses

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

checkpoint_clause

CHECKPOINT [ GLOBAL | LOCAL ]

cluster_index_clause

CLUSTER [ schema. ] cluster index_attributes

coalesce_index_partition

COALESCE PARTITION
   [ parallel_clause ]

coalesce_table_partition

COALESCE PARTITION
   [ update_index_clauses ]
   [ parallel_clause ]

column_association

COLUMNS [ schema. ]table.column
          [, [ schema. ]table.column ]...
   using_statistics_type

column_clauses

{ { add_column_clause
  | modify_column_clause
  | drop_column_clause
  }
    [ add_column_clause
    | modify_column_clause
    | drop_column_clause
    ]...
| rename_column_clause
| modify_collection_retrieval
  [ modify_collection_retrieval ]...
| modify_LOB_storage_clause
  [ modify_LOB_storage_clause ] ...
| alter_varray_col_properties
  [ alter_varray_col_properties ] ...
| REKEY encryption_spec
}

column_definition

column datatype [ SORT ]
      [ DEFAULT expr ]
      [ ENCRYPT encryption_spec ]
      [ ( inline_constraint [ inline_constraint ] ... )
      | inline_ref_constraint 
      ]


column_properties

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

commit_switchover_clause

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

compile_type_clause

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

compiler_parameters_clause

parameter_name = parameter_value

composite_partitioning

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

compute_statistics_clause

COMPUTE [ SYSTEM ] STATISTICS [ for_clause ]

conditional_insert_clause

[ ALL | FIRST ]
WHEN condition
THEN insert_into_clause
     [ values_clause ]
     [ error_logging_clause ]
     [ insert_into_clause
       [ values_clause ]
       [ error_logging_clause ]
     ]...
[ WHEN condition
  THEN insert_into_clause
       [ values_clause ]
       [ error_logging_clause ]
       [ insert_into_clause
         [ values_clause ]
         [ error_logging_clause ]
       ]...
]...
[ ELSE insert_into_clause
       [ values_clause ]
       [ error_logging_clause ]
       [ insert_into_clause
         [ values_clause ]
         [ error_logging_clause ]
       ]...
]

constraint

{ inline_constraint
| out_of_line_constraint
| inline_ref_constraint
| out_of_line_ref_constraint
}

constraint_clauses

{ ADD { out_of_line_constraint
        [ out_of_line_constraint ]...
      | out_of_line_REF_constraint
      }
| MODIFY { CONSTRAINT constraint
         | PRIMARY KEY
         | UNIQUE (column [, column ]...)
         }
         constraint_state
| RENAME CONSTRAINT old_name TO new_name
| drop_constraint_clause
}

constraint_state

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

constructor_declaration

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

constructor_spec

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

context_clause

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

controlfile_clauses

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

convert_standby_clause

CONVERT TO PHYSICAL STANDBY


cost_matrix_clause

COST MODEL

create_datafile_clause

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

create_incomplete_type

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

create_mv_refresh

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

create_nested_table_type

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

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

create_varray_type

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

database_file_clauses

{ RENAME FILE
     'filename' [, 'filename' ]...
     TO 'filename'
| create_datafile_clause
| alter_datafile_clause
| alter_tempfile_clause
}

database_logging_clauses

{ LOGFILE
    [ GROUP integer ] file_specification
      [, [ GROUP integer ] file_specification ]...
| MAXLOGFILES integer
| MAXLOGMEMBERS integer
| MAXLOGHISTORY integer
| { ARCHIVELOG | NOARCHIVELOG }
| FORCE LOGGING
}

datafile_tempfile_clauses

{ ADD { DATAFILE | TEMPFILE }
   [ file_specification
     [, file_specification ]...
   ]
| DROP {DATAFILE | TEMPFILE } { 'filename' | file_number }
| RENAME DATAFILE 'filename' [, 'filename' ]... TO
     'filename' [, 'filename' ]...
| { DATAFILE | TEMPFILE } { ONLINE | OFFLINE }
}

datafile_tempfile_spec

[ 'filename' | 'ASM_filename' ]
[ SIZE size_clause ]
[ REUSE ]
[ autoextend_clause ]

dblink

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

dblink_authentication

AUTHENTICATED BY user
IDENTIFIED BY password

db_user_proxy

db_user_proxy [ WITH { ROLE { role_name [, role_name]... 
                            | ALL EXCEPT role_name [, role_name]...
                            }
                      | NO ROLES
                      )
              ] [ AUTHENTICATION REQUIRED ]


deallocate_unused_clause

DEALLOCATE UNUSED
[ KEEP size_clause ]

default_cost_clause

DEFAULT COST (cpu_cost, io_cost, network_cost)

default_selectivity_clause

DEFAULT SELECTIVITY default_selectivity

default_tablespace

DEFAULT TABLESPACE tablespace
[ DATAFILE datafile_tempfile_spec ]
extent_management_clause

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
}

default_temp_tablespace

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

dependent_handling_clause

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

dimension_join_clause

JOIN KEY
   { child_key_column
   | (child_key_column [, child_key_column ]...)
   }
REFERENCES parent_level
  [ JOIN KEY
       { child_key_column
       | (child_key_column [, child_key_column ]...)
       }
     REFERENCES parent_level
  ]...

diskgroup_alias_clauses

{ ADD ALIAS
    'alias_name' FOR 'filename'
    [, 'alias_name' FOR 'filename' ]...
| DROP ALIAS
    'alias_name'
    [, 'alias_name' ]...
| RENAME ALIAS
    'old_alias_name' TO 'new_alias_name'
    [, 'old_alias_name' TO 'new_alias_name' ]...
}

diskgroup_availability

{ MOUNT
| DISMOUNT [ FORCE | NOFORCE ]
}

diskgroup_directory_clauses

{ ADD DIRECTORY
    'filename'
    [, 'filename' ]...
| DROP DIRECTORY
    'filename' [ FORCE | NOFORCE ]
    [, 'filename' [ FORCE | NOFORCE ] ]...
| RENAME DIRECTORY
    'old_dir_name' TO 'new_dir_name'
    [, 'old_dir_name' TO 'new_dir_name' ]...
}

diskgroup_template_clauses

{ { ADD | ALTER } TEMPLATE
      qualified_template_clause
      [, qualified_template_clause ]...
| DROP TEMPLATE
       template_name
       [, template_name ]...
}

distributed_recov_clauses

{ ENABLE | DISABLE } DISTRIBUTED RECOVERY

dml_event_clause

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

dml_table_expression_clause

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

domain_index_clause

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

drop_binding_clause

DROP BINDING
(parameter_type
 [, parameter_type ]...)
[ FORCE ]

drop_column_clause

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

drop_constraint_clause

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

drop_disk_clauses

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

drop_diskgroup_file_clause

DROP FILE
  'filename'
  [, 'filename' ]...

drop_index_partition

DROP PARTITION partition_name

drop_logfile_clauses

DROP [ STANDBY ] LOGFILE
   { logfile_descriptor
     [, logfile_descriptor ]...
   | MEMBER 'filename'
            [, 'filename' ]...
   }

drop_table_partition

DROP PARTITION partition
   [ update_index_clauses [ parallel_clause ] ]

drop_table_subpartition

DROP SUBPARTITION subpartition
   [ update_index_clauses [ parallel_clause ] ]

element_spec

[ inheritance_clauses ]
{ subprogram_spec
| constructor_spec
| map_order_function_spec
}
  [ subprogram_clause
  | constructor_spec
  | map_order_function_spec
  ]...
[, pragma_clause ]

else_clause

ELSE else_expr

enable_disable_clause

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

end_session_clauses

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

encryption_spec

[ USING 'encrypt_algorithm' ]
  [ IDENTIFIED BY password ]
  [ [NO] SALT ]


error_logging_clause

LOG ERRORS 
  [ INTO [schema.] table ]
  [ (simple_expression) ]
  [ REJECT LIMIT { integer | UNLIMITED } ]


estimate_statistics_clause

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

exceptions_clause

EXCEPTIONS INTO [ schema. ]table

exchange_partition_subpart

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

expr

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

expression_list

{ expr [, expr ]...
| (expr [, expr ]...)
}

extended_attribute_clause

ATTRIBUTE attribute
LEVEL level
DETERMINES { dependent_column
           | (dependent_column
               [, dependent_column ]...
             )
[ LEVEL level
  DETERMINES { dependent_column
             | (dependent_column
                 [, dependent_column ]...
               )
]...

extent_management_clause

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

external_data_properties

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

external_table_clause

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

file_specification

{ datafile_tempfile_spec
| redo_log_file_spec
}

finish_clause

FINISH [ FORCE ] [ WAIT | NOWAIT ]

flashback_mode_clause

FLASHBACK { ON | OFF }

flashback_query_clause

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

for_clause

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

for_update_clause

FOR UPDATE
[ OF [ [ schema. ]
       { table | view } . ]column
       [, [ [ schema. ]
            { table | view } . ]column
       ]...
]
[ NOWAIT | WAIT integer ]

full_database_recovery

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

fully_qualified_file_name

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

function_association

{ 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 ]...
}
{ using_statistics_type
| { default_cost_clause
    [, default_selectivity_clause ]
  | default_selectivity_clause
    [, default_cost_clause ]
  }
}

function_declaration

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

function_spec

FUNCTION name
   (parameter datatype [, parameter datatype ]...)
   return_clause

general_recovery

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

global_partitioned_index

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

grant_object_privileges

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

grant_system_privileges

{ system_privilege
| role
| ALL PRIVILEGES
}
  [, { system_privilege
     | role
     | ALL PRIVILEGES
     }
  ]...
TO grantee_clause
[ WITH ADMIN OPTION ]

grantee_clause

{ user [ IDENTIFIED BY password ]
| role
| PUBLIC
}
  [, { user [ IDENTIFIED BY password ]
     | role
     | PUBLIC
     } 
  ]...

group_by_clause

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

grouping_expression_list

expression_list [, expression_list ]...

grouping_sets_clause

GROUPING SETS
({ rollup_cube_clause | grouping_expression_list })

hash_partitioning

PARTITION BY HASH
(column [, column ] ...)
{ individual_hash_partitions
| hash_partitions_by_quantity
}

hash_partitions_by_quantity

PARTITIONS hash_partition_quantity
[ STORE IN
     (tablespace [, tablespace ]...) ]
[ OVERFLOW STORE IN
     (tablespace [, tablespace ]...) ]

hierarchical_query_clause

[ START WITH condition ]
CONNECT BY [ NOCYCLE ] condition

hierarchy_clause

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

implementation_clause

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

incomplete_file_name

+diskgroup_name [ (template_name) ]

index_attributes

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

index_expr

{ column | column_expression }

index_org_overflow_clause

[ INCLUDING column_name ]
OVERFLOW
[ segment_attributes_clause ]

index_org_table_clause

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

index_partition_description

PARTITION
[ partition
   [ { segment_attributes_clause
     | key_compression
     }
     [ segment_attributes_clause
     | key_compression
     ]...
   ]
]

index_partitioning_clause

PARTITION [ partition ]
   VALUES LESS THAN (literal[, literal... ])
   [ segment_attributes_clause ]

index_properties

[ { { global_partitioned_index
    | local_partitioned_index
    }
  | index_attributes
  }
      [ { { global_partitioned_index
          | local_partitioned_index
          }
        | index_attributes
        }
      ]...
| domain_index_clause
]

index_subpartition_clause

{ STORE IN (tablespace[, tablespace ]...)
| (SUBPARTITION
      [ subpartition [ TABLESPACE tablespace ] ]
   [, SUBPARTITION
         [ subpartition [ TABLESPACE tablespace ] ]
   ]...
  )
}

individual_hash_partitions

(PARTITION
    [ partition partitioning_storage_clause ]
  [, PARTITION
        [ partition partitioning_storage_clause ]
  ]...
)

inheritance_clauses

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

inline_constraint

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

inline_ref_constraint

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

inner_cross_join_clause

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

insert_into_clause

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

instance_clauses

{ ENABLE | DISABLE } INSTANCE 'instance_name'

integer

[ + | - ] digit [ digit ]...

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

interval_year_to_month

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

into_clause

INTO [ schema. ] table

invoker_rights_clause

AUTHID { CURRENT_USER | DEFINER }

Java_declaration

JAVA NAME string

join_clause

table_reference { inner_cross_join_clause | outer_join_clause 
                  [ inner_cross_join_clause | outer_join_clause ]...
                }


key_compression

{ COMPRESS [ integer ]
| NOCOMPRESS
}

level_clause

LEVEL level IS
   { level_table.level_column
   | (level_table.level_column
      [, level_table.level_column ]...
     )
   }

list_partitioning

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

list_values_clause

VALUES ({ literal | NULL }
        [, { literal | NULL }...)
       | DEFAULT
       )

LOB_parameters

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

LOB_partition_storage

PARTITION partition
{ LOB_storage_clause | varray_col_properties }
  [ LOB_storage_clause | varray_col_properties ]...
[ (SUBPARTITION subpartition
   { LOB_storage_clause | varray_col_properties }
     [ LOB_storage_clause
     | varray_col_properties
     ]...
  )
]

LOB_storage_clause

LOB
{ (LOB_item [, LOB_item ]...)
     STORE AS (LOB_parameters)
| (LOB_item)
     STORE AS
        { LOB_segname (LOB_parameters)
        | LOB_segname
        | (LOB_parameters)
        }
}

local_partitioned_index

LOCAL
[ on_range_partitioned_table
| on_list_partitioned_table
| on_hash_partitioned_table
| on_comp_partitioned_table
]

logfile_clause

LOGFILE
[ GROUP integer ] file_specification
  [, [ GROUP integer ] file_specification ]...

logfile_clauses

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

logfile_descriptor

{ GROUP integer
| ('filename' [, 'filename' ]...)
| 'filename'
}

logging_clause

{ LOGGING | NOLOGGING }

main_model

[ MAIN main_model_name ]
model_column_clauses
[ cell_reference_options ]
model_rules_clause

managed_standby_recovery

RECOVER
 { MANAGED STANDBY DATABASE
   [ { redo_apply_clauses | finish_clause | cancel_clause } ]
 |
   TO LOGICAL STANDBY db_name
 }

map_order_func_declaration

{ MAP | ORDER } MEMBER function_declaration

map_order_function_spec

{ MAP | ORDER } MEMBER function_spec

mapping_table_clauses

{ MAPPING TABLE | NOMAPPING }

materialized_view_props

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

maximize_standby_db_clause

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

maxsize_clause

MAXSIZE { UNLIMITED | size_clause }

merge_insert_clause

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

merge_table_partitions

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

merge_table_subpartitions

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

merge_update_clause

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

mining_attribute_clause

USING
{ * 
| { [ schema . ] table . * 
  | expr [ AS alias ]
  }
    [, { [ schema . ] table . * 
       | expr [ AS alias ]
       }
    ]...
}  

model_clause

MODEL
   [ cell_reference_options ]
   [ return_rows_clause ]
   [ reference_model ]
     [ reference_model ]...
   main_model

model_column

expr [ [ AS ] c_alias ]

model_column_clauses

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

model_rules_clause

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

modify_col_properties

( column [ datatype ]
         [ DEFAULT expr ]
         [ { ENCRYPT encryption_spec | DECRYPT }
         [ inline_constraint
           [ inline_constraint ]... ]
         [ LOB_storage_clause ]
  [, column [ datatype ]
            [ DEFAULT expr ]
            [ { ENCRYPT encryption_spec | DECRYPT }
            [ inline_constraint
              [ inline_constraint ]... ]
            [ LOB_storage_clause ]
  ]
)

modify_col_substitutable

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

modify_collection_retrieval

MODIFY NESTED TABLE collection_item
RETURN AS { LOCATOR | VALUE }

modify_column_clauses

MODIFY { (modify_col_properties [, modify_col_properties] ...)
       | modify_col_substitutable
       }

modify_hash_partition

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

modify_hash_subpartition

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

modify_index_default_attrs

MODIFY DEFAULT ATTRIBUTES
   [ FOR PARTITION partition ]
   { physical_attributes_clause
   | TABLESPACE { tablespace | DEFAULT }
   | logging_clause
   }
     [ physical_attributes_clause
     | TABLESPACE { tablespace | DEFAULT }
     | logging_clause
     ]...

modify_index_partition

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

modify_index_subpartition

MODIFY SUBPARTITION subpartition
{ UNUSABLE
| allocate_extent_clause
| deallocate_unused_clause
}

modify_list_partition

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

modify_list_subpartition

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

modify_LOB_parameters

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

modify_LOB_storage_clause

MODIFY LOB (LOB_item)
   (modify_LOB_parameters)

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
   }

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 varray
     }
     (LOB_parameters)
     [ { LOB (LOB_item)
       | VARRAY varray
       }
       (LOB_parameters)
     ]...
   ]

modify_table_partition

{ modify_range_partition
| modify_hash_partition
| modify_list_partition
}

modify_table_subpartition

MODIFY SUBPARTITION subpartition
{ modify_hash_subpartition
| modify_list_subpartition
}

move_table_clause

MOVE [ ONLINE ]
   [ segment_attributes_clause ]
   [ table_compression ]
   [ index_org_table_clause ]
   [ { LOB_storage_clause
     | varray_col_properties
     }
     [ { LOB_storage_clause
       | varray_col_properties
       }
     ]...
   ]
   [ parallel_clause ]

move_table_partition

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

move_table_subpartition

MOVE SUBPARTITION
   subpartition_spec
   [ update_index_clauses ]
   [ parallel_clause ]

multi_column_for_loop

FOR (dimension_column
      [, dimension_column ]...)
IN ( { (literal [, literal ]...)
       [ (literal [, literal ]...)... ]
     | subquery
     }
   )

multi_table_insert

{ ALL insert_into_clause
      [ values_clause ] [error_logging_clause]
      [ insert_into_clause
        [ values_clause ] [error_logging_clause]
      ]...
| conditional_insert_clause
}
subquery

multiset_except

nested_table1
MULTISET EXCEPT [ ALL | DISTINCT ]
nested_table2

multiset_intersect

nested_table1
MULTISET INTERSECT [ ALL | DISTINCT ]
nested_table2

multiset_union

nested_table1
MULTISET UNION [ ALL | DISTINCT ]
nested_table2

nested_table_col_properties

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

new_values_clause

{ INCLUDING | EXCLUDING } NEW VALUES

number

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

numeric_file_name

+diskgroup_name.filenumber.incarnation_number

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

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

object_table_substitution

[ NOT ] SUBSTITUTABLE AT ALL LEVELS

object_type_col_properties

COLUMN column substitutable_column_clause

object_view_clause

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

OID_clause

OBJECT IDENTIFIER IS
{ SYSTEM GENERATED | PRIMARY KEY }

OID_index_clause

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

on_comp_partitioned_table

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

on_hash_partitioned_table

{ STORE IN (tablespace[, tablespace ]...)
| (PARTITION
      [ partition [ TABLESPACE tablespace ] ]
   [, PARTITION
         [ partition [ TABLESPACE tablespace ] ]
   ]...
  )
}

on_list_partitioned_table

( PARTITION
    [ partition
      [ { segment_attributes_clause
        | key_compression
        }
          [ segment_attributes_clause
          | key_compression
          ]...
      ]
    ]
  [, PARTITION
       [ partition
         [ { segment_attributes_clause
           | key_compression
           }
             [ segment_attributes_clause
             | key_compression
             ]...
         ]
       ]
  ]...
)

on_object_clause

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

on_range_partitioned_table

( PARTITION
    [ partition
      [ { segment_attributes_clause
        | key_compression
        }
          [ segment_attributes_clause
          | key_compression
          ]...
      ]
    ]
  [, PARTITION
       [ partition
         [ { segment_attributes_clause
           | key_compression
           }
             [ segment_attributes_clause
             | key_compression
             ]...
         ]
       ]
  ]...
)

order_by_clause

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

out_of_line_constraint

[ CONSTRAINT constraint_name ]
{ UNIQUE (column [, column ]...)
| PRIMARY KEY (column [, column ]...)
| FOREIGN KEY (column [, column ]...)
     references_clause
| CHECK (condition)
}
[ 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 })
  references_clause
  [ constraint_state ]
}

outer_join_clause

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

outer_join_type

{ FULL | LEFT | RIGHT }
[ OUTER ]

parallel_clause

{ NOPARALLEL | PARALLEL [ integer ] }

parallel_enable_clause

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

partial_database_recovery

{ TABLESPACE tablespace [, tablespace ]...
| DATAFILE { 'filename' | filenumber }
             [, 'filename' | filenumber ]...
           }
| STANDBY
  { TABLESPACE tablespace [, tablespace ]...
  | DATAFILE { 'filename' | filenumber }
               [, 'filename' | filenumber ]...
             }
  }
  UNTIL [ CONSISTENT WITH ] CONTROLFILE
}

partition_attributes

[ { physical_attributes_clause
  | logging_clause
  | allocate_extent_clause
  | deallocate_unused_clause
  | shrink_clause
  }
    [ 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
  }
    [ physical_attributes_clause
    | logging_clause
    | allocate_extent_clause
    | deallocate_unused_clause
    ]...
]
[ table_compression ]
[ { LOB LOB_item | VARRAY varray }
  modify_LOB_parameters
  [ { LOB LOB_item | VARRAY varray }
    modify_LOB_parameters
  ]...
]

partition_extended_name

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

partition_level_subpartition

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

partition_spec

PARTITION [ partition ]
[ table_partition_description ]

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_segname
  }
    [ { TABLESPACE tablespace
      | OVERFLOW [ TABLESPACE tablespace ]
      | LOB (LOB_item) STORE AS
        { LOB_segname [ (TABLESPACE tablespace) ]
        | (TABLESPACE tablespace)
        }
      | VARRAY varray_item STORE AS LOB LOB_segname
      }
    ]...
]

password_parameters

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

permanent_tablespace_clause

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

physical_attributes_clause

[ { PCTFREE integer
  | PCTUSED integer
  | INITRANS integer
  | storage_clause
  }
    [ PCTFREE integer
    | PCTUSED integer
    | INITRANS integer
    | storage_clause
    ]...
]

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 [, column ]...)
}

pragma_clause

PRAGMA RESTRICT_REFERENCES
({ method_name | DEFAULT } ,
 { RNDS | WNDS | RNPS | WNPS | TRUST }
   [, { RNDS | WNDS | RNPS | WNPS | TRUST } ]...
)

procedure_declaration

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

procedure_spec

PROCEDURE name
(parameter datatype [, parameter datatype ]...)
[ { IS | AS } call_spec ]

proxy_clause

{ GRANT | REVOKE }
CONNECT THROUGH { ENTERPRISE USERS
                | db_user_proxy
                }

qualified_disk_clause

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

qualified_template_clause

template_name
ATTRIBUTES
([ MIRROR | UNPROTECTED ]
 [ FINE | COARSE ]
)

query_partition_clause

PARTITION BY
  { value_expr[, value_expr ]...
  | ( value_expr[, value_expr ]... )
  }

query_table_expression

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

quiesce_clauses

QUIESCE RESTRICTED | UNQUIESCE

range_partitioning

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

range_values_clause

VALUES LESS THAN
  ({ literal | MAXVALUE }
     [, { literal | MAXVALUE } ]...
  )

rebalance_diskgroup_clause

REBALANCE [POWER integer] [WAIT | NOWAIT]

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
  ]
    [ parallel_clause
    | TABLESPACE tablespace
    | PARAMETERS ('ODCI_parameters')
    | ONLINE
    | COMPUTE STATISTICS
    | physical_attributes_clause
    | key_compression
    | logging_clause
    ]...

records_per_block_clause

{ MINIMIZE | NOMINIMIZE } RECORDS_PER_BLOCK

recovery_clauses

{ general_recovery
| managed_standby_recovery
| BEGIN BACKUP
| END BACKUP
}

redo_apply_clauses

{ USING CURRENT LOGFILE
 | NOPARALLEL
 | DISCONNECT [ FROM SESSION ]
 | NODELAY
 | UNTIL CHANGE integer
 }
  [ { USING CURRENT LOGFILE
    | NOPARALLEL
    | DISCONNECT [ FROM SESSION ]
    | NODELAY
    | UNTIL CHANGE integer
    } ]...

redo_log_file_spec

[ 'filename | ASM_filename'
| ('filename | ASM_filename'
   [, 'filename | ASM_filename' ]...)
]
[ SIZE size_clause ]
[ REUSE ]

reference_model

REFERENCE reference_spreadsheet_name
ON (subquery)
spreadsheet_column_clauses
[ cell_reference_options ]

references_clause

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

referencing_clause

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

register_logfile_clause

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

relational_properties

{ column_definition
| { out_of_line_constraint
  | out_of_line_ref_constraint
  | supplemental_logging_props
  }
}
  [, { column_definition
     | { out_of_line_constraint
       | out_of_line_ref_constraint
       | supplemental_logging_props
       }
  ]...

relational_table

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

rename_column_clause

RENAME COLUMN old_name TO new_name

rename_index_partition

RENAME { PARTITION partition
       | SUBPARTITION subpartition }
   TO new_name

rename_partition_subpart

RENAME { PARTITION | SUBPARTITION }
  current_name TO new_name

replace_type_clause

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

resize_disk_clauses

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

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
  { size_clause | UNLIMITED | DEFAULT }
}

return_clause

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

return_rows_clause

RETURN { UPDATED | ALL } ROWS

returning_clause

RETURNING expr [, expr ]...
INTO data_item [, data_item ]...

revoke_object_privileges

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

revoke_system_privileges

{ system_privilege
| role
| ALL PRIVILEGES
}
  [, { system_privilege
     | role
     | ALL PRIVILEGES
     }
  ]...
FROM grantee_clause

rollup_cube_clause

{ ROLLUP | CUBE } (grouping_expression_list)

routine_clause

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

row_movement_clause

{ ENABLE | DISABLE } ROW MOVEMENT

sample_clause

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

schema_object_clause

{ object_option [, object_option ]... | ALL }
auditing_on_clause

scoped_table_ref_constraint

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

searched_case_expression

WHEN condition THEN return_expr
[ WHEN condition THEN return_expr ]...

security_clause

GUARD { ALL | STANDBY | NONE }

segment_attributes_clause

{ physical_attributes_clause
| TABLESPACE tablespace
| logging_clause
}
  [ physical_attributes_clause
  | TABLESPACE tablespace
  | logging_clause
  ]...

segment_management_clause

SEGMENT SPACE MANAGEMENT { AUTO | MANUAL }

select_list

{ *
| { query_name.*
  | [ schema. ]
    { table | view | materialized view } .*
  | expr [ [ AS ] c_alias ]
  }
    [, { query_name.*
       | [ schema. ]
         { table | view | materialized view } .*
       | expr [ [ AS ] c_alias ]
       }
    ]...
}

set_subpartition_template

SET SUBPARTITION TEMPLATE
   { (SUBPARTITION subpartition
         [ list_values_clause ]
         [ partitioning_storage_clause ]
       [, SUBPARTITION subpartition
             [ list_values_clause ]
             [ partitioning_storage_clause ]...
       ]
      )
   | hash_subpartition_quantity
   }

set_time_zone_clause

SET TIME_ZONE =
   '{ { + | - } hh : mi | time_zone_region }'

shrink_clause

SHRINK SPACE [ COMPACT ] [ CASCADE ]

shutdown_dispatcher_clause

SHUTDOWN [ IMMEDIATE ] dispatcher_name

simple_case_expression

expr WHEN comparison_expr
     THEN return_expr
     [ WHEN comparison_expr
       THEN return_expr ]...

single_column_for_loop

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

single_table_insert

insert_into_clause
{ values_clause [ returning_clause ]
| subquery 
}
[ error_logging_clause ]

size_clause

integer [ K | M | G | T | P | E ]

split_index_partition

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

split_table_partition

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

split_table_subpartition

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

sql_statement_clause

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

sqlj_object_type

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

sqlj_object_type_attr

EXTERNAL NAME 'field_name'

sqlj_object_type_sig

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

standby_database_clauses

( activate_standby_db_clause
| maximize_standby_db_clause
| register_logfile_clause
| commit_switchover_clause
| start_standby_clause
| stop_standby_clause
| convert_standby_clause
)
[ parallel_clause ]

start_standby_clause

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

startup_clauses

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

stop_standby_clause

{ STOP | ABORT }
LOGICAL STANDBY APPLY

storage_clause

STORAGE
   ({ INITIAL size_clause
    | NEXT size_clause
    | MINEXTENTS integer
    | MAXEXTENTS { integer | UNLIMITED }
    | PCTINCREASE integer
    | FREELISTS integer
    | FREELIST GROUPS integer
    | OPTIMAL [ size_clause
              | NULL
              ]
    | BUFFER_POOL { KEEP | RECYCLE | DEFAULT }
    }
      [ INITIAL size_clause
      | NEXT size_clause
      | MINEXTENTS integer
      | MAXEXTENTS { integer | UNLIMITED }
      | PCTINCREASE integer
      | FREELISTS integer
      | FREELIST GROUPS integer
      | OPTIMAL [ size_clause
                | NULL
                ]
      | BUFFER_POOL { KEEP | RECYCLE | DEFAULT }
      ]...
   )

streaming_clause

{ ORDER | CLUSTER } expr BY (column [, column ]...)

subpartition_by_hash

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

subpartition_by_list

SUBPARTITION BY LIST (column)
   [ subpartition_template ]

subpartition_spec

SUBPARTITION [ subpartition ]
   [ list_values_clause ]
   [ partitioning_storage_clause ]

subpartition_template

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

subprogram_declaration

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

subprogram_spec

{ MEMBER | STATIC }
{ procedure_spec | function_spec }

subquery

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

subquery_factoring_clause

WITH query_name AS (subquery)
     [, query_name AS (subquery) ]...

subquery_restriction_clause

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

substitutable_column_clause

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

supplemental_db_logging

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

supplemental_id_key_clause

DATA
({ ALL
 | PRIMARY KEY
 | UNIQUE
 | FOREIGN KEY
 }
   [, { ALL
      | PRIMARY KEY
      | UNIQUE
      | FOREIGN KEY
      }
  ]...
)
COLUMNS

supplemental_log_grp_clause

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

supplemental_logging_props

{ supplemental_log_grp_clause
| supplemental_id_key_clause
}

supplemental_table_logging

{ ADD SUPPLEMENTAL LOG
        { supplemental_log_grp_clause
        | supplemental_id_key_clause
        }
      [, SUPPLEMENTAL LOG
           { supplemental_log_grp_clause
           | supplemental_id_key_clause
           }
      ]...
| DROP SUPPLEMENTAL LOG
         { supplemental_id_key_clause
         | GROUP log_group
         }
       [, SUPPLEMENTAL LOG
            { supplemental_id_key_clause
            | GROUP log_group
            }
       ]...
}

table_collection_expression

TABLE (collection_expression) [ (+) ]

table_compression

{ COMPRESS | NOCOMPRESS }

table_index_clause

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

table_partition_description

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

table_partitioning_clauses

{ range_partitioning
| hash_partitioning
| list_partitioning
| composite_partitioning
}

table_properties

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

table_reference

{ ONLY
  (query_table_expression)
  [ flashback_query_clause ]
  [ t_alias ]
| query_table_expression
  [ flashback_query_clause ]
  [ t_alias ]
}

tablespace_clauses

{ EXTENT MANAGEMENT LOCAL
| DATAFILE file_specification
           [, file_specification ]...
| SYSAUX DATAFILE file_specification
                  [, file_specification ]...
| default_tablespace
| default_temp_tablespace
| undo_tablespace
}

tablespace_group_clause

TABLESPACE GROUP { tablespace_group_name | '' }

tablespace_logging_clauses

{ logging_clause
| [ NO ] FORCE LOGGING
}

tablespace_retention_clause

RETENTION { GUARANTEE | NOGUARANTEE }

tablespace_state_clauses

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

temporary_tablespace_clause

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

text

[ {N | n} ]
{ 'c [ c ]...'
| { Q | q }
  'quote_delimiter c [ c ]... quote_delimiter'
}

trace_file_clause

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

truncate_partition_subpart

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

undo_tablespace

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

undo_tablespace_clause

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

undrop_disk_clause

UNDROP DISKS

update_all_indexes_clause

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

update_global_index_clause

{ UPDATE | INVALIDATE } GLOBAL INDEXES

update_index_clauses

{ update_global_index_clause
| update_all_indexes_clause
}

update_index_partition

index_partition_description
     [ index_subpartition_clause ]
[, index_partition_description
      [ index_subpartition_clause ] ...


update_index_subpartition

SUBPARTITION [ subpartition ]
   [ TABLESPACE tablespace ]
[, SUBPARTITION [ subpartition ]
      [ TABLESPACE tablespace ]
]...

update_set_clause

SET
{ { (column [, column ]...) = (subquery)
  | column = { expr | (subquery) | DEFAULT }
  }
     [, { (column [, column]...) = (subquery)
        | column = { expr | (subquery) | DEFAULT }
        }
     ]...
| VALUE (t_alias) = { expr | (subquery) }
}

upgrade_table_clause

UPGRADE [ [NOT ] INCLUDING DATA ]
   [ column_properties ]

using_function_clause

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

using_index_clause

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

using_statistics_type

USING { [ schema. ] statistics_type | NULL }

using_type_clause

USING [ schema. ]implementation_type
[ array_DML_clause ]

validation_clauses

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

values_clause

VALUES ({ expr | DEFAULT }
          [, { expr | DEFAULT } ]...
       )

varray_col_properties

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

where_clause

WHERE condition

windowing_clause

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

XML_attributes_clause

XMLATTRIBUTES
  (value_expr [ AS c_alias ]
    [, value_expr [ AS c_alias ]
      ]...
  )

XML_namespaces_clause

XMLNAMESPACES
  ( [ string AS identifier ]
      [ [, string AS identifier ]
      ]... 
    [ DEFAULT string ]
  )

XML_passing_clause

PASSING [ BY VALUE ] 
    expr [ AS identifier ]
      [, expr [ AS identifier ] 
      ]...

XML_table_column

column 
     { FOR ORDINALITY 
     | datatype [ PATH string ] [ DEFAULT expr ]
     }

XMLSchema_spec

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

XMLType_column_properties

XMLTYPE [ COLUMN ] column
   [ XMLType_storage ]
   [ XMLSchema_spec ]

XMLType_storage

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

XMLType_table

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

XMLType_view_clause

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