Syntax for Subclauses

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

• Chapter 1, "SQL Statements"

• Chapter 2, "SQL Functions"

• Chapter 3, "SQL Expressions"

• Chapter 4, "SQL Conditions"

  See Also:

  Oracle Database SQL Language Reference for detailed information about Oracle SQL

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 ]

add_disk_clause

ADD
  { [ 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_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 ]

alias_file_name

+diskgroup_name [ (template_name) ] /alias_name

allocate_extent_clause

ALLOCATE EXTENT
  [ ( { 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

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

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

alter_session_set_clause

SET { parameter_name = parameter_value }...

alter_system_reset_clause

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

alter_system_security

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

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

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

{ ADD | REMOVE } multiple_XMLSchema_spec
  [ 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' ]
   | 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 ]... )
   }

audit_operation_clause

{ { sql_statement_shortcut
  | ALL
  } [, { 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 ]...
   }

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 }

C_declaration

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

call_spec

LANGUAGE { Java_declaration | C_declaration }

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
]

compile_type_clause

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

compiler_parameters_clause

parameter_name = parameter_value

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

compound_DML_trigger

FOR dml_event_clause [ referencing_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_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 | 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 | COMMIT }
  | { START WITH | NEXT } date
  | WITH { PRIMARY KEY | ROWID }
  | USING
     { DEFAULT [ MASTER | LOCAL ] ROLLBACK SEGMENT
     | [ MASTER | LOCAL ] ROLLBACK SEGMENT rollback_segment
     }...
  | USING
     { ENFORCED | TRUSTED } CONSTRAINTS
  }...
| NEVER REFRESH
}

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 ]

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

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
  { DISK disk_name [, disk_name ] ...
  | DISKS IN FAILGROUP failgroup_name [, failgroup_name ]...
  } ... [timeout_clause]

disk_online_clause

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

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

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

element_spec

[ inheritance_clauses ]
{ subprogram_spec
| 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 [, @integer3]'
}
[ 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 } ]

exceptions_clause

EXCEPTIONS INTO [ schema. ] table

exchange_partition_subpart

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

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
}

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
          }
  | 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
    }...
  ]
| 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 [ START WITH condition ]
| START WITH condition CONNECT BY [ NOCYCLE ] 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' )
   ]
]

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 ]
   [, SUBPARTITION
         [ subpartition ][ TABLESPACE tablespace ] [ key_compression ]
   ]...
  )
}

individual_hash_partitions

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

individual_hash_subparts

SUBPARTITION [subpartition] [partitioning_storage_clause]

inheritance_clauses

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

key_compression

{ COMPRESS [ integer ]
| NOCOMPRESS
}

level_clause

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

list_partitions

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_compression_clause

{ COMPRESS [HIGH | MEDIUM ]
| 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_retention_storage

RETENTION [ MAX | MIN integer | AUTO | NONE ]

local_domain_index_clause

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

local_XMLIndex_clause

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

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

LOB
{ (LOB_item [, LOB_item ]...)
     STORE AS { {SECUREFILE | BASICFILE}
              | (LOB_storage_parameters)
              }...
| (LOB_item)
     STORE AS { {SECUREFILE | BASICFILE}
              | LOB_segname 
              | (LOB_storage_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 |  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
      }...
    | FINISH
    | CANCEL
    ]
| TO LOGICAL STANDBY { db_name | KEEP IDENTITY }
}

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

[ 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 }...
       [ LOB_storage_clause ]
       [ alter_XMLSchemas_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_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_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]... )
}

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

multiple_XMLSchema_spec

XMLSCHEMAS ( single_XMLSchema_spec [, single_XMLSchema_spec]... )

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 ]
    }...
  )
]
[ RETURN AS { LOCATOR | VALUE } ]

nested_table_type

[ OID 'object_identifier' ]
{ IS | AS } TABLE OF datatype 

new_values_clause

{ INCLUDING | EXCLUDING } NEW VALUES

non_DML_trigger

{ BEFORE | AFTER } 
{ ddl_event [OR ddl_event]...
| database_event [OR database_event]...
}
ON { [schema.] SCHEMA
   | DATABASE
   }

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

[ OID 'object_identifier' ] [ invoker_rights_clause ]
{ { IS | AS } OBJECT
  | UNDER [schema.]supertype
  } [ sqlj_object_type ]
  [ ( { attribute datatype [ sqlj_object_type_attr ] }...
        [, element_spec [, element_spec ]...]
    )
  ] [ [NOT] FINAL ] [ [NOT] INSTANTIABLE ] 

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
      }...
    ] [ index_subpartition_clause ]
      [, PARTITION
           [ partition ]
           [ { segment_attribute_clause
             | key_compression
             }...
           ] [ 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
      }...
    ]
      [, PARTITION
           [ partition ]
           [ { 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
      }...
    ]
      [, PARTITION
          [ partition ]
          [ { 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
  }...
]
[ 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_value [, partition_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

{ 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

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

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

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 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 | HIGH | UNPROTECTED ]
 [ FINE | COARSE ]
)

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'
                 }
               )
  | 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 ]
[ REUSE ]

reference_model

REFERENCE reference_spreadsheet_name
ON (subquery)
spreadsheet_column_clauses
  [ cell_reference_options ]

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 ]

referencing_clause

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

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

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

searched_case_expression

{ WHEN condition THEN return_expr }...

security_clause

GUARD { ALL | STANDBY | NONE }

segment_attributes_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
   { ( 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 }...

simple_DML_trigger

{ BEFORE | AFTER | INSTEAD OF } dml_event_clause
  [ referencing_clause ] [ FOR EACH ROW ]

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 ]

single_XMLSchema_spec

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

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_table_partition

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

split_table_subpartition

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

sql_format

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

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 }
 | maxsize_clause
 | PCTINCREASE integer
 | FREELISTS integer
 | FREELIST GROUPS integer
 | OPTIMAL [ size_clause | NULL ]
 | BUFFER_POOL { KEEP | RECYCLE | DEFAULT }
 | ENCRYPT
 } ...
)

storage_table_clause

WITH {SYSTEM | USER} MANAGED STORAGE TABLES 

streaming_clause

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

string

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

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_template

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

subprogram_declaration

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

subprogram_spec

{ MEMBER | STATIC }
{ procedure_spec | function_spec }

subquery

{ query_block
| subquery { UNION [ALL] | INTERSECT | MINUS } subquery
    [ { UNION [ALL] | INTERSECT | MINUS } subquery ]...
| ( 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_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 }
    ]...
}

system_partitioning_clause

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

table_collection_expression

TABLE (collection_expression) [ (+) ]

table_compression

{ COMPRESS [ FOR { ALL | DIRECT_LOAD } OPERATIONS ] 
| 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
  }...
]

table_partitioning_clauses

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

table_properties

[ column_properties ]
[ table_partitioning_clauses ]
[ CACHE | NOCACHE ]
[ 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 ]

storage_table_clause

WITH {SYSTEM | USER} MANAGED STORAGE TABLES 

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 ]

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
}

varray_type

[ OID 'object_identifier' ]
{ IS | AS } { VARRAY | VARYING ARRAY }
(limit) OF datatype 

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

XMLTABLE_options

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

XMLindex_clause

[XDB.] XMLINDEX [ local_XMLIndex_clause ]
                [ parallel_clause ]
                [ PARAMETERS ('XMLIndex_Parameters') ]

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
| [SECUREFILE | BASICFILE]
  { CLOB | BINARY XML }
    [ { LOB_segname [ (LOB_parameters) ]
      | (LOB_parameters)
      }
    ]
}

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