Skip Headers
Oracle® Database SQL Language Quick Reference
11g Release 2 (11.2)

Part Number E10593-04
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

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 | virtual_column_definition
      [, column_definition | virtual_column_definition] ...
   }
   [ column_properties ]
   [ out_of_line_part_storage [, out_of_line_part_storage]...]

add_disk_clause

ADD
  { [ QUORUM | REGULAR ] [ FAILGROUP failgroup_name ]
    DISK qualified_disk_clause [, qualified_disk_clause ]...
  }...

add_hash_index_partition

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

add_hash_partition_clause

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

add_hash_subpartition

ADD hash_subpartition_desc
   [ dependent_tables_clause ]
   [ update_index_clauses ]
   [ parallel_clause ]

add_list_partition_clause

ADD PARTITION [ partition ]
   list_values_clause
   [ table_partition_description ]
   [ { range_subpartition_desc
     | list_subpartition_desc
     | hash_subpartition_desc
     }
   ]
   [ update_index_clauses ]

add_list_subpartition

ADD list_subpartition_desc [ dependent_tables_clause ] [ 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_mv_log_column_clause

ADD (column)

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 ]
   [ ( { range_subpartition_desc
       | list_subpartition_desc
       | hash_subpartition_desc
       }
      )
   ]
   [ update_index_clauses ]

add_range_subpartition

ADD range_subpartition_desc [ dependent_tables_clause ] [ update_index_clauses ]

add_system_partition_clause

[BEFORE { partition_name | partition_number }]
[table_partition_description]
[update_index_clauses]

add_table_partition

{ add_range_partition_clause
| add_hash_partition_clause
| add_list_partition_clause
} [ dependent_tables_clause ]

add_volume_clause

ADD VOLUME asm_volume SIZE size_clause [redundancy_clause]
  [ STRIPE_WIDTH integer {K | M} ]
  [ STRIPE_COLUMNS integer ]
  [ ATTRIBUTE disk_region_clause ]

alias_file_name

+diskgroup_name [ (template_name) ] /alias_name

allocate_extent_clause

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

alter_datafile_clause

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

alter_external_table

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

{ SET INTERVAL ( expr )
| SET STORE IN ( tablespace [, tablespace]... )
}

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

{ add_overflow_clause
| OVERFLOW
     { segment_attributes_clause
     | allocate_extent_clause
     | shrink_clause
     | deallocate_unused_clause
     }...
}

alter_session_set_clause

SET { { parameter_name = parameter_value }...
    | EDITION = edition_name
    }

alter_system_reset_clause

parameter_name
   [ { SCOPE = SPFILE 
     | SID = { 'sid' | '*' }
     }...
   ]

alter_system_set_clause

{ set_parameter_clause
| USE_STORED_OUTLINES = (TRUE | FALSE | category_name)
| GLOBAL_TOPIC_ENABLED = (TRUE | FALSE)
}

alter_table_partitioning

{ modify_table_default_attrs
| alter_interval_partitioning
| set_subpartition_template
| modify_table_partition
| modify_table_subpartition
| move_table_partition
| move_table_subpartition
| add_table_partition
| coalesce_table_partition
| coalesce_table_subpartition
| 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
    | { CACHE | NOCACHE }
    | RESULT_CACHE ( MODE {DEFAULT | FORCE} )
    | upgrade_table_clause
    | records_per_block_clause
    | parallel_clause
    | row_movement_clause
    | flashback_archive_clause
    }...
  | RENAME TO new_table_name
  } [ alter_iot_clauses ] [ alter_XMLSchema_clause ]
| { shrink_clause 
  | READ ONLY 
  | READ WRITE 
  | REKEY encryption_spec 
  }
}

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 )

alter_XMLSchema_clause

{ ALLOW ANYSCHEMA
| ALLOW NONSCHEMA
| DISALLOW NONSCHEMA
}

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
     }
     [ TO 'location' ]
   }

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

audit_operation_clause

{ { sql_statement_shortcut
  | ALL
  | ALL STATEMENTS
  } [, { sql_statement_shortcut
       | ALL
       }
    ]
| { system_privilege
  | ALL PRIVILEGES
  } [, { system_privilege
       | ALL PRIVILEGES
       }
    ]
} [ auditing_by_clause ]

audit_schema_object_clause

{ sql_operation [, object_option]
| ALL
} auditing_on_clause

auditing_by_clause

{ BY { proxy [, proxy ]...
  | user [, user ]...
  }
| IN SESSION CURRENT
}

auditing_on_clause

ON { [ schema. ] object
   | DIRECTORY directory_name
   | MINING MODEL [ schema. ] model
   | 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 }

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_clause

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

coalesce_table_subpartition

COALESCE SUBPARTITION subpartition [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
  }...
| rename_column_clause
| { modify_collection_retrieval }...
| { modify_LOB_storage_clause }...
| { alter_varray_col_properties }...
}

column_definition

column datatype [ SORT ]
  [ DEFAULT expr ]
  [ ENCRYPT encryption_spec ]
  [ ( { 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
}...

commit_switchover_clause

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

composite_hash_partitions

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

composite_list_partitions

PARTITION BY LIST ( column )
  { subpartition_by_range
  | subpartition_by_hash
  | subpartition_by_list
  }
( { PARTITION [partition] list_partition_desc }... )

composite_range_partitions

PARTITION BY RANGE ( column [, column]... )
  [ INTERVAL ( expr ) [ STORE IN ( tablespace [, tablespace]... ) ]]
  { subpartition_by_range
  | subpartition_by_list
  | subpartition_by_hash
  }
( { PARTITION [partition] range_partition_desc }... )

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

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_database_clause

CONVERT TO ( PHYSICAL | SNAPSHOT ) STANDBY

cost_matrix_clause

COST
  { MODEL [AUTO]
  | ( class_value [, class_value]... )
        VALUES ( ( cost_value [, cost_value]...) 
                 [ , (cost_value [, cost_value]... ) ]...
               )
  }

create_datafile_clause

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

create_mv_refresh

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

cycle_clause

{CYCLE c_alias [, c_alias]...
    SET cycle_mark_c_alias TO cycle_value
    DEFAULT no_cycle_value
}

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 }
| SHRINK TEMPFILE { 'filename' | file_number } [KEEP size_clause]
| RENAME DATAFILE 'filename' [, 'filename' ]...
    TO 'filename' [, 'filename' ]...
| { DATAFILE | TEMPFILE } { ONLINE | OFFLINE }
}

datafile_tempfile_spec

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

db_user_proxy

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

dblink

database[.domain [.domain ]... ] [ @ connection_qualifier ]

dblink_authentication

AUTHENTICATED BY user IDENTIFIED BY password

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

DEFAULT TABLESPACE tablespace
[ DATAFILE datafile_tempfile_spec ]
extent_management_clause

default_temp_tablespace

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

deferred_segment_creation

SEGMENT CREATION { IMMEDIATE | DEFERRED }

dependent_tables_clause

DEPENDENT TABLES
( table ( partition_spec [, partition_spec]... 
          [, table ( partition_spec [, partition_spec]... ]
        )
)

dimension_join_clause

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

disk_offline_clause

OFFLINE
  { [QUORUM | REGULAR] DISK disk_name [, disk_name ] ...
  | DISKS IN [QUORUM | REGULAR] FAILGROUP failgroup_name [, failgroup_name ]...
  } ... [timeout_clause]

disk_online_clause

ONLINE
  { { [QUORUM | REGULAR] DISK disk_name [, disk_name]...
    | DISKS IN [QUORUM | REGULAR] FAILGROUP failgroup_name [, failgroup_name]...
    } ...
  | ALL
  } [ WAIT | NOWAIT ]

disk_region_clause

[ HOT | COLD ] [ MIRRORHOT | MIRRORCOLD ]

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_attributes

SET ATTRIBUTE 'attribute_name' = 'attribute_value'

diskgroup_availability

{ MOUNT [ RESTRICTED | NORMAL ] 
           [ FORCE | NOFORCE ]
| 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 | MODIFY } TEMPLATE template_name
      qualified_template_clause [, qualified_template_clause ]...
| DROP TEMPLATE template_name [, template_name ]...
}

diskgroup_volume_clauses

{ add_volume_clause
| modify_volume_clause
| RESIZE VOLUME asm_volume SIZE size_clause
| DROP VOLUME asm_volume
}

distributed_recov_clauses

{ ENABLE | DISABLE } DISTRIBUTED RECOVERY

dml_table_expression_clause

{ [ schema. ]
  { table
    [ partition_extension_clause
    | @ dblink
    ]
  | { view | materialized view } [ @ dblink ]
  }
| ( subquery [ subquery_restriction_clause ] )
| table_collection_expression
}

domain_index_clause

indextype
   [ local_domain_index_clause ]
   [ 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 }... ]
| DROP { COLUMN column
       | (column [, column ]...)
       }
  [ { 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
{ [QUORUM | REGULAR] DISK
    disk_name [ FORCE | NOFORCE ]
    [, disk_name [ FORCE | NOFORCE ] ]...
| DISKS IN [QUORUM | REGULAR] 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_extended_name
   [ update_index_clauses [ parallel_clause ] ]

drop_table_subpartition

DROP subpartition_extended_name
   [ update_index_clauses [ parallel_clause ] ]

ds_iso_format

[-] P [days D] T [hours H] [minutes M] 
    [seconds [. frac_secs] S]

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 ]

enable_disable_volumes

{ ENABLE | DISABLE } VOLUME
  { asm_volume [, asm_volume]...
  | ALL
  }

encryption_spec

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

end_session_clauses

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

error_logging_clause

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

exceptions_clause

EXCEPTIONS INTO [ schema. ] table

exchange_partition_subpart

EXCHANGE { partition_extended_name
         | subpartition_extended_name
         }
   WITH TABLE [ schema. ] 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 ]... )
               }
  }...

extent_management_clause

EXTENT MANAGEMENT LOCAL
  [ AUTOALLOCATE
  | UNIFORM [ SIZE size_clause ]
  ]

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_owner_clause

SET OWNERSHIP { OWNER = user | GROUP = usergroup 
                  [, OWNER = user | GROUP = usergroup ]...
              } FOR FILE 'filename' [, 'filename']...

file_permissions_clause

SET PERMISSION { OWNER | GROUP | OTHER }
  = { NONE | READ ONLY | READ WRITE }
  [, { OWNER | GROUP | OTHER | ALL }
    = { NONE | READ ONLY | READ WRITE } ]...
    FOR FILE 'filename' [, 'filename']...

file_specification

{ datafile_tempfile_spec
| redo_log_file_spec
}

flashback_archive_clause

FLASHBACK ARCHIVE [flashback_archive] | NO FLASHBACK ARCHIVE

flashback_archive_quota

QUOTA integer {K| M| G| T| P| E}

flashback_archive_retention

RETENTION integer {YEAR | MONTH | DAY}

flashback_mode_clause

FLASHBACK { ON | OFF }

flashback_query_clause

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

for_update_clause

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

full_database_recovery

[ STANDBY ] DATABASE
[ { UNTIL { CANCEL
          | TIME date
          | CHANGE integer
          | CONSISTENT
          }
  | 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 ]
  }
}

general_recovery

RECOVER
[ AUTOMATIC ]
[ FROM 'location' ]
{ { full_database_recovery
  | partial_database_recovery
  | LOGFILE 'filename'
  }
  [ { TEST
    | ALLOW integer CORRUPTION
    | parallel_clause
    }...
  ]
| 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_partitions

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

hash_partitions_by_quantity

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

hash_subparts_by_quantity

SUBPARTITIONS integer [STORE IN ( tablespace [, tablespace]... )]

hierarchical_query_clause

{ CONNECT BY [ NOCYCLE ] condition [AND condition]... [ START WITH condition ]
| START WITH condition CONNECT BY [ NOCYCLE ] condition [AND condition]...
}

hierarchy_clause

HIERARCHY hierarchy
(child_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
  | TABLESPACE { tablespace | DEFAULT }
  | key_compression
  | { SORT | NOSORT }
  | REVERSE
  | VISIBLE | INVISIBLE
  | 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
  }...
]
[ index_org_overflow_clause ]

index_partition_description

PARTITION
[ partition
   [ { segment_attributes_clause
     | key_compression
     }...
   | ( PARAMETERS 'ODCI_parameters' )
   ] [ UNUSABLE ]
]

index_partitioning_clause

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

index_properties

[ { { global_partitioned_index
    | local_partitioned_index
    }
  | index_attributes
  }...
| INDEXTYPE IS { domain_index_clause
                      | XMLTable_index_clause
                      | XMLIndex_clause
                      }
]

index_subpartition_clause

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

individual_hash_partitions

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

individual_hash_subparts

SUBPARTITION [subpartition] [partitioning_storage_clause]

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 }

join_clause

table_reference
  { 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_partition_desc

list_values_clause
table_partition_description
  [ ( "(" ( ("range_subpartition_desc"/",")
          | ("list_subpartition_desc"/",")
          | ("individual_hash_subparts"/",")
          )
      ")"
    ) | "hash_subparts_by_quantity"
  ]

list_partitions

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

list_subpartition_desc

SUBPARTITION [subpartition]
  list_values_clause
  [partitioning_storage_clause]

list_values_clause

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

LOB_compression_clause

{ COMPRESS [HIGH | MEDIUM | LOW ]
| NOCOMPRESS
}

LOB_deduplicate_clause

{ DEDUPLICATE   
| KEEP_DUPLICATES
}

LOB_parameters

{ { ENABLE | DISABLE } STORAGE IN ROW
  | CHUNK integer
  | PCTVERSION integer
  | FREEPOOLS integer
  | LOB_retention_clause
  | LOB_deduplicate_clause
  | LOB_compression_clause
  | { ENCRYPT encryption_spec | DECRYPT }
  | { CACHE | NOCACHE | CACHE READS } [ logging_clause ] 
}...

LOB_partition_storage

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

LOB_partitioning_storage

LOB (LOB_item) STORE AS [BASICFILE | SECUREFILE]
  [ LOB_segname [ (TABLESPACE tablespace) ]
  | (TABLESPACE tablespace)
  ]

LOB_retention_storage

RETENTION [ MAX | MIN integer | AUTO | NONE ]

LOB_storage_clause

LOB
{ (LOB_item [, LOB_item ]...)
     STORE AS { {SECUREFILE | BASICFILE}
              | (LOB_storage_parameters)
              }...
| (LOB_item)
     STORE AS { {SECUREFILE | BASICFILE}
              | LOB_segname 
              | (LOB_storage_parameters)
              }...
}

LOB_storage_parameters

{ { TABLESPACE tablespace
  | LOB_parameters [storage_clause]
  }...
| storage_clauase
}

local_domain_index_clause

LOCAL
  [ ( PARTITION partition [ PARAMETERS ( 'ODCI_parameters' ) ]
      [,  PARTITION partition [ PARAMETERS ('ODCI_parameters') ]]...
    )
  ]

local_partitioned_index

LOCAL
[ on_range_partitioned_table
| on_list_partitioned_table
| on_hash_partitioned_table
| on_comp_partitioned_table
]

local_XMLIndex_clause

LOCAL
  [ ( PARTITION partition [ XMLIndex_parameters_clause ]
      [, PARTITION partition [ XMLIndex_parameters)clause ]]...
    )
  ]

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

logfile_descriptor

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

logging_clause

{ LOGGING | NOLOGGING |  FILESYSTEM_LIKE_LOGGING }

main_model

[ MAIN main_model_name ]
model_column_clauses
[ cell_reference_options ]
model_rules_clause

managed_standby_recovery

RECOVER
{ MANAGED STANDBY DATABASE
    [ { USING CURRENT LOGFILE
      | DISCONNECT [FROM SESSION]
      | NODELAY
      | UNTIL CHANGE integer
      | UNTIL CONSISTENT
      }...
    | FINISH
    | CANCEL
    ]
| TO LOGICAL STANDBY { db_name | KEEP IDENTITY }
}

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_extended_name, partition_extended_name
   [ INTO partition_spec ]
   [ dependent_tables_clause ]
   [ update_index_clauses ]
   [ parallel_clause ]

merge_table_subpartitions

MERGE SUBPARTITIONS partition_extended_name, partition_extended_name
   [ INTO { range_subpartition_desc 
          | list_subpartition_desc
          }
   ]
   [ dependent_tables_clause ]
   [ 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 ]...
main_model

model_column

expr [ [ AS ] c_alias ]

model_column_clauses

[ PARTITION BY expr [ c_alias ] [, expr [c_alias] ]...
DIMENSION BY (expr [c_alias] [, expr [c_alias] ]...)
MEASURES (expr [c_alias] [, expr [c_alias] ]...)

model_iterate_clause

ITERATE ( number ) [ UNTIL ( condition ) ]

model_rules_clause

[ RULES
  [ { UPDATE | UPSERT [ ALL ] } ]
  [ { AUTOMATIC | SEQUENTIAL } ORDER ]
  [ model_iterate_clause ]
]
( [ { 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 ...
       [ LOB_storage_clause ]
       [ alter_XMLSchema_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_diskgroup_file

MODIFY FILE 'filename' ATTRIBUTE ( disk_region_clause )
  [, 'filename' ATTRIBUTE ( disk_region_clause ) ]...

modify_hash_partition

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

modify_index_default_attrs

MODIFY DEFAULT ATTRIBUTES
   [ FOR PARTITION partition ]
   { 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
  }...
| 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_extended_name
  { partition_attributes
  | { ADD | DROP } VALUES (literal[ , literal ]...)
  | { add_range_subpartition
    | add_list_subpartition
    | add_hash_subpartition 
    }
  | COALESCE SUBPARTITION [ update_index_clauses ][ parallel_clause ]
  | [ REBUILD ] UNUSABLE LOCAL INDEXES
  }

modify_LOB_parameters

{ storage_clause
| PCTVERSION integer
| FREEPOOLS integer
| REBUILD FREEPOOLS
| LOB_retention_clause
| LOB_deduplicate_clause
| LOB_compression_clause
| { ENCRYPT encryption_spec | DECRYPT }
| { 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_mv_column_clause

MODIFY ( column [ ENCRYPT encryption_spec
       | DECRYPT ] 
       )

modify_range_partition

MODIFY partition_extended_name
   { partition_attributes
   | { add_range_subpartition
     | 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_extended_name ]
   [ segment_attributes_clause ]
   [ table_compression ]
   [ PCTTHRESHOLD integer ]
   [ key_compression ]
   [ alter_overflow_clause ]
   [ { LOB (LOB_item) | VARRAY varray } (LOB_parameters) ]...

modify_table_partition

{ modify_range_partition
| modify_hash_partition
| modify_list_partition
}

modify_table_subpartition

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

modify_volume_clause

MODIFY VOLUME asm_volume
  [ ATTRIBUTE disk_region_clause ]
  [ MOUNTPATH 'mountpath_name' ]
  [ USAGE 'usage_name' ]

move_mv_log_clause

MOVE segment_attributes_clause [parallel_clause]

move_table_clause

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

move_table_partition

MOVE partition_extended_name
   [ MAPPING TABLE ]
   [ table_partition_description ]
   [ update_index_clauses ]
   [ parallel_clause ]

move_table_subpartition

MOVE SUBPARTITION
   { range_subpartition_desc
   | list_subpartition_desc
   | hash_subpartition_desc
   } [ 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] }...
| 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

mv_log_augmentation

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

mv_log_purge_clause

PURGE { IMMEDIATE [ SYNCHRONOUS | ASYNCHRONOUS ]  )
      | START WITH datetime_expr 
          [ NEXT datetime_expr 
          | REPEAT INTERVAL interval_expr 
          ]
      | [ START WITH datetime_expr ] { NEXT datetime_expr
                                     | REPEAT INTERVAL interval_expr
                                     }
      }

nested_table_col_properties

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

nested_table_partition_spec

PARTITION partition [segment_attributes_clause]

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_ref_constraint ]
| { out_of_line_constraint
  | out_of_line_ref_constraint
  | supplemental_logging_props
  }
}

object_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 }...
    }  [, { out_of_line_constraint
          | attribute { inline_constraint }...
          }
       ]...
  )
]

OID_clause

OBJECT IDENTIFIER IS
{ SYSTEM GENERATED | PRIMARY KEY }

OID_index_clause

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

on_comp_partitioned_table

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

on_hash_partitioned_table

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

on_list_partitioned_table

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

on_object_clause

{ [ schema. ] object 
| { DIRECTORY directory_name
  | EDITION edition_name
  | MINING MODEL [schema.] mining_model_name
  | JAVA { SOURCE | RESOURCE } [ schema. ] object
  }
}

on_range_partitioned_table

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

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_part_storage

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

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

partial_database_recovery

{ TABLESPACE tablespace [, tablespace ]...
| DATAFILE { 'filename' | filenumber }
             [, 'filename' | filenumber ]...
}

partition_attributes

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

partition_extended_name

PARTITION partition
| 
PARTITION FOR ( partition_key_value [, partition_key_value]... )

partition_extension_clause

{ PARTITION (partition)
| PARTITION FOR (partition_key_value [, partition_key_value]...)
| SUBPARTITION (subpartition)
| SUBPARTITION FOR (subpartition_key_value [, subpartition_key_value]...)
}

partition_spec

PARTITION [ partition ] [ table_partition_description ]

partitioning_storage_clause

[ { TABLESPACE tablespace
  | OVERFLOW [TABLESPACE tablespace]
  | table_compression
  | key_compression
  | LOB_partitioning_storage
  | VARRAY varray_item STORE AS [SECUREFILE | BASICFILE] 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

TABLESPACE tablespace
  [ DATAFILE file_specification [, file_specification ]... ]
{ MINIMUM EXTENT size_clause
| BLOCKSIZE integer [ K ]
| logging_clause
| FORCE LOGGING
| ENCRYPTION encryption_spec
| 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
  }...
]

physical_properties

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

pivot_clause

table_reference PIVOT [ XML ]
  ( aggregate_function ( expr ) [[AS] alias ]
      [, aggregate_function ( expr ) [[AS] alias ] ]...
    pivot_for_clause
    pivot_in_clause
  )

pivot_for_clause

FOR { column
    | ( column [, column]... )
    }

pivot_in_clause

IN ( { { { expr
         | ( expr [, expr]... )
         } [ [ AS] alias]
       }...
     | subquery
     | ANY [, ANY]...
     }
   )

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

ATTRIBUTE
( redundancy_clause 
  striping_clause 
  disk_region_clause
)

query_block

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

query_partition_clause

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

query_table_expression

{ query_name
| [ schema. ]
  { table [ partition_extension_clause
          | @ dblink
          ]
  | { view | materialized view } [ @ dblink ]
  } ["sample_clause"]
| (subquery [ subquery_restriction_clause ])
| table_collection_expression
}

quiesce_clauses

QUIESCE RESTRICTED | UNQUIESCE

range_partition_desc

range_values_clause
table_partition_description
[ ( { range_subpartition_desc [, range_subpartition_desc] ...
    | list_subpartition_desc [, list_subpartition_desc] ...
    | individual_hash_subparts [, individual_hash_subparts] ...
    }
  ) | hash_subparts_by_quantity ]

range_partitions

PARTITION BY RANGE (column[, column ]...)
  [ INTERVAL expr [ STORE IN ( tablespace [, tablespace]...) ]]
( PARTITION [ partition ]
    range_values_clause table_partition_description
      [, PARTITION [ partition ]
        range_values_clause table_partition_description
      ]...
)

range_subpartition_desc

SUBPARTITION [subpartition] range_values_clause
  [partitioning_storage_clause]

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' )
  | XMLIndex_parameters_clause
  | ONLINE
  | 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_log_file_spec

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

redundancy_clause

[ MIRROR | HIGH | UNPROTECTED ]

reference_model

REFERENCE reference_spreadsheet_name
ON (subquery)
spreadsheet_column_clauses
  [ cell_reference_options ]

reference_partition_desc

PARTITION [partition] [table_partition_description] )

reference_partitioning

PARTITION BY REFERENCE ( constraint ) 
  [ (reference_partition_desc...) ]

references_clause

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

register_logfile_clause

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

relational_properties

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

relational_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_extended_name
       | subpartition_extended_name
       } TO new_name

resize_disk_clauses

RESIZE
{ ALL [ SIZE size_clause ]
| [QUORUM | REGULAR] DISK
   disk_name [ SIZE size_clause ]
   [, disk_name [ SIZE size_clause ] ]...
| DISKS IN [QUORUM | REGULAR] 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_rows_clause

RETURN { UPDATED | ALL } ROWS

returning_clause

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

rolling_migration_clause

{ START ROLLING MIGRATION TO 'ASM_version'
| STOP ROLLING MIGRATION
}

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

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

search_clause

{ SEARCH
        { DEPTH FIRST BY c_alias [, c_alias]...
            [ ASC | DESC ]
            [ NULLS FIRST | NULLS LAST ]
         | BREADTH FIRST BY c_alias [, c_alias]...
            [ ASC | DESC ]
            [ NULLS FIRST | NULLS LAST ]
        }
        SET ordering_column
}

searched_case_expression

{ WHEN condition THEN return_expr }...

security_clause

GUARD { ALL | STANDBY | NONE }

security_clauses

{ { ENABLE | DISABLE } RESTRICTED SESSION
  | SET ENCRYPTION WALLET OPEN
    IDENTIFIED BY { "wallet_password" | "HSM_credentials" }
  | SET ENCRYPTION WALLET CLOSE
    [ IDENTIFIED BY { "wallet_password" | "HSM_credentials" } ]
  | set_encryption_key
}

segment_attributes_clause

{ physical_attributes_clause
| TABLESPACE tablespace
| logging_clause
}...

segment_management_clause

SEGMENT SPACE MANAGEMENT { AUTO | MANUAL }

select_list

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

set_encryption_key

{ SET ENCRYPTION KEY
  {
    [ "certificate_id" ] IDENTIFIED BY "wallet_password"
    |
    IDENTIFIED BY "HSM_credentials" [ MIGRATE USING "wallet_password" ]
  }
}

set_parameter_clause

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

set_subpartition_template

SET SUBPARTITION TEMPLATE
   { ( range_subpartition_desc [, range_subpartition_desc]... )
   | ( list_subpartition_desc [, list_subpartition_desc]... )
   | 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 }...

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 ]

split_nested_table_part

NESTED TABLE column INTO
  ( PARTITION partition [segment_attributes_clause],
    PARTITION partition [segment_attributes_clause] [split_nested_table_part]
  ) [ split_nested_table_part ]

split_table_partition

SPLIT partition_extended_name
  { AT (literal [, literal]... )
    [ INTO ( range_partition_desc, range_partition_desc ) ]
  | VALUES (literal [, literal] ... )
    [ INTO (list_partition_desc, list_partition_desc ) ]
  } [ split_nested_table_part]
    [ dependent_tables_clause ]
    [ update_index_clauses ]
    [ parallel_clause ]

split_table_subpartition

SPLIT subpartition_extended_name
  { AT ( literal [, literal]... )
    [ INTO (range_subpartition_desc, range_subpartition_desc) ]
  | VALUES ({ literal | NULL  [, literal | NULL ]...})
    [ INTO (list_subpartition_desc, list_subpartition_desc) ]
  } [ dependent_tables_clause ]
    [ update_index_clauses ]
    [ parallel_clause ]

sql_format

[+ | -] days hours : minutes : seconds [. frac_secs ]

standby_database_clauses

{ activate_standby_db_clause
| maximize_standby_db_clause
| register_logfile_clause
| commit_switchover_clause
| start_standby_clause
| stop_standby_clause
| convert_database_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
  }
}

still_image_object_types

{ SI_StillImage
| SI_AverageColor
| SI_PositionalColor
| SI_ColorHistogram
| SI_Texture
| SI_FeatureList
| SI_Color
}

stop_standby_clause

{ STOP | ABORT } LOGICAL STANDBY APPLY

storage_clause

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

storage_table_clause

WITH {SYSTEM | USER} MANAGED STORAGE TABLES

string

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

striping_clause

[ FINE | COARSE ]

subpartition_by_hash

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

subpartition_by_list

SUBPARTITION BY LIST (column) [ subpartition_template ]

subpartition_by_range

SUBPARTITION BY RANGE ( column [, column]... ) [subpartition_template]

subpartition_extended_name

SUBPARTITION subpartition
| 
SUBPARTITION FOR ( subpartition_key_value [, subpartition_key_value]... )

subpartition_template

SUBPARTITION TEMPLATE
  ( { range_subpartition_desc [, range_subpartition_desc] ...
    | list_subpartition_desc [, list_subpartition_desc] ...
    | individual_hash_subparts [, individual_hash_subparts] ...
    }
  ) | hash_subpartition_quantity

subquery

{ query_block
| subquery { UNION [ALL] | INTERSECT | MINUS } subquery
    [ { UNION [ALL] | INTERSECT | MINUS } subquery ]...
| ( subquery )
} [ order_by_clause ]

subquery_factoring_clause

WITH 
  query_name ([c_alias [, c_alias]...]) AS (subquery) [search_clause ] [cycle_clause]
  [, query_name ([c_alias [, c_alias]...]) AS (subquery) [search_clause] [cycle_clause]]...

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_plsql_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 { supplemental_log_grp_clause
                 | supplemental_id_key_clause
                 }

supplemental_plsql_clause

DATA FOR PROCEDURAL REPLICATION

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

switch_logfile_clause

SWITCH ALL LOGFILES TO BLOCKSIZE integer

system_partitioning

PARTITION BY SYSTEM [ PARTITIONS integer
                    | reference_partition_desc
                       [, reference_partition_desc ...]
                    ]

table_collection_expression

TABLE (collection_expression) [ (+) ]

table_compression

{ COMPRESS [ BASIC
           | FOR { OLTP
                 | { QUERY | ARCHIVE } [ LOW | HIGH ]
                 }
           ]
| 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
  | nested_table_col_properties
  }...
]

table_partitioning_clauses

{ range_partitions
| hash_partitions
| list_partitions
| reference_partitioning
| composite_range_partitions
| composite_hash_partitions
| composite_list_partitions
| system_partitioning
}

table_properties

[ column_properties ]
[ table_partitioning_clauses ]
[ CACHE | NOCACHE ]
[ RESULT_CACHE ( MODE {DEFAULT | FORCE } ) ] 
[ parallel_clause ]
[ ROWDEPENDENCIES | NOROWDEPENDENCIES ]
[ enable_disable_clause ]...
[ row_movement_clause ]
[ flashback_archive_clause ]
[ AS subquery ]

table_reference

{ ONLY (query_table_expression)
| query_table_expression [ pivot_clause | unpivot_clause ]
} [ 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 ]

timeout_clause

DROP AFTER integer { M | H }

trace_file_clause

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

truncate_partition_subpart

TRUNCATE { partition_extended_name
         | subpartition_extended_name
         }
   [ { 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

unpivot_clause

table_reference UNPIVOT [ {INCLUDE | EXCLUDE} NULLS ]
( { column | ( column [, column]... ) }
  pivot_for_clause
  unpivot_in_clause
)

unpivot_in_clause

IN
( { column | ( column [, column]... ) }
      [  AS { constant | ( constant [, constant]... ) } ]
        [, { column | ( column [, column]... ) }
          [  AS {constant | ( constant [, constant]... ) } ]
        ]...
)

update_all_indexes_clause

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

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 ]

user_clauses

{ ADD USER user [, user]...
| DROP USER user [, user]... [CASCADE]
}

usergroup_clauses

{ ADD USERGROUP usergroup WITH MEMBER user [, user]...
| MODIFY USERGROUP usergroup { ADD | DROP } MEMBER user [, user]...
| DROP USERGROUP usergroup 
}

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 { FAST | COMPLETE } ]
     [ into_clause ]
     { OFFLINE| ONLINE }
}

values_clause

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

varray_col_properties

VARRAY varray_item 
{ [ substitutable_column_clause ] varray_storage_clause
| substitutable_column_clause
}

varray_storage_clause

STORE AS [SECUREFILE | BASICFILE] LOB
{ [LOB_segname] ( LOB_storage_parameters )
| LOB_segname
}

virtual_column_definition

column [datatype] [GENERATED ALWAYS] AS (column_expression)
   [VIRTUAL]
   [ inline_constraint [inline_constraint]... ]

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
  [ENTITYESCAPING | NOENTITYESCAPING]
  [SCHEMACHECK | NOSCHEMACHECK]
value_expr [ AS { c_alias | EVALNAME value_expr } ]
  [, value_expr [ AS { c_alias | EVALNAME value_expr } ]
  ]...

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

XMLindex_clause

[XDB.] XMLINDEX [ local_XMLIndex_clause ]
                [ parallel_clause ]
  [ XMLIndex_parameters_clause ]

XMLSchema_spec

[ XMLSCHEMA XMLSchema_URL ]
ELEMENT { element | XMLSchema_URL # element }
  [ ALLOW ANYSCHEMA
  | ALLOW NONSCHEMA
  | DISALLOW NONSCHEMA
  ]

XMLTABLE_options

[ XML_passing_clause ]
[ COLUMNS XML_table_column [, XML_table_column]...]

XMLType_column_properties

XMLTYPE [ COLUMN ] column
   [ XMLType_storage ]
   [ XMLSchema_spec ]

XMLType_storage

STORE
{ AS
{ OBJECT RELATIONAL
| [SECUREFILE | BASICFILE]
  { CLOB | BINARY XML }
    [ { LOB_segname [ (LOB_parameters) ]
      | (LOB_parameters)
      }
    ]
}
| { ALL VARRAYS AS { LOBS | TABLES } }
}

XMLType_table

OF XMLTYPE
  [ (oject_properties) ]
  [ XMLTYPE XMLType_storage ]
  [ XMLSchema_spec ]
  [ XMLType_virtual_columns ]
  [ 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 ]...) }

XMLType_virtual_columns

VIRTUAL COLUMNS ( column AS (expr) [, column AS (expr) ]... )

ym_iso_format

[-] P [ years Y ] [months M] [days D]
  [T [hours H] [minutes M] [seconds [. frac_secs] S ] ]