Oracle SQL clauses

advanced_index_compression

{ COMPRESS ADVANCED [ LOW | HIGH ] } | NOCOMPRESS

attribute_clause

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

build_clause

BUILD { IMMEDIATE | DEFERRED }

consistent_hash_with_subpartitions

PARTITION BY CONSISTENT HASH (column [, column ]...)
  { subpartition_by_range
  | subpartition_by_list
  | subpartition_by_hash
  }
  [ PARTITIONS AUTO ]

ilm_compression_policy

{ table_compression { SEGMENT | GROUP } 
  { { AFTER ilm_time_period OF { { NO ACCESS } | { NO MODIFICATION } | CREATION } }
  | { ON function_name } }
}
|
{ { ROW STORE COMPRESS ADVANCED
  | COLUMN STORE COMPRESS FOR QUERY  }
  ROW AFTER ilm_time_period OF NO MODIFICATION
}

index_properties

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

interval_expression

( expr1 - expr2 )
   { DAY [ (leading_field_precision) ] TO
     SECOND [ (fractional_second_precision) ]
   | YEAR [ (leading_field_precision) ] TO
     MONTH
   }

system_partitioning

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

alias_file_name

+diskgroup_name [ (template_name) ] /alias_name

clustering_join

[ schema. ] table JOIN [ schema. ] table ON ( equijoin_condition )
                    [, JOIN [ schema. ] table ON ( equijoin_condition ) ]...

enable_disable_volume

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

filter_clauses

FILTER FACT (filter_clause [, filter_clause]…)

incomplete_file_name

+diskgroup_name [ (template_name) ]

index_subpartition_clause

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

null_condition

expr IS [ NOT ] NULL

program_unit

{ FUNCTION [ schema. ] function_name
|
PROCEDURE [ schema. ] procedure_name
|
PACKAGE [ schema. ] package_name }

use_key

USE [ ENCRYPTION ] KEY 'key_id'
  [ USING TAG 'tag' ]
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

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

container_map_clause

  CONTAINER_MAP UPDATE { add_table_partition | split_table_partition }

create_type_body

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
TYPE BODY plsql_type_body_source

fully_qualified_file_name

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

hash_partitions

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

on_comp_partitioned_table

[ STORE IN ( tablespace [, tablespace ]... ) ]
( PARTITION
    [ partition ]
    [ { segment_attributes_clause
      | index_compression
      }...
    ] [ USABLE | UNUSABLE ] [ index_subpartition_clause ]
      [, PARTITION
           [ partition ]
           [ { segment_attributes_clause
             | index_compression
             }...
           ] [ USABLE | UNUSABLE ] [ index_subpartition_clause ]
       ]...
)

parallel_pdb_creation_clause

PARALLEL [ integer ]

register_logfile_clause

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

undrop_disk_clause

UNDROP DISKS

user_defined_function

[ schema. ]
{ [ package. ]function | user_defined_operator }
[ @ dblink. ]
[ ( [ [ DISTINCT | ALL ] expr [, expr ]... ] ) ]

XMLType_view_clause

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

add_table_partition

ADD {
PARTITION [ partition ] add_range_partition_clause
  [, PARTITION [ partition ] add_range_partition_clause ]...
| PARTITION [ partition ] add_list_partition_clause
  [, PARTITION [ partition ] add_list_partition_clause ]...
| PARTITION [ partition ] add_system_partition_clause
  [, PARTITION [ partition ] add_system_partition_clause ]...
  [ BEFORE { partition_name | partition_number } ]
| PARTITION [ partition ] add_hash_partition_clause
} [ dependent_tables_clause ]

coalesce_index_partition

COALESCE PARTITION [ parallel_clause ]

context_clause

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

database_file_clauses

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

drop_hierarchy

DROP HIERARCHY [ schema. ] hierarchy_name;

individual_hash_subparts

SUBPARTITION [subpartition] [read_only_clause] [indexing_clause] [partitioning_storage_clause]

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_col ] | ref_attr [, ref_attr ] } ) references_clause
    [ constraint_state ]
}

scrub_clause

SCRUB [ FILE 'ASM_filename' | DISK disk_name ]
  [ REPAIR | NOREPAIR]
  [ POWER { AUTO | LOW | HIGH | MAX } ]
  [ WAIT | NOWAIT ]
  [ FORCE | NOFORCE ]
  [ STOP ]

switch_logfile_clause

SWITCH ALL LOGFILES TO BLOCKSIZE integer

timeout_clause

DROP AFTER integer { M | H }

XMLType_column_properties

XMLTYPE [ COLUMN ] column
   [ XMLType_storage ]
   [ XMLSchema_spec ]

alter_attribute_dimension

ALTER ATTRIBUTE DIMENSION [ schema. ]
  attr_dim_name { RENAME TO new_attr_dim_name | COMPILE };

create_controlfile

CREATE CONTROLFILE
  [ REUSE ] [ SET ] DATABASE database
  [ logfile_clause ]
  { RESETLOGS | NORESETLOGS }
  [ DATAFILE file_specification
             [, file_specification ]... ]
  [ MAXLOGFILES integer
  | MAXLOGMEMBERS integer
  | MAXLOGHISTORY integer
  | MAXDATAFILES integer
  | MAXINSTANCES integer
  | { ARCHIVELOG | NOARCHIVELOG }
  | FORCE LOGGING
  | SET STANDBY NOLOGGING FOR {DATA AVAILABILITY | LOAD PERFORMANCE}
 ]...
  [ character_set_clause ] ;

create_pdb_from_xml

[ AS CLONE ] USING filename
  [ source_file_name_convert | source_file_directory ]
  [ { [ COPY | MOVE ] file_name_convert } | NOCOPY ]
  [ service_name_convert ]
  [ default_tablespace ]
  [ pdb_storage_clause ]
  [ path_prefix_clause ]
  [ tempfile_reuse_clause ]
  [ user_tablespaces_clause ]
  [ standbys_clause ]
  [ logging_clause ]
  [ create_file_dest_clause ]
  [ HOST = 'hostname' ]
  [ PORT = number ]
  [ create_pdb_decrypt_from_xml ]

create_sequence

CREATE SEQUENCE [ schema. ] sequence
  [ SHARING = { METADATA | DATA | NONE } ]
  [ { INCREMENT BY | START WITH } integer
  | { MAXVALUE integer | NOMAXVALUE }
  | { MINVALUE integer | NOMINVALUE }
  | { CYCLE | NOCYCLE }
  | { CACHE integer | NOCACHE }
  | { ORDER | NOORDER }
  | { KEEP | NOKEEP }
  | { SCALE {EXTEND | NOEXTEND} | NOSCALE }
  | { SESSION | GLOBAL }
  ]...
;

delete_secret_seps

   DELETE SECRET 'secret' FOR CLIENT 'client_identifier'  
   FROM [LOCAL] AUTO_LOGIN KEYSTORE directory 

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

partition_spec

PARTITION [ partition ] [ table_partition_description ]

partitioning_storage_clause

[ { { TABLESPACE tablespace | TABLESPACE SET tablespace_set }
  | OVERFLOW [ TABLESPACE tablespace] | TABLESPACE SET tablespace_set ]
  | table_compression
  | index_compression
  | inmemory_clause
  | ilm_clause
  | LOB_partitioning_storage
  | VARRAY varray_item STORE AS [SECUREFILE | BASICFILE] LOB LOB_segname
  }...
]

path_prefix_clause

PATH_PREFIX = { 'path_name' | directory_object_name | NONE }

range_partition_desc

PARTITION [partition]
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 ]

rename_index_partition

RENAME
  { PARTITION partition | SUBPARTITION subpartition }
TO new_name

startup_clauses

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

trace_file_clause

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

using_clause

USING [ schema. ] fact_table_or_view  [ [ AS ] alias ]

zonemap_attributes

{ TABLESPACE tablespace
| SCALE integer
| { CACHE | NOCACHE }
}...

lock_table

LOCK TABLE [ schema. ] { table | view }
   [ partition_extension_clause
   | @ dblink
   ] [, [ schema. ] { table | view }
      [ partition_extension_clause
      | @ dblink
      ]
     ]...
   IN lockmode MODE
   [ NOWAIT
   | WAIT integer
   ] ;

alter_table

ALTER TABLE [ schema. ] table
  [ memoptimize_read_clause ]
  [ memoptimize_write_clause ]
  [ alter_table_properties
  | column_clauses
  | constraint_clauses
  | alter_table_partitioning
  | alter_external_table
  | move_table_clause
  | modify_to_partitioned
  | modify_opaque_type
  | immutable_table_clauses
  | blockchain_table_clauses
  ]
  [ enable_disable_clause
  | { ENABLE | DISABLE }
    { TABLE LOCK | ALL TRIGGERS | CONTAINER_MAP | CONTAINERS_DEFAULT }
  ] ...
  ;

alter_tempfile_clause

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

audit_operation_clause

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

cancel_sql_clause

 CANCEL SQL ' session_id , serial_number [ , @ instance_id ] [ , sql_id ] '

case_expression

CASE { simple_case_expression
     | searched_case_expression
     }
     [ else_clause ]
     END

cell_reference_options

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

clustering_when

[ { YES | NO } ON LOAD ] [ { YES | NO } ON DATA MOVEMENT ]

default_index_compression

INDEX { COMPRESS ADVANCED { LOW | HIGH }
      | NOCOMPRESS
      }

inline_ref_constraint

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

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

multi_column_for_loop

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

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

object_type_col_properties

COLUMN column substitutable_column_clause

truncate_cluster

TRUNCATE CLUSTER [schema.] cluster
  [ {DROP | REUSE} STORAGE ] ;

update_index_clauses

{ update_global_index_clause
| update_all_indexes_clause
}

activate_standby_db_clause

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

alter_user

ALTER USER
  { user
    { IDENTIFIED
      { BY password [ REPLACE old_password ]
      | EXTERNALLY [ AS 'certificate_DN' | AS 'kerberos_principal_name' ]
      | GLOBALLY [ AS '{  directory_DN  |  {AZURE_USER | AZURE_ROLE }=value  
                           | {IAM_GROUP_NAME | IAM_PRINCIPAL_NAME}=value  }']
      }
    | NO AUTHENTICATION 
    | DEFAULT COLLATION collation_name
    | DEFAULT TABLESPACE tablespace
    | [ LOCAL ] TEMPORARY TABLESPACE { tablespace | tablespace_group_name }
    | { QUOTA { size_clause
              | UNLIMITED
              } ON tablespace
      } ...
    | PROFILE profile
    | DEFAULT ROLE { role [, role ]...
                   | ALL [ EXCEPT role [, role ]... ]
                   | NONE
                   }
    | PASSWORD EXPIRE
    | ACCOUNT { LOCK | UNLOCK }
    | ENABLE EDITIONS [ FOR object_type [, object_type ]... ] [ FORCE ]
    | [HTTP] DIGEST { ENABLE | DISABLE }
    | CONTAINER = { CURRENT | ALL }
    | container_data_clause
    } ...
  | user [, user ]... proxy_clause
  } ;

alternate_key_clause

ALTERNATE KEY { [ ( ] attribute [ ) ]
                |  
                ( attribute [, attribute ]... )
              }

composite_list_partitions

PARTITION BY LIST ( column [, column]... )
[ AUTOMATIC [ STORE IN ( tablespace [, tablespace ]... ) ] ]
  { subpartition_by_range
  | subpartition_by_list
  | subpartition_by_hash
  }
( list_partition_desc [, list_partition_desc]... )

create_profile

CREATE PROFILE profile
  LIMIT { resource_parameters
        | password_parameters
        }...
  [ CONTAINER = { CURRENT | ALL } ] ;

create_zonemap_on_table

CREATE MATERIALIZED ZONEMAP
  [ schema. ] zonemap_name
  [ zonemap_attributes ]
  [ zonemap_refresh_clause ]
  [ { ENABLE | DISABLE } PRUNING ]
  ON [ schema. ] { table | materialized_view } ( column [, column]... )

drop_materialized_view_log

DROP MATERIALIZED VIEW LOG ON [ schema. ] table ;

filter_clause

hier_id TO predicate

implementation_clause

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

index_org_table_clause

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

individual_hash_partitions

( PARTITION [partition] [read_only_clause] [indexing_clause] [partitioning_storage_clause]
  [, PARTITION [partition] {read_only_clause] [indexing_clause] [partitioning_storage_clause]]... )

password_parameters

{ { FAILED_LOGIN_ATTEMPTS
  | PASSWORD_LIFE_TIME
  | PASSWORD_REUSE_TIME
  | PASSWORD_REUSE_MAX
  | PASSWORD_LOCK_TIME
  | PASSWORD_GRACE_TIME
  | INACTIVE_ACCOUNT_TIME
  }
  { expr | UNLIMITED | DEFAULT }
| PASSWORD_VERIFY_FUNCTION
  { function | NULL | DEFAULT }
| ( PASSWORD_ROLLOVER_TIME { expr | DEFAULT } )
}

pivot_in_clause

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

single_column_for_loop

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

start_standby_clause

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

supplemental_id_key_clause

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

tablespace_encryption_clause

ENCRYPTION [ { [ tablespace_encryption_spec ] ENCRYPT } | DECRYPT ]

varray_col_properties

VARRAY varray_item 
{ [ substitutable_column_clause ] varray_storage_clause
| substitutable_column_clause
}

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

alter_java

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

array_DML_clause

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

clustering_column_group

( column [, column ]... )

comment

COMMENT ON
  { AUDIT POLICY policy
  | COLUMN [ schema. ]
      { table. | view. | materialized_view. } column
  | EDITION edition_name
  | INDEXTYPE [ schema. ] indextype
  | MATERIALIZED VIEW materialized_view
  | MINING MODEL [ schema. ] model
  | OPERATOR [ schema. ] operator
  | TABLE [ schema. ] { table | view }
  }
  IS string ;

create_function

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
FUNCTION plsql_function_source

cross_outer_apply_clause

{ CROSS | OUTER } APPLY { table_reference | collection_expression }

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

drop_pluggable_database

DROP PLUGGABLE DATABASE pdb_name
  [ { KEEP | INCLUDING } DATAFILES ] ;

grouping_expression_list

expression_list [, expression_list ]...

inmemory_column_clause

{ INMEMORY [ inmemory_memcompress ] | NO INMEMORY } ( column [, column ]... )
 [ { INMEMORY [ inmemory_memcompress ] | NO INMEMORY } ( column [, column ]... ) ]...

insert

INSERT [ hint ]
   { single_table_insert | multi_table_insert } ;

pdb_snapshot_clause

   ENABLE SNAPSHOT { MANUAL | EVERY snapshot_interval { HOURS | MINUTES } | NONE  }

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

revoke_object_privileges

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

rolling_patch_clauses

{ START ROLLING PATCH
| STOP ROLLING PATCH
}

subquery_restriction_clause

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

tablespace_retention_clause

RETENTION { GUARANTEE | NOGUARANTEE }

undo_tablespace

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

user_tablespaces_clause

USER_TABLESPACES =
  { ( 'tablespace' [, 'tablespace' ]... )
  | ALL [ EXCEPT ( 'tablespace' [, 'tablespace' ]... ) ]
  | NONE
  }
  [ SNAPSHOT COPY | NO DATA | COPY | MOVE | NOCOPY ]

OID_clause

OBJECT IDENTIFIER IS
{ SYSTEM GENERATED | PRIMARY KEY }

XMLSchema_spec

  [ XMLSCHEMA XMLSchema_URL ]
ELEMENT { element | XMLSchema_URL # element }
  [ STORE ALL VARRAYS AS { LOBS | TABLES } ]
  [ { ALLOW | DISALLOW } NONSCHEMA ]
  [ { ALLOW | DISALLOW } ANYSCHEMA ]

allocate_extent_clause

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

alter_database

ALTER DATABASE [ database ]
  { startup_clauses
  | recovery_clauses
  | database_file_clauses
  | logfile_clauses
  | controlfile_clauses
  | standby_database_clauses
  | default_settings_clauses
  | instance_clauses
  | security_clause
  | prepare_clause
  | drop_mirror_copy
  | lost_write_protection
  | cdb_fleet_clauses
  | property_clause
  } ;

alter_view

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

blockchain_hash_and_data_format_clause

HASHING USING sha2_512 VERSION v1

cache_specification

MEASURE GROUP
 {    ALL 
   | ( measure_name [, measure_name ]... ) [ levels_clause  MATERIALIZED ]...
 }

classification_clause

[ CAPTION caption ]
[ DESCRIPTION description ]
[ CLASSIFICATION classification_name
  [ VALUE classification_value ] 
  [ LANGUAGE language ]
]...

create_tablespace_set

CREATE TABLESPACE SET tablespace_set
  [ IN SHARDSPACE shardspace ]
  [ USING TEMPLATE 
    ( { DATAFILE [, file_specification ]... ] permanent_tablespace_attrs )
  ] ;

diskgroup_attributes

SET ATTRIBUTE 'attribute_name' = 'attribute_value'

drop_outline

DROP OUTLINE outline ;

external_table_data_props

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

ilm_time_period

integer { { DAY | DAYS } | { MONTH | MONTHS } | { YEAR | YEARS } }

model_iterate_clause

ITERATE ( number ) [ UNTIL ( condition ) ]

plsql_declarations

{ function_declaration | procedure_declaration }...

quiesce_clauses

QUIESCE RESTRICTED | UNQUIESCE

row_limiting_clause

[ OFFSET offset { ROW | ROWS } ]
[ FETCH { FIRST | NEXT } [ { rowcount | percent PERCENT } ]
    { ROW | ROWS } { ONLY | WITH TIES } ]

row_pattern_definition_list

row_pattern_definition [, row_pattern_definition ]...

row_pattern_partition_by

PARTITION BY column [, column ]...

set_parameter_clause

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

source_file_directory

SOURCE_FILE_DIRECTORY = { 'directory_path_name' | NONE }

substitutable_column_clause

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

table_partition_description

 [ { INTERNAL | EXTERNAL } ]
[ deferred_segment_creation ]
[ read_only_clause ]
[ indexing_clause ]
[ segment_attributes_clause ]
[ table_compression | prefix_compression ]
[ inmemory_clause ]
[ ilm_clause ]
[ OVERFLOW [ segment_attributes_clause ] ]
[ { LOB_storage_clause
  | varray_col_properties
  | nested_table_col_properties
  }...
]

alter_index

ALTER INDEX [ schema. ]index
  { { deallocate_unused_clause
    | allocate_extent_clause
    | shrink_clause
    | parallel_clause
    | physical_attributes_clause
    | logging_clause
    | partial_index_clause
    } ...
  | rebuild_clause
  | PARAMETERS ( 'ODCI_parameters' )
               )
  | COMPILE
  | { ENABLE | DISABLE }
  | UNUSABLE [ ONLINE ] [ { DEFERRED | IMMEDIATE } INVALIDATION ]
  | VISIBLE | INVISIBLE
  | RENAME TO new_name
  | COALESCE [ CLEANUP ] [ ONLY ] [ parallel_clause ]
  | { MONITORING | NOMONITORING } USAGE
  | UPDATE BLOCK REFERENCES
  | alter_index_partitioning
  }
  ;

alter_tablespace

ALTER TABLESPACE tablespace alter_tablespace_attrs ;

attr_dim_attribute_clause

[ alias. ] column [ [ AS ] attribute_name ] [ classification_clause ]...

convert_database_clause

CONVERT TO ( PHYSICAL | SNAPSHOT ) STANDBY

dblink_authentication

AUTHENTICATED BY user IDENTIFIED BY password

default_aggregate_clause

DEFAULT AGGREGATE BY aggr_function

dimension_join_clause

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

disk_online_clause

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

drop_index_partition

DROP PARTITION partition_name

drop_logfile_clauses

DROP [ STANDBY ] LOGFILE
   { logfile_descriptor
     [, logfile_descriptor ]...
   | MEMBER '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']...

flashback_archive_quota

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

inline_analytic_view

ANALYTIC VIEW (sub_av_clause) [[AS] inline_av_alias]

list_values

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

merge_into_new_keystore

MERGE KEYSTORE 'keystore1_location' [ IDENTIFIED BY keystore1_password ]
  AND KEYSTORE 'keystore2_location' [ IDENTIFIED BY keystore2_password ]
  INTO NEW KEYSTORE 'keystore3_location' IDENTIFIED BY keystore3_password

modify_volume_clause

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

move_to_filegroup_clause

MOVE FILE 'ASM_filename' TO FILEGROUP filegroup_name 

out_of_line_constraint

  [ CONSTRAINT constraint_name ]
{ UNIQUE (column [, column ]...)
| PRIMARY KEY (column [, column ]...)
| FOREIGN KEY (column [, column ]...) references_clause
| CHECK (condition)
} [ constraint_state ]

period_definition

PERIOD FOR valid_time_column [ ( start_time_column, end_time_column ) ]

query_partition_clause

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

row_pattern_skip_to

AFTER MATCH {
  SKIP TO NEXT ROW
  | SKIP PAST LAST ROW
  | SKIP TO FIRST variable_name
  | SKIP TO LAST variable_name
  | SKIP TO variable_name
  }

subav_clause

USING  { [schema.]base_av_name [hierarchies_clause] [filter_clauses] [add_calcs_clause] }

create_pdb_clone

{ { FROM { src_pdb_name [ @ dblink ] } | { NON$CDB @ dblink } }
|
  { AS PROXY FROM src_pdb_name @ dblink }
}
  [ parallel_pdb_creation_clause ]
  [ default_tablespaces ]
  [ pdb_storage_clause ]
  [ file_name_convert ]
  [ service_name_convert ]
  [ path_prefix_clause ]
  [ tempfile_reuse_clause ]
  [ SNAPSHOT COPY ]
  [ using_snapshot_clause ]
  [ user_tablespaces_clause ]
  [ standbys_clause ]
  [ logging_clause ]
  [ create_file_dest_clause ]
  [ keystore_clause ]
  [ pdb_refresh_mode_clause ]
  [ RELOCATE AVAILABILITY {MAX | NORMAL} ]
  [ NO DATA ]
  [ HOST = 'hostname' ]
  [ PORT = number ]

set_transaction

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

JSON_passing_clause

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

LOB_deduplicate_clause

{ DEDUPLICATE   
| KEEP_DUPLICATES
}

add_hash_index_partition

ADD PARTITION
   [ partition_name ]
   [ TABLESPACE tablespace_name ]
   [ index_compression ]
   [ parallel_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) ]

clustering_columns

clustering_column_group
| ( clustering_column_group [, clustering_column_group ]... )

default_settings_clauses

{ DEFAULT EDITION = edition_name
| SET DEFAULT { BIGFILE | SMALLFILE } TABLESPACE
| DEFAULT TABLESPACE tablespace
| DEFAULT [ LOCAL ] 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
| [NO] FORCE FULL DATABASE CACHING
| CONTAINERS DEFAULT TARGET = { (container_name) | NONE }
| flashback_mode_clause
| undo_mode_clause
| set_time_zone_clause
}

drop_role

DROP ROLE role ;

drop_trigger

DROP TRIGGER [ schema. ] trigger ;

exceptions_clause

EXCEPTIONS INTO [ schema. ] table

inmemory_distribute

DISTRIBUTE [ AUTO | BY { ROWID RANGE | PARTITION | SUBPARTITION } ]
           [ FOR SERVICE { DEFAULT | ALL | service_name | NONE } ]

level_clause

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

list_partitions

PARTITION BY LIST ( column [, column]... )
[ AUTOMATIC [ STORE IN ( tablespace [, tablespace ]... ) ] ]
(PARTITION [ partition ]
    list_values_clause table_partition_description
  [, PARTITION [ partition ]
        list_values_clause table_partition_description
        [ external_part_subpart_data_props ]
  ]...
)

merge_into_existing_keystore

MERGE KEYSTORE 'keystore1_location' [ IDENTIFIED BY keystore1_password ]
  INTO EXISTING KEYSTORE 'keystore2_location' IDENTIFIED BY keystore2_password
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

partial_index_clause

INDEXING { PARTIAL | FULL }

query_table_expression

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

row_pattern_order_by

ORDER BY column [, column ]...

table_reference

{ { { ONLY (query_table_expression) | query_table_expression }
  [ flashback_query_clause ]
  [ pivot_clause | unpivot_clause | row_pattern_clause ] }
| containers_clause
| shards_clause
}
[ t_alias ]

tablespace_group_clause

TABLESPACE GROUP { tablespace_group_name | '' }

ts_file_name_convert

FILE_NAME_CONVERT =
  ( 'filename_pattern', 'replacement_filename_pattern'
      [, 'filename_pattern', 'replacement_filename_pattern' ]... )
  [ KEEP ]

validation_clauses

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

virtual_column_definition

column [ datatype [ COLLATE column_collation_name ] ]
  [ VISIBLE | INVISIBLE ]
  [ GENERATED ALWAYS ] AS (column_expression) [ VIRTUAL ]
  [ evaluation_edition_clause ] [ unusable_editions_clause ]
  [ inline_constraint [ inline_constraint ]... ]

split_table_partition

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

update_all_indexes_clause

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

values_clause

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

OID_index_clause

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

analytic_clause

[ query_partition_clause ] [ order_by_clause [ windowing_clause ] ]

audit_schema_object_clause

{ sql_operation [, sql_operation ]
| ALL
} auditing_on_clause

convert_redundancy_clause

CONVERT REDUNDANCY TO FLEX

create_outline

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

drop_attribute_dimension

DROP ATTRIBUTE DIMENSION [ schema. ] attr_dimension_name;

flashback_archive_retention

RETENTION integer {YEAR | MONTH | DAY}

floating_point_condition

expr IS [ NOT ] { NAN | INFINITE }

index_partitioning_clause

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

number

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

object_access_expression

{ table_alias.column.
| object_table_alias.
| (expr).
}
{ attribute [.attribute ]...
  [.method ([ argument [, argument ]... ]) ]
| method ([ argument [, argument ]... ])
}

select_list

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

set_role

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

simple_expression

{ [ query_name.
  | [schema.] { table. | view. | materialized view. }
  | t_alias.
  ] { column | ROWID }
| ROWNUM
| string
| number
| sequence. { CURRVAL | NEXTVAL }
| NULL
}

single_table_insert

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

supplemental_log_grp_clause

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

table_compression

COMPRESS
| ROW STORE COMPRESS [ BASIC | ADVANCED ]
| COLUMN STORE COMPRESS [  FOR { QUERY | ARCHIVE } [ LOW | HIGH ] ]
  [ [NO] ROW LEVEL LOCKING ]
| NOCOMPRESS

tempfile_reuse_clause

TEMPFILE REUSE

value

VALUE(correlation_variable)

where_clause

WHERE condition

add_system_partition_clause

[table_partition_description]
[update_index_clauses]

blockchain_table_clauses

 blockchain_drop_table_clause 
     blockchain_row_retention_clause 
     blockchain_hash_and_data_format_clause

compound_expression

{ (expr)
| { + | - | PRIOR } expr
| expr { * | / | + | - | || } expr
| expr COLLATE collation_name
}

Note: The double vertical bars are part of the syntax
      (indicating concatenation) rather than BNF notation.

create_hierarchy

CREATE [ OR REPLACE ] [ FORCE | NOFORCE ] 
  HIERARCHY [ schema. ] hierarchy 
  [ SHARING "=" ( METADATA | NONE ) ]
  [ classification_clause ]... ]
  hier_using_clause
  level_hier_clause
  [ hier_attrs_clause ]
;

drop_edition

DROP EDITION edition [CASCADE];

drop_rollback_segment

DROP ROLLBACK SEGMENT rollback_segment ;

drop_tablespace

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

external_table_clause

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

file_specification

{ datafile_tempfile_spec
| redo_log_file_spec
}

lost_write_protection

[ { ENABLE | DISABLE | REMOVE | SUSPEND } ] LOST WRITE PROTECTION

range_partitionset_clause

PARTITIONSET BY RANGE (column [, column]...)
  PARTITION BY CONSISTENT HASH (column [, column]...)
  [ SUBPARTITION BY { { RANGE | HASH } (column [, column]...)
                    | LIST (column)
                    }
  [ subpartition_template ]
  ]
  PARTITIONS AUTO ( range_partitionset_desc [, range_partitionset_desc]... )

reference_partition_desc

PARTITION [partition] [table_partition_description] )

reverse_migrate_key

SET [ ENCRYPTION ] KEY
  IDENTIFIED BY software_keystore_password
  [ FORCE KEYSTORE ]
  REVERSE MIGRATE USING HSM_auth_string

subquery_factoring_clause

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

tablespace_datafile_clauses

DATAFILES { SIZE size_clause | autoextend_clause }...

undo_mode_clause

LOCAL UNDO { ON | OFF }

alter_diskgroup

ALTER DISKGROUP
  { diskgroup_name
      { { { add_disk_clause | drop_disk_clause }
          [, { add_disk_clause | drop_disk_clause } ]...
        | resize_disk_clause
        } [ rebalance_diskgroup_clause ]
      | replace_disk_clause
      | rename_disk_clause
      | disk_online_clause
      | disk_offline_clause
      | rebalance_diskgroup_clause
      | check_diskgroup_clause
      | diskgroup_template_clauses
      | diskgroup_directory_clauses
      | diskgroup_alias_clauses
      | diskgroup_volume_clauses
      | diskgroup_attributes
      | modify_diskgroup_file
      | drop_diskgroup_file_clause
      | convert_redundancy_clause
      | usergroup_clauses
      | user_clauses
      | file_permissions_clause
      | file_owner_clause
      | scrub_clause
      | quotagroup_clauses
      | filegroup_clauses
      }
    | { diskgroup_name [, diskgroup_name ]...
      | ALL
      } { undrop_disk_clause
        | diskgroup_availability
        | enable_disable_volume
        }
  } ;

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

constraint

{ inline_constraint
| out_of_line_constraint
| inline_ref_constraint
| out_of_line_ref_constraint
}

create_index

CREATE [ UNIQUE | BITMAP ] INDEX [ schema. ] index
  ON { cluster_index_clause
     | table_index_clause
     | bitmap_join_index_clause
     }
[ USABLE | UNUSABLE ]
[ { DEFERRED | IMMEDIATE } INVALIDATION ] ;

create_tablespace

CREATE
   [ BIGFILE | SMALLFILE ]
   { permanent_tablespace_clause
   | temporary_tablespace_clause
   | undo_tablespace_clause
   } ;

drop_sequence

DROP SEQUENCE [ schema. ] sequence_name ;

group_by_clause

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

revoke_system_privileges

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

rolling_migration_clauses

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

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 }
  | ( CELL_FLASH_CACHE ( KEEP | NONE | DEFAULT ) )
 | ENCRYPT
 } ...
)

supplemental_plsql_clause

DATA FOR PROCEDURAL REPLICATION

using_snapshot_clause

  USING SNAPSHOT { snapshot_name | AT SCN snapshot_SCN | AT snapshot_timestamp }

alter_analytic_view

ALTER ANALYTIC VIEW [ schema. ] analytic_view_name 
  { RENAME TO new_av_name | COMPILE };

alter_inmemory_join_group

ALTER INMEMORY JOIN GROUP [ schema. ] join_group
  { ADD | REMOVE } ( [ schema. ] table ( column ) ) ;

alter_synonym

ALTER [ PUBLIC ] SYNONYM [ schema. ] synonym
  { EDITIONABLE | NONEDITIONABLE | COMPILE } ;

cache_clause

CACHE cache_specification [, cache_specification]...

calc_measure_clause

AS ( calc_meas_expression )

composite_hash_partitions

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

create_pdb_decrypt_from_xml

DECRYPT USING 'transport_secret'

create_procedure

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
PROCEDURE plsql_procedure_source

db_user_proxy_clauses

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

default_measure_clause

DEFAULT MEASURE measure

drop_function

DROP FUNCTION [ schema. ] function_name ;

drop_table

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

hash_partitions_by_quantity

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

hier_attr_clause

hier_attr_name [ classification_clause ]...

import_keys

IMPORT [ ENCRYPTION ] KEYS WITH SECRET secret
  FROM 'filename'
  [ FORCE KEYSTORE ]
  IDENTIFIED BY keystore_password
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

index_expr

{ column | column_expression }

into_clause

INTO [ schema. ] table

isolate_keystore

ISOLATE KEYSTORE INDENTIFIED BY isolated_keystore_password
FROM ROOT KEYSTORE [ FORCE KEYSTORE ]
IDENTIFIED BY { EXTERNAL STORE | united_keystore_password }
[ WITH BACKUP [ USING 'backup_identifier' ] ]

qualified_disk_clause

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

row_pattern_quantifier

* [ ? ]
| + [ ? ]
| ? [ ? ]
| { [ unsigned_integer ] , [ unsigned_integer ] } [ ? ]
| { unsigned_integer }

Note: The curly brackets are part of the syntax rather than BNF notation.

update_set_clause

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

JSON_exists_condition

JSON_EXISTS( expr [ FORMAT JSON ], JSON_basic_path_expression
  [ JSON_passing_clause] 
  [ JSON_exists_on_error_clause ]
  [ JSON_exists_on_empty_clause ] )

JSON_exists_on_empty_clause

{ ERROR | TRUE | FALSE } ON EMPTY

alter_system_set_clause

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

alter_tablespace_encryption

ENCRYPTION
  { 
  { OFFLINE { [ tablespace_encryption_spec ] ENCRYPT | DECRYPT } }
  | { ONLINE { { [ tablespace_encryption_spec ] { ENCRYPT | REKEY } }
               | DECRYPT }
             [ ts_file_name_convert ] }
  | { FINISH { ENCRYPT | REKEY | DECRYPT } [ ts_file_name_convert ] }
  }

commit

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

constraint_state

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

create_edition

CREATE EDITION edition
  [ AS CHILD OF parent_edition ]
;

create_pfile

CREATE PFILE [= 'pfile_name' ]
   FROM { SPFILE [= 'spfile_name']
        | MEMORY
        } ;

default_selectivity_clause

DEFAULT SELECTIVITY default_selectivity

drop_directory

DROP DIRECTORY directory_name ;

drop_restore_point

DROP RESTORE POINT restore_point [ FOR PLUGGABLE DATABASE pdb_name ] ;

grouping_sets_clause

GROUPING SETS
({ rollup_cube_clause | grouping_expression_list })

immutable_table_no_delete_clause

NO DELETE ( [ LOCKED ] | ( UNTIL integer DAYS AFTER INSERT [LOCKED] ) )

inline_constraint

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

levels_clause

LEVELS ( level_specification [, level_specification ]... )

list_partitionset_clause

PARTITIONSET BY LIST (column)
  PARTITION BY CONSISTENT HASH (column [, column]...)
  [ SUBPARTITION BY { { RANGE | HASH } (column [, column]...)
                    | LIST (column)
                    }
  [ subpartition_template ]
  ]
  PARTITIONS AUTO ( list_partitionset_desc [, list_partitionset_desc]... )

maxsize_clause

MAXSIZE { UNLIMITED | size_clause }

object_properties

{ { column | attribute }
    [ DEFAULT expr ]
    [ { inline_constraint }...  | inline_ref_constraint ]
| { out_of_line_constraint
  | out_of_line_ref_constraint
  | supplemental_logging_props
  }
}

row_pattern_measure_column

expr AS c_alias

segment_attributes_clause

{ physical_attributes_clause
| { TABLESPACE tablespace | TABLESPACE SET tablespace_set }
| logging_clause
}...

subav_factoring_clause

subav_name ANALYTIC VIEW AS (subav_clause)

JSON_condition

{ is_JSON_condition
| JSON_exists_condition
| JSON_textcontains_condition
}

add_range_partition_clause

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

av_measure

meas_name  [{ base_measure_clause | calc_measure_clause }]
  [ classification_clause ]...

character_set_clause

CHARACTER SET character_set

check_datafiles_clause

CHECK DATAFILES [ GLOBAL | LOCAL ]

container_data_clause

{
SET CONTAINER_DATA = { ALL | DEFAULT | ( container_name [, container_name ]... ) }
|
ADD CONTAINER_DATA = ( container_name [, container_name ]... )
|
REMOVE CONTAINER_DATA = ( container_name [, container_name ]... )
}
[ FOR [ schema. ] container_data_object ]

create_attribute_dimension

CREATE [ OR REPLACE ] [ FORCE | NOFORCE ] ATTRIBUTE DIMENSION
  [ schema. ] attr_dimension [ SHARING "=" ( METADATA | NONE ) ] [ classification_clause ]... ]
  [ DIMENSION TYPE { STANDARD | TIME } ]
  attr_dim_using_clause
  attributes_clause
  [ attr_dim_level_clause ]...
  [ all_clause ]
;

create_pdb_from_mirror_copy

new_pdb_name FROM base_pdb_name USING MIRROR COPY mirror_name

create_restore_point

CREATE [ CLEAN ] RESTORE POINT restore_point
   [ FOR PLUGGABLE DATABASE pdb_name ]   
   [ AS OF {TIMESTAMP | SCN} expr ]
   [ PRESERVE
   | GUARANTEE FLASHBACK DATABASE
   ];

delete_secret

DELETE SECRET FOR CLIENT 'client_identifier'
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

filter_condition

INCLUDING ROWS where_clause

index_partition_description

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

join_clause

table_reference
  { inner_cross_join_clause | outer_join_clause | cross_outer_apply_clause }...

materialized_view_props

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

modify_diskgroup_file

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

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
  | index_compression
  }...
| PARAMETERS ('ODCI_parameters')
| COALESCE [ CLEANUP ] [  parallel_clause ]
| UPDATE BLOCK REFERENCES
| UNUSABLE
}

move_datafile_clause

MOVE DATAFILE ( 'filename' | 'ASM_filename' | file_number )
 [ TO ( 'filename' | 'ASM_filename' ) ]
 [ REUSE ] [ KEEP ]

proxy_clause

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

single_row_function

{ numeric_function
| character_function
| datetime_function
| comparison_function
| conversion_function
| large_object_function
| collection_function
| hierarchical_function
| data_mining_function
| XML_function
| JSON_function
| encoding_decoding_function
| NULL_related_function
| environment_id_function
}

drop_cluster

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

grant_roles_to_programs

role [, role ]... TO program_unit [, program_unit ]...

insert_into_clause

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

add_list_partition_clause

list_values_clause
[ table_partition_description ]
[ external_part_subpart_data_props ]
[ ( { range_subpartition_desc [, range_subpartition_desc] ...
    | list_subpartition_desc [, list_subpartition_desc] ...
    | individual_hash_subparts [, individual_hash_subparts] ...
    }
  ) | hash_subparts_by_quantity ]
[ update_index_clauses ]

alter_dimension

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

alter_flashback_archive

ALTER FLASHBACK ARCHIVE flashback_archive
  { SET DEFAULT
  | { ADD | MODIFY } TABLESPACE tablespace [flashback_archive_quota]
  | REMOVE TABLESPACE tablespace_name
  | MODIFY RETENTION flashback_archive_retention
  | PURGE { ALL | BEFORE { SCN expr | TIMESTAMP expr } }
  | [NO] OPTIMIZE DATA
  };

alter_trigger

ALTER TRIGGER [ schema. ] trigger_name
  { trigger_compile_clause
  | { ENABLE | DISABLE }
  | RENAME TO new_name
  | { EDITIONABLE | NONEDITIONABLE }
  } ;

compound_condition

{ (condition)
| NOT condition
| condition { AND | OR } condition
}

drop_type_body

DROP TYPE BODY [ schema. ] type_name ;

end_session_clauses

{ DISCONNECT SESSION 'session_id, serial_number'
     [ POST_TRANSACTION ]
| KILL SESSION 'session_id, serial_number [, @ instance_id]'
}
[ IMMEDIATE | NOREPLAY ]

export_keys

EXPORT [ ENCRYPTION ] KEYS WITH SECRET secret
  TO 'filename'
  [ FORCE KEYSTORE ]
  IDENTIFIED BY keystore_password
  [ WITH IDENTIFIER IN { 'key_id' [, 'key_id' ]... | ( subquery ) } ]

external_part_subpart_data_props

[ DEFAULT DIRECTORY directory ]
[ LOCATION
   ([ directory: ] 'location_specifier'
      [, [ directory: ] 'location_specifier' ]...
   )
]

list_subpartition_desc

SUBPARTITION [subpartition] list_values_clause
  [read_only_clause] [indexing_clause] [partitioning_storage_clause]
  [external_part_subpart_data_props]

main_model

[ MAIN main_model_name ]
model_column_clauses
[ cell_reference_options ]
model_rules_clause

permanent_tablespace_clause

TABLESPACE tablespace
  [ DATAFILE file_specification [, file_specification ]... ]
  [ permanent_tablespace_attrs ]
  [ IN SHARDSPACE shardspace ]

revoke_roles_from_programs

{ role [, role ]... | ALL } FROM program_unit [, program_unit ]...

undo_tablespace_clause

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

update_index_subpartition

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

user

USER

using_function_clause

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

LOB_partitioning_storage

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

add_calcs_clause

ADD MEASURES (calc_meas_clause [, calc_meas_clause]…)

add_update_secret

{ ADD | UPDATE } SECRET 'secret' FOR CLIENT 'client_identifier'
  [ USING TAG 'tag' ]
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

checkpoint_clause

CHECKPOINT [ GLOBAL | LOCAL ]

diskgroup_volume_clauses

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

drop_dimension

DROP DIMENSION [ schema. ] dimension ;

drop_package

DROP PACKAGE [ BODY ] [ schema. ] package ;

exists_condition

EXISTS (subquery)

file_owner_clause

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

flashback_query_clause

{ VERSIONS BETWEEN { SCN | TIMESTAMP }
    { expr | MINVALUE } AND { expr | MAXVALUE }
| VERSIONS PERIOD FOR valid_time_column BETWEEN
    { expr | MINVALUE } AND { expr | MAXVALUE }
| AS OF { SCN | TIMESTAMP } expr
| AS OF PERIOD FOR valid_time_column expr
}

general_recovery

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

inmemory_duplicate

DUPLICATE | DUPLICATE ALL | NO DUPLICATE

modify_index_subpartition

MODIFY SUBPARTITION subpartition
{ UNUSABLE
| allocate_extent_clause
| deallocate_unused_clause
}

query_block

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

quotagroup_clauses

{ ADD QUOTAGROUP quotagroup_name [ SET property_name = property_value ]
| MODIFY QUOTAGROUP quotagroup_name SET property_name = property_value
| MOVE FILEGROUP filegroup_name TO quotagroup_name
| DROP QUOTAGROUP quotagroup_name
}

relational_table

[ (relational_properties) ]
[ immutable_table_clauses ]
[ blockchain_table_clauses ]
[ DEFAULT COLLATION collation_name ]
[ ON COMMIT { DROP | PRESERVE } DEFINITION ]
[ ON COMMIT { DELETE | PRESERVE } ROWS ]
[ physical_properties ]
[ table_properties ]

simple_case_expression

expr
  { WHEN comparison_expr THEN return_expr }...

source_file_name_convert

SOURCE_FILE_NAME_CONVERT =
  { ( 'filename_pattern', 'replacement_filename_pattern'
      [, 'filename_pattern', 'replacement_filename_pattern' ]... )
    |
    NONE
  }

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 ] }
|
{ switchover_clause | failover_clause }

storage_table_clause

WITH {SYSTEM | USER} MANAGED STORAGE TABLES 

subpartition_by_range

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

switchover_clause

SWITCHOVER TO target_db_name [ VERIFY | FORCE ]

create_materialized_view

CREATE MATERIALIZED VIEW [ schema. ] materialized_view
  [ OF [ schema. ] object_type ]
  [ ( { scoped_table_ref_constraint
      | column_alias [ENCRYPT [encryption_spec]]
      }
      [, { scoped_table_ref_constraint
         | column_alias [ENCRYPT [encryption_spec]]
         }
      ]...
    )
  ]
  [ DEFAULT COLLATION collation_name ]
  { ON PREBUILT TABLE
    [ { WITH | WITHOUT } REDUCED PRECISION ]
  | physical_properties materialized_view_props
  }
  [ USING INDEX
    [ physical_attributes_clause
    | TABLESPACE tablespace
    ]...
  | USING NO INDEX
  ]
  [ create_mv_refresh ]
  [ evaluation_edition_clause ]
  [ { ENABLE | DISABLE } ON QUERY COMPUTATION ]
  [ query_rewrite_clause ]
AS subquery ;

drop_materialized_zonemap

DROP MATERIALIZED ZONEMAP [ schema. ] zonemap_name ;

flashback_table

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

revoke

REVOKE
  { { revoke_system_privileges | revoke_object_privileges }
    [ CONTAINER = { CURRENT | ALL } ] }
  | revoke_roles_from_programs ;

add_logfile_clauses

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

alter_database_link

ALTER [ SHARED ] [ PUBLIC ] DATABASE LINK dblink
  { CONNECT TO user IDENTIFIED BY password [ dblink_authentication ]
  | dblink_authentication
  };

alter_datafile_clause

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

alter_function

ALTER FUNCTION [ schema. ] function_name
{ function_compile_clause | { EDITIONABLE | NONEDITIONABLE } }

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

close_keystore

SET KEYSTORE CLOSE
  [ IDENTIFIED BY { EXTERNAL STORE | keystore_password } ]
  [ CONTAINER = { ALL | CURRENT } ]

composite_range_partitions

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

create_keystore

CREATE
  { KEYSTORE 'keystore_location'
  | [ LOCAL ] AUTO_LOGIN KEYSTORE FROM KEYSTORE 'keystore_location'
  }
  IDENTIFIED BY keystore_password

create_operator

CREATE [ OR REPLACE ] OPERATOR
   [ schema. ] operator binding_clause ; [ SHARING "=" ( METADATA | NONE )]

create_type

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
TYPE plsql_type_source

cursor_expression

CURSOR (subquery)

deallocate_unused_clause

DEALLOCATE UNUSED [ KEEP size_clause ]

drop_disk_clause

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_library

DROP LIBRARY library_name ;

hierarchies_clause

HIERARCHIES ( [ hier_id [, hier_id]... ] )

hierarchy_clause

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

index_compression

{ prefix_compression
| advanced_index_compression
}

inmemory_priority

PRIORITY { NONE | LOW | MEDIUM | HIGH | CRITICAL }

local_XMLIndex_clause

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

maximize_standby_db_clause

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

memoptimize_read_clause

[ { (MEMOPTIMIZE FOR READ) | (NO MEMOPTIMIZE FOR READ) } ]

outer_join_type

{ FULL | LEFT | RIGHT } [ OUTER ]

prefix_compression

COMPRESS [ integer ] | NOCOMPRESS 

string

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

unusable_editions_clause

[ UNUSABLE BEFORE { CURRENT EDITION | EDITION edition } ]
[ UNUSABLE BEGINNING WITH { CURRENT EDITION | EDITION edition | NULL EDITION } ]

create_java

CREATE [ OR REPLACE ] [ AND { RESOLVE | COMPILE } ] [ NOFORCE ]
  JAVA { { SOURCE | RESOURCE } NAMED [ schema. ] primary_name
       | CLASS [ SCHEMA schema ]
       }
  [ SHARING = { METADATA | NONE } ]
  [ invoker_rights_clause ]
  [ RESOLVER ( (match_string [,] { schema_name | - })...) ]
  { USING { BFILE (directory_object_name, server_file_name)
          | { CLOB | BLOB | BFILE } subquery
          | 'key_for_BLOB'
          }
  | AS source_char
  } ;

drop_user

DROP USER user [ CASCADE ] ;

savepoint

SAVEPOINT savepoint ;

alter_system_reset_clause

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

alter_system

ALTER SYSTEM
  { archive_log_clause
  | checkpoint_clause
  | check_datafiles_clause
  | distributed_recov_clauses
  | FLUSH { SHARED_POOL | GLOBAL CONTEXT | BUFFER_CACHE | FLASH_CACHE          
                | REDO TO target_db_name [ [ NO ] CONFIRM APPLY ] }
  | end_session_clauses
  | SWITCH LOGFILE
  | { SUSPEND | RESUME }
  | quiesce_clauses
  | rolling_migration_clauses
  | rolling_patch_clauses
  | security_clauses
  | affinity_clauses
  | shutdown_dispatcher_clause
  | REGISTER
  | SET alter_system_set_clause
        [ alter_system_set_clause ]...
  | RESET alter_system_reset_clause
          [ alter_system_reset_clause ]...
  | RELOCATE CLIENT client_id
  | cancel_sql_clause
  | FLUSH PASSWORDFILE_METADATA_CACHE
  } ;

blockchain_row_retention_clause

NO DELETE { [ LOCKED ] | (UNTIL integer DAYS AFTER INSERT [ LOCKED ]) }

commit_switchover_clause

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

datetime_expression

expr AT
   { LOCAL
   | TIME ZONE { ' [ + | - ] hh:mi'
               | DBTIMEZONE
               | 'time_zone_name'
               | expr
               }
   }

distributed_recov_clauses

{ ENABLE | DISABLE } DISTRIBUTED RECOVERY

drop_database_link

DROP [ PUBLIC ] DATABASE LINK dblink ;

global_partitioned_index

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

inner_cross_join_clause

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

numeric_file_name

+diskgroup_name.filenumber.incarnation_number

object_table_substitution

[ NOT ] SUBSTITUTABLE AT ALL LEVELS

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 ]

on_range_partitioned_table

( PARTITION
    [ partition ]
    [ { segment_attributes_clause
      | index_compression
      }...
    ] [ USABLE | UNUSABLE ]
      [, PARTITION
          [ partition ]
          [ { segment_attributes_clause
            | index_compression
            }...
          ] [ USABLE | 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 ]
  ]...

pivot_clause

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

rebalance_diskgroup_clause

REBALANCE
  [ { [ { WITH | WITHOUT } phase [, phase]... ] [ POWER integer ] [ WAIT | NOWAIT ] }
    |
    { MODIFY POWER [ integer ] }
  ]

reference_partitioning

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

row_movement_clause

{ ENABLE | DISABLE } ROW MOVEMENT

table_collection_expression

TABLE (collection_expression) [ (+) ]

associate_statistics

ASSOCIATE STATISTICS WITH
  { column_association | function_association }
  [ storage_table_clause ] ;

create_database

CREATE DATABASE [ database ]
  { USER SYS IDENTIFIED BY password
  | USER SYSTEM IDENTIFIED BY password
  | CONTROLFILE REUSE
  | MAXDATAFILES integer
  | MAXINSTANCES integer
  | CHARACTER SET charset
  | NATIONAL CHARACTER SET charset
  | SET DEFAULT
      { BIGFILE | SMALLFILE } TABLESPACE
  | database_logging_clauses
  | tablespace_clauses
  | set_time_zone_clause
  | [ BIGFILE | SMALLFILE ] USER_DATA TABLESPACE tablespace_name
      DATAFILE datafile_tempfile_spec [, datafile_tempfile_spec ]...
  | enable_pluggable_database
  }... ;

create_directory

CREATE [ OR REPLACE ] DIRECTORY directory
  [ SHARING = { METADATA | NONE } ]
  AS 'path_name' ;

create_view

CREATE [OR REPLACE]
  [[NO] FORCE]
  [ EDITIONING | EDITIONABLE [ EDITIONING ] | NONEDITIONABLE ]
  VIEW [schema.] view
  [ SHARING = { METADATA | DATA | EXTENDED DATA | NONE } ]
  [ ( { alias [ VISIBLE | INVISIBLE ] [ inline_constraint... ]
      | out_of_line_constraint
      }
        [, { alias [ VISIBLE | INVISIBLE ] [ inline_constraint...]
           | out_of_line_constraint
           }
        ]
    )
  | object_view_clause
  | XMLType_view_clause
  ]
  [ DEFAULT COLLATION collation_name ]
  [ BEQUEATH { CURRENT_USER | DEFINER } ]
  AS subquery [ subquery_restriction_clause ]
  [ CONTAINER_MAP | CONTAINERS_DEFAULT ] ;

error_logging_clause

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

grantee_clause

{ user | role | PUBLIC }
  [, { user | role | PUBLIC } ]...

hier_attr_name

{   MEMBER_NAME
  | MEMBER_UNIQUE_NAME
  | MEMBER_CAPTION
  | MEMBER_DESCRIPTION
  | LEVEL_NAME
  | HIER_ORDER
  | DEPTH
  | IS_LEAF
  | PARENT_LEVEL_NAME
  | PARENT_UNIQUE_NAME
}

merge_insert_clause

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

merge

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

pdb_storage_clause

STORAGE
  { ( { MAXSIZE { UNLIMITED | size_clause }
        |
        MAX_AUDIT_SIZE { UNLIMITED | size_clause }
        |
        MAX_DIAG_SIZE { UNLIMITED | size_clause }
      }...
    )
  |
  UNLIMITED
  }

add_disk_clause

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

attributes_clause

ATTRIBUTES ( attr_dim_attribute_clause [, attr_dim_attribute_clause ]... )

create_flashback_archive

CREATE FLASHBACK ARCHIVE [DEFAULT] flashback_archive
  TABLESPACE tablespace
  [flashback_archive_quota]
  [ [NO] OPTIMIZE DATA ]
  flashback_archive_retention
;

create_indextype

CREATE [ OR REPLACE ] INDEXTYPE [ schema. ] indextype
  [ SHARING "=" ( METADATA | NONE ) ]
  FOR [ schema. ] operator (parameter_type [, parameter_type ]...)
        [, [ schema. ] operator (parameter_type [, parameter_type ]...)
        ]...
  using_type_clause
  [WITH LOCAL [RANGE] PARTITION ]
  [ storage_table_clause ]
;

create_zonemap_as_subquery

CREATE MATERIALIZED ZONEMAP
  [ schema. ] zonemap_name
  [ zonemap_attributes ]
  [ zonemap_refresh_clause ]
  [ { ENABLE | DISABLE } PRUNING ]
  AS query_block

default_table_compression

TABLE { COMPRESS FOR OLTP      
      | COMPRESS FOR QUERY { LOW | HIGH }
      | COMPRESS FOR ARCHIVE { LOW | HIGH }
      | NOCOMPRESS
      }

disk_offline_clause

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

drop_materialized_view

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

expression_list

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

flashback_database

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

flashback_mode_clause

FLASHBACK { ON | OFF }

partitionset_clauses

{ range_partitionset_clause | list_partitionset_clause }

property_clause

PROPERTY { SET | REMOVE } DEFAULT_CREDENTIAL = qualified_credential_name

purge

PURGE
  { TABLE table
  | INDEX index
  | TABLESPACE tablespace [ USER username ]
  | TABLESPACE SET tablespace_set [ USER username ]
  | RECYCLEBIN
  | DBA_RECYCLEBIN
  } ;

relational_properties

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

revokee_clause

{ user | role | PUBLIC }
  [, { user | role | PUBLIC } ]...

row_pattern_definition

variable_name AS condition

service_name_convert

SERVICE_NAME_CONVERT =
  { ( 'service_name', 'replacement_service_name'
      [, 'service_name', 'replacement_service_name' ]... )
    |
    NONE
  }

supplemental_db_logging

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

unpivot_clause

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

using_type_clause

USING [ schema. ] implementation_type [ array_DML_clause ]

add_update_secret_seps

(ADD | UPDATE ) SECRET 'secret' FOR CLIENT 'client_identifier' 
    [ USING TAG 'tag' ] 
     TO [ LOCAL ] AUTO_LOGIN KEYSTORE directory

base_measure_clause

[ FACT [alias.] ] column [ meas_aggregate_clause ]

cluster_clause

BY [ LINEAR | INTERLEAVED ] ORDER clustering_columns

cluster_range_partitions

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

column_definition

column [ datatype [ COLLATE column_collation_name ] ]
  [ SORT ] [ VISIBLE | INVISIBLE ]
  [ DEFAULT [ ON NULL ] expr | identity_clause ]
  [ ENCRYPT encryption_spec ]
  [ { inline_constraint }...
  | inline_ref_constraint
  ]

create_pdb_from_seed

ADMIN USER admin_user_name IDENTIFIED BY password
  [ pdb_dba_roles ]
  [ parallel_pdb_creation_clause ]
  [ default_tablespace ]
  [ pdb_storage_clause ]
  [ file_name_convert ]
  [ service_name_convert ]
  [ path_prefix_clause ]
  [ tempfile_reuse_clause ]
  [ user_tablespaces_clause ]
  [ standbys_clause ]
  [ logging_clause ]
  [ create_file_dest_clause ]
  [ HOST = 'hostname' ]
  [ PORT = number ]

create_pluggable_database

CREATE PLUGGABLE DATABASE
  { { pdb_name [ AS APPLICATION CONTAINER ] | using_snapshot_clause} | { AS SEED } }
  { create_pdb_from_seed | create_pdb_clone | create_pdb_from_xml | create_pdb_from_mirror_copy 
    | container_map_clause } pdb_snapshot_clause ;

create_schema

CREATE SCHEMA AUTHORIZATION schema
   { create_table_statement
   | create_view_statement
   | grant_statement
   }...
;

dblink

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

disk_region_clause

[ HOT | COLD ] [ MIRRORHOT | MIRRORCOLD ]

diskgroup_template_clauses

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

identity_clause

GENERATED
[ ALWAYS | BY DEFAULT [ ON NULL ] ]
AS IDENTITY [ ( identity_options ) ]

ilm_tiering_policy

{ TIER TO tablespace [ SEGMENT | GROUP ] [ ON function_name ] }
|
{ TIER TO tablespace READ ONLY [ SEGMENT | GROUP ] 
  { { AFTER ilm_time_period OF { { NO ACCESS } | { NO MODIFICATION } | CREATION } }
  | { ON function_name } } }

lead_cdb_clause

  SET LEAD_CDB = { TRUE | FALSE }

recovery_clauses

{ general_recovery
| managed_standby_recovery
| BEGIN BACKUP
| END BACKUP
}

rename

RENAME old_name TO new_name ;

sample_clause

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

type_constructor_expression

[ NEW ] [ schema. ]type_name
   ([ expr [, expr ]... ])

alter_database_dictionary

ALTER DATABASE DICTIONARY 
{   ENCRYPT CREDENTIALS
  | REKEY CREDENTIALS
  | DELETE CREDENTIALS KEY 
};

attr_dim_level_clause

LEVEL level [ { NOT NULL  |  SKIP WHEN NULL } ]
  [ classification_clause [ classification_clause ]...
  [ LEVEL TYPE 
      {   STANDARD 
        | YEARS 
        | HALF_YEARS
        | QUARTERS
        | MONTHS
        | WEEKS
        | DAYS
        | HOURS
        | MINUTES
        | SECONDS
      }
  ]
  key_clause [ alternate_key_clause ]
  [ MEMBER NAME expression ]
  [ MEMBER CAPTION expression ] 
  [ MEMBER DESCRIPTION expression ]
  [ ORDER BY  [ MIN | MAX ] dim_order_clause 
                    [, [ MIN | MAX ] dim_order_clause ]... ]
  ]
  [ DETERMINES ( attribute [, attribute]... ) ]

autoextend_clause

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

by_users_with_roles

BY USERS WITH GRANTED ROLES role [, role]...

check_diskgroup_clause

CHECK [ REPAIR | NOREPAIR ]

condition

{ comparison_condition
| floating_point_condition
| logical_condition
| model_condition
| multiset_condition
| pattern_matching_condition
| range_condition
| null_condition
| XML_condition
| JSON_condition
| compound_condition
| exists_condition
| in_condition
| is_of_type_condition
}

create_datafile_clause

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

default_cost_clause

DEFAULT COST (cpu_cost, io_cost, network_cost)

encryption_spec

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

hash_subparts_by_quantity

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

in_condition

{ expr [ NOT ] IN ({ expression_list | subquery })
| ( expr [, expr ]... )
    [ NOT ] IN ({ expression_list [, expression_list ]...
                | subquery
                }
               )
}

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

on_hash_partitioned_table

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

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
        [ external_part_subpart_data_props ]
      ]...
)

rebuild_clause

REBUILD
  [ { PARTITION partition
    | SUBPARTITION subpartition
    }
  | { REVERSE | NOREVERSE }
  ]
  [ parallel_clause
  | TABLESPACE tablespace
  | PARAMETERS ( 'ODCI_parameters' )
  | XMLIndex_parameters_clause
  | ONLINE
  | physical_attributes_clause
  | index_compression
  | logging_clause
  | partial_index_clause
  ]...

subpartition_by_hash

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

subpartition_by_list

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

using_index_clause

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

create_materialized_zonemap

{ create_zonemap_on_table | create_zonemap_as_subquery } ;

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 ]

level_hier_clause

( level [ CHILD  OF level ]... )

scoped_table_ref_constraint

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

table_index_clause

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

LOB_retention_clause

RETENTION [ MAX | MIN integer | AUTO | NONE ]

alter_hierarchy

ALTER HIERARCHY [ schema. ] hierarchy_name 
  { RENAME TO new_hier_name | COMPILE };

create_context

CREATE [ OR REPLACE ] CONTEXT namespace
  USING [ schema. ] package
  [ SHARING "=" ( METADATA | NONE ) ]
  [ INITIALIZED { EXTERNALLY | GLOBALLY }
  | ACCESSED GLOBALLY
  ] ;

create_key

CREATE [ ENCRYPTION ] KEY
  [ USING TAG 'tag' ]
  [ USING ALGORITHM 'encrypt_algorithm' ]
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]
  [ CONTAINER = { ALL | CURRENT } ]

disassociate_statistics

DISASSOCIATE STATISTICS FROM
   { COLUMNS [ schema. ]table.column
               [, [ schema. ]table.column ]...
   | FUNCTIONS [ schema. ]function
                 [, [ schema. ]function ]...
   | PACKAGES [ schema. ]package
                [, [ schema. ]package ]...
   | TYPES [ schema. ]type
             [, [ schema. ]type ]...
   | INDEXES [ schema. ]index
               [, [ schema. ]index ]...
   | INDEXTYPES [ schema. ]indextype
                  [, [ schema. ]indextype ]...
   }
   [ FORCE ] ;

flashback_archive_clause

FLASHBACK ARCHIVE [flashback_archive] | NO FLASHBACK ARCHIVE

function

{ single_row_function
| aggregate_function
| analytic_function
| object_reference_function
| model_function
| user_defined_function
| OLAP_function
| data_cartridge_function
}

ilm_clause

ILM
{ ADD POLICY ilm_policy_clause
| { DELETE | ENABLE | DISABLE } POLICY ilm_policy_name
| DELETE_ALL | ENABLE_ALL | DISABLE_ALL
}

inmemory_clause

INMEMORY [ inmemory_attributes ]
| NO INMEMORY

keystore_clause

KEYSTORE IDENTIFIED BY [ ( EXTERNAL STORE ) | keystore_password ] 
    [ NO REKEY ]

local_partitioned_index

LOCAL
[ on_range_partitioned_table
| on_list_partitioned_table
| on_hash_partitioned_table
| on_comp_partitioned_table
]

merge_update_clause

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

row_pattern_primary

variable_name
| $
| ^
| ( [ row_pattern ] )
| {- row_pattern -}
| row_pattern_permute

Note: The curly brackets are part of the syntax rather than BNF notation.

select

subquery [ for_update_clause ] ;

set_encryption_key

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

supplemental_subset_replication_clause

DATA SUBSET DATABASE REPLICATION 

table_properties

[ column_properties ]
[ read_only_clause ]
[ indexing_clause ]
[ table_partitioning_clauses ]
[ attribute_clustering_clause ]
[ CACHE | NOCACHE ]
[ RESULT_CACHE ( MODE {DEFAULT | FORCE } ) ] 
[ parallel_clause ]
[ ROWDEPENDENCIES | NOROWDEPENDENCIES ]
[ enable_disable_clause ]...
[ row_movement_clause ]
[ flashback_archive_clause ]
[ ROW ARCHIVAL ]
[ AS subquery | { FOR EXCHANGE WITH TABLE [ schema .] table } ]

with_clause

WITH [ plsql_declarations ] [ subquery_factoring_clause | subav_factoring_clause ]
              [, { subquery_factoring_clause | subav_factoring_clause } ]

add_hash_partition_clause

partitioning_storage_clause
[ update_index_clauses ]
[ parallel_clause ]
[ read_only_clause ]
[ indexing_clause ]

alter_keystore_password

ALTER KEYSTORE PASSWORD
  [ FORCE KEYSTORE ]
  IDENTIFIED BY old_keystore_password
  SET new_keystore_password
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

backup_keystore

BACKUP KEYSTORE [ USING 'backup_identifier' ]
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ TO 'keystore_location' ]

cluster_index_clause

CLUSTER [ schema. ] cluster index_attributes

create_diskgroup

CREATE DISKGROUP diskgroup_name
  [ { HIGH | NORMAL | FLEX | EXTENDED [ SITE site_name ] | EXTERNAL } REDUNDANCY ]
  { [ QUORUM | REGULAR ] [ FAILGROUP failgroup_name ]
    DISK qualified_disk_clause [, qualified_disk_clause]...
  }...
  [ ATTRIBUTE { 'attribute_name' = 'attribute_value' }
              [, 'attribute_name' = 'attribute_value' ]... ]
;

create_table

CREATE [ { GLOBAL | PRIVATE } TEMPORARY | SHARDED | DUPLICATED | [ IMMUTABLE ] BLOCKCHAIN 
  | IMMUTABLE  ] 
   TABLE
  [ schema. ] table
  [ SHARING = { METADATA | DATA | EXTENDED DATA | NONE } ]
  { relational_table | object_table | XMLType_table }
  [ MEMOPTIMIZE FOR READ ]
  [ MEMOPTIMIZE FOR WRITE ]
  [ PARENT [ schema. ] table ] ;

dim_order_clause

attribute [ ASC | DESC ] [ NULLS { FIRST | LAST } ]

drop_analytic_view

DROP ANALYTIC VIEW [ schema. ] analytic_view_name;

full_database_recovery

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

model_clause

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

physical_properties

{ [ deferred_segment_creation ] segment_attributes_clause [ table_compression ]
    [ inmemory_table_clause ] [ ilm_clause ] 
| [ deferred_segment_creation ] ORGANIZATION
  { HEAP [ segment_attributes_clause ] heap_org_table_clause 
  | INDEX [ segment_attributes_clause ] index_org_table_clause
  | EXTERNAL PARTITION ATTRIBUTES external_table_clause 
    [ REJECT LIMIT ]
  }
| CLUSTER cluster (column [, column ]...)
}

row_pattern_clause

MATCH_RECOGNIZE (  
  [ row_pattern_partition_by ]
  [ row_pattern_order_by ]
  [ row_pattern_measures ]
  [ row_pattern_rows_per_match ]
  [ row_pattern_skip_to ]
  PATTERN (row_pattern)
  [ row_pattern_subset_clause ]
  DEFINE row_pattern_definition_list
  )

row_pattern_measures

MEASURES row_pattern_measure_column [, row_pattern_measure_column ]...

secret_management_clauses

{ add_update_secret
| delete_secret
| add_update_secret_seps
| delete_secret_seps
}

tablespace_clauses

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

unpivot_in_clause

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

usergroup_clauses

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

using_statistics_type

USING { [ schema. ] statistics_type | NULL }

varray_storage_clause

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

create_rollback_segment

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

delete

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

drop_database

DROP DATABASE ;

drop_inmemory_join_group

DROP INMEMORY JOIN GROUP [ schema. ] join_group ;                              

drop_profile

DROP PROFILE profile [ CASCADE ] ;

explain_plan

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

LOB_partition_storage

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

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 ] 

controlfile_clauses

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

create_inmemory_join_group

CREATE INMEMORY JOIN GROUP [ schema. ] join_group
  ( [ schema. ] table ( column ) , [ schema. ] table ( column )
    [, [ schema. ] table ( column ) ]... ) ;

create_user

CREATE USER user
   { { 
       IDENTIFIED       
    
        {
           BY password [ [HTTP] DIGEST { ENABLE | DISABLE } ]
           | EXTERNALLY [ AS 'certificate_DN'  |  AS 'kerberos_principal_name' ]
           | GLOBALLY [ AS '{ directory_DN | { AZURE_USER | AZURE_ROLE }=value  
                                       | {IAM_GROUP_NAME | IAM_PRINCIPAL_NAME}=value  }']
           }

        }               
          | NO AUTHENTICATION
   }
   [ DEFAULT COLLATION collation_name ]
   [ DEFAULT TABLESPACE tablespace
   | [ LOCAL ] TEMPORARY TABLESPACE { tablespace | tablespace_group_name }
   | { QUOTA { size_clause | UNLIMITED } ON tablespace }...
   | PROFILE profile
   | PASSWORD EXPIRE
   | ACCOUNT { LOCK | UNLOCK }
     [ DEFAULT TABLESPACE tablespace
     | TEMPORARY TABLESPACE
          { tablespace | tablespace_group_name }
     | { QUOTA { size_clause | UNLIMITED } ON tablespace }...
     | PROFILE profile
     | PASSWORD EXPIRE
     | ACCOUNT { LOCK | UNLOCK }
     | ENABLE EDITIONS
     | CONTAINER = { CURRENT | ALL }
     ]...
  ] ;

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

dim_by_clause

DIMENSION BY ( dim_key [, dim_key ]... )

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

extended_attribute_clause

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

failover_clause

FAILOVER TO target_db_name [ FORCE ]

immutable_table_clauses

[ immutable_table_no_drop_clause ]
    [ immutable_table_no_delete_clause ]

meas_aggregate_clause

AGGREGATE BY aggr_function

pdb_dba_roles

ROLES = ( role [, role ]... )

rename_disk_clause

RENAME
  { DISK old_disk_name TO new_disk_name [, old_disk_name TO new_disk_name ]...
  | DISKS ALL }

return_rows_clause

RETURN { UPDATED | ALL } ROWS

rollup_cube_clause

{ ROLLUP | CUBE } (grouping_expression_list)

security_clause

GUARD { ALL | STANDBY | NONE }

shutdown_dispatcher_clause

SHUTDOWN [ IMMEDIATE ] dispatcher_name

subquery

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

table_partitioning_clauses

{ range_partitions
| list_partitions
| hash_partitions
| composite_range_partitions
| composite_list_partitions
| composite_hash_partitions
| reference_partitioning
| system_partitioning
| consistent_hash_partitions
| consistent_hash_with_subpartitions
| partitionset_clauses
}

unified_audit

AUDIT
  { POLICY policy
    [ { BY user [, user]... }
    | { EXCEPT user [, user]... }
    | by_users_with_roles ]
    [ WHENEVER [ NOT ] SUCCESSFUL ]
  }
  |
  { CONTEXT NAMESPACE namespace ATTRIBUTES attribute [, attribute ]...
      [, CONTEXT NAMESPACE namespace ATTRIBUTES attribute [, attribute ]... ]...
    [ BY user [, user]... ]
  } ;

user_clauses

{ ADD USER 'user' [, 'user']...
| DROP USER 'user' [, 'user']... [CASCADE]
| REPLACE USER 'old_user' WITH 'new_user' [, 'old_user' WITH 'new_user']...
}

create_mv_refresh

{ REFRESH
  { { FAST | COMPLETE | FORCE }
  | { ON DEMAND 
    | ON COMMIT 
    | ON STATEMENT
    }
  | { 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
}

create_synonym

CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ]
   [ PUBLIC ] SYNONYM
   [ schema. ] synonym
   [ SHARING = { METADATA | NONE } ]
   FOR [ schema. ] object [ @ dblink ] ;

drop_flashback_archive

DROP FLASHBACK ARCHIVE flashback_archive;

drop_java

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

multi_table_insert

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

XMLType_virtual_columns

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

attribute_clustering_clause

CLUSTERING [ clustering_join ] cluster_clause
           [ clustering_when ] [ zonemap_clause ]

auditing_by_clause

BY user [, user ]...

auditing_on_clause

ON { [ schema. ] object
   | DIRECTORY directory_name
   | MINING MODEL [ schema. ] model
   | SQL TRANSLATION PROFILE [ schema. ] profile
   | DEFAULT
   }

create_cluster

CREATE CLUSTER [ schema. ] cluster
  (column datatype [ COLLATE column_collation_name ] [ SORT ]
    [, column datatype [ COLLATE column_collation_name ] [ SORT ] ]...
  )
  [ SHARING "=" ( METADATA | NONE ) ]
  [ { physical_attributes_clause
    | SIZE size_clause
    | TABLESPACE tablespace
    | { INDEX
      | [ SINGLE TABLE ]
        HASHKEYS integer [ HASH IS expr ]
      }
    }...
  ]
  [ parallel_clause ]
  [ NOROWDEPENDENCIES | ROWDEPENDENCIES ]
  [ CACHE | NOCACHE ] [ cluster_range_partitions ] ;

drop_context

DROP CONTEXT namespace ;

hier_attrs_clause

HIERARCHICAL ATTRIBUTES ( hier_attr_clause [, hier_attr_clause ]... )

is_JSON_condition

expr IS [ NOT ] JSON [ FORMAT JSON ] [ STRICT | LAX ]
[ { WITH | WITHOUT } UNIQUE KEYS ]

list_partitionset_desc

PARTITIONSET partition_set list_values_clause
  [ TABLESPACE SET tablespace_set ]
  [ LOB_storage_clause ]
  [ SUBPARTITIONS STORE IN ( tablespace_set )... ]

list_values_clause

VALUES ( list_values | DEFAULT )

local_domain_index_clause

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

physical_attributes_clause

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

read_only_clause

{ READ ONLY } | { READ WRITE }

redundancy_clause

[ MIRROR | HIGH | UNPROTECTED | PARITY  ]

row_pattern_factor

row_pattern_primary [ row_pattern_quantifier ]

searched_case_expression

{ WHEN condition THEN return_expr }...

truncate_table

TRUNCATE TABLE [schema.] table
  [ {PRESERVE | PURGE} MATERIALIZED VIEW LOG ]
  [ {DROP [ ALL ] | REUSE} STORAGE ] [ CASCADE ] ;

update

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

JSON_exists_on_error_clause

{ ERROR | TRUE | FALSE } ON ERROR

LOB_compression_clause

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

administer_key_management

ADMINISTER KEY MANAGEMENT
  { keystore_management_clauses
  | key_management_clauses
  | secret_management_clauses
  } ;

alter_tablespace_attrs

{ default_tablespace_params
| MINIMUM EXTENT size_clause
| RESIZE size_clause
| COALESCE
| SHRINK SPACE [ KEEP size_clause ]
| RENAME TO new_tablespace_name
| { BEGIN | END } BACKUP
| datafile_tempfile_clauses
| tablespace_logging_clauses
| tablespace_group_clause
| tablespace_state_clauses
| autoextend_clause
| flashback_mode_clause
| tablespace_retention_clause
| alter_tablespace_encryption
} 

alter_tablespace_set

ALTER TABLESPACE SET tablespace_set alter_tablespace_attrs ;

analytic_function

analytic_function([ arguments ]) OVER (analytic_clause)

array_step

[ { integer | integer TO integer [, integer | integer TO integer ]... } | * ]

Note: The outside square brackets shown in boldface type are part of the syntax.
      In this case, they do not represent optionality.

calc_meas_clause

meas_name AS (expression)

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.

heap_org_table_clause

[ table_compression ] [ inmemory_table_clause ] [ ilm_clause ]

ilm_inmemory_policy

{ SET INMEMORY [ inmemory_attributes ]
| MODIFY INMEMORY inmemory_memcompress
| NO INMEMORY
}
[ SEGMENT ]
{ AFTER ilm_time_period OF { NO ACCESS | NO MODIFICATION | CREATION }
        | ON function_name
        }

index_org_overflow_clause

  [ INCLUDING column_name ]
OVERFLOW [ segment_attributes_clause ]

indexing_clause

INDEXING { ON | OFF }

inmemory_attributes

[ inmemory_memcompress ] [ inmemory_priority ] [ inmemory_distribute ] [ inmemory_duplicate ]

model_expression

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

Note: The outside square brackets shown in boldface type are part of the syntax.
      In this case, they do not represent optionality.

partition_extension_clause

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

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
}

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

analyze

ANALYZE
  { { TABLE [ schema. ] table
    | INDEX [ schema. ] index
    } [ partition_extension_clause ]
  | CLUSTER [ schema. ] cluster
  }
  { validation_clauses
  | LIST CHAINED ROWS [ into_clause ]
  | DELETE [ SYSTEM ] STATISTICS
  } ;

containers_clause

CONTAINERS( [schema.] { table | view } )

create_file_dest_clause

CREATE_FILE_DEST = { NONE | 'directory_path_name' | diskgroup_name }

create_lockdown_profile

CREATE LOCKDOWN PROFILE profile_name 
   { static_base_profile | dynamic_base_profile };

create_spfile

CREATE SPFILE [= 'spfile_name' ]
  FROM { PFILE [= 'pfile_name' ] [ AS COPY ]
       | MEMORY
       } ;

default_tablespace

DEFAULT TABLESPACE tablespace
[ DATAFILE datafile_tempfile_spec ]
[ extent_management_clause ]

dim_ref

[ schema. ] attr_dim_name [ [AS] dim__alias ]

enable_disable_clause

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

filegroup_clauses

{ add_filegroup_clause
| modify_filegroup_clause
| move_to_filegroup_clause
| drop_filegroup_clause
}

grantee_identified_by

user [, user ]... IDENTIFIED BY password [, password ]...

level_specification

( [ [ dim_name. ] hier_name. ] level_name ) 

partition_extended_name

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

range_partitionset_desc

PARTITIONSET partition_set range_values_clause
  [ TABLESPACE SET tablespace_set ]
  [ LOB_storage_clause ]
  [ SUBPARTITIONS STORE IN ( tablespace_set )... ]

rollback

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

row_pattern_permute

PERMUTE ( row_pattern [, row_pattern ]...)

row_pattern_subset_clause

SUBSET row_pattern_subset_item [, row_pattern_subset_item ]...

row_pattern_term

[ row_pattern_term ] row_pattern_factor

set_key

SET [ ENCRYPTION ] KEY
  [ USING TAG 'tag' ]
  [ USING ALGORITHM 'encrypt_algorithm' ]
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]
  [ CONTAINER = { ALL | CURRENT } ]

zonemap_refresh_clause

REFRESH
[ FAST | COMPLETE | FORCE ]
[ ON { DEMAND | COMMIT | LOAD | DATA MOVEMENT | LOAD DATA MOVEMENT } ]

JSON_object_access_expr

table_alias.JSON_column [.JSON_object_key [ array_step ]... ]...

JSON_textcontains_condition

JSON_TEXTCONTAINS( column, JSON_basic_path_expression, string )

create_dimension

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

datafile_tempfile_spec

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

default_tablespace_params

DEFAULT [ default_table_compression ] [ default_index_compression ]
        [ inmemory_clause ] [ ilm_clause ] [ storage_clause ]

default_temp_tablespace

[ BIGFILE | SMALLFILE ] DEFAULT
{ { TEMPORARY TABLESPACE }
| { LOCAL TEMPORARY TABLESPACE FOR { ALL | LEAF } }
} tablespace
[ TEMPFILE file_specification [, file_specification ]...]
[ extent_management_clause ]

dependent_tables_clause

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

drop_diskgroup_file_clause

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

else_clause

ELSE else_expr

enable_pluggable_database

ENABLE PLUGGABLE DATABASE
  [ SEED
  [ file_name_convert ]
  [ SYSTEM tablespace_datafile_clauses ]
  [ SYSAUX tablespace_datafile_clauses ]
  ]
  [ undo_mode_clause ]

expr

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

immutable_table_no_drop_clause

   NO DROP [ UNTIL integer DAYS IDLE ]

keystore_management_clauses

{ create_keystore
| open_keystore
| close_keystore
| backup_keystore
| alter_keystore_password
| merge_into_new_keystore
| merge_into_existing_keystore
| isolate_keystore
| unite_keystore
}

managed_standby_recovery

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

partial_database_recovery

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

qualified_template_clause

ATTRIBUTE
( redundancy_clause 
  striping_clause 
  disk_region_clause
)

security_clauses

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

segment_management_clause

SEGMENT SPACE MANAGEMENT { AUTO | MANUAL }

set_key_tag

SET TAG 'tag' FOR 'key_id'
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

shards_clause

SHARDS( [schema.] { table | view } )

shrink_clause

SHRINK SPACE [ COMPACT ] [ CASCADE ]

size_clause

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

update_index_partition

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

create_trigger

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
TRIGGER plsql_trigger_source

dml_table_expression_clause

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

drop_lockdown_profile

DROP LOCKDOWN PROFILE profile_name ;

drop_procedure

DROP PROCEDURE [ schema. ] procedure ;

drop_tablespace_set

DROP TABLESPACE SET tablespace_set
   [ { DROP | KEEP } QUOTA ]
   [ INCLUDING CONTENTS [ { AND | KEEP } DATAFILES ] [ CASCADE CONSTRAINTS ] ]
   ;

drop_view

DROP VIEW [ schema. ] view [ CASCADE CONSTRAINTS ] ;

for_update_clause

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

grant_system_privileges

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

allow_disallow_clustering

{ ALLOW | DISALLOW } CLUSTERING

column_association

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

database_logging_clauses

{ LOGFILE
    [ GROUP integer ] file_specification
      [, [ GROUP integer ] file_specification ]...
| MAXLOGFILES integer
| MAXLOGMEMBERS integer
| MAXLOGHISTORY integer
| { ARCHIVELOG | NOARCHIVELOG }
| FORCE LOGGING
| SET STANDBY NOLOGGING FOR {DATA AVAILABILITY | LOAD PERFORMANCE}

drop_diskgroup

DROP DISKGROUP diskgroup_name
   [  FORCE INCLUDING CONTENTS
   | { INCLUDING | EXCLUDING } CONTENTS
   ];

drop_indextype

DROP INDEXTYPE [ schema. ] indextype [ FORCE ] ;

drop_index

DROP INDEX [ schema. ] index [ ONLINE ] [ FORCE ]
  [ { DEFERRED | IMMEDIATE } INVALIDATION ];

hier_ref

[ schema. ] hier_name [ [ AS ] hier_alias ] [ DEFAULT ]

hierarchical_query_clause

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

integer

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

move_keys

MOVE [ENCRYPTION] KEYS  
    TO NEW KEYSTORE keystore_location1
    IDENTIFIED BY keystore1_password
    FROM [FORCE] KEYSTORE
    IDENTIFIED BY keystore_password
    [WITH IDENTIFIER IN
      { 'key_identifier' [, 'key_identifier']... | ( subquery ) } ]
    [WITH BACKUP [USING 'backup_identifier'] ];

permanent_tablespace_attrs

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

range_subpartition_desc

SUBPARTITION [subpartition] range_values_clause
  [read_only_clause] [indexing_clause] [partitioning_storage_clause]
  [external_part_subpart_data_props]

redo_log_file_spec

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

references_clause

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

returning_clause

{ RETURN | RETURNING } expr [, expr ]...
INTO data_item [, data_item ]...

standbys_clause

STANDBYS = { ( 'cdb_name' [, 'cdb_name' ]... )
           | { ALL [ EXCEPT ( 'cdb_name' [, 'cdb_name' ]... ) ] }
           | NONE
           }

striping_clause

[ FINE | COARSE ]

unite_keystore

UNITE KEYSTORE INDENTIFIED BY isolated_keystore_password
WITH ROOT KEYSTORE [ FORCE KEYSTORE ]
IDENTIFIED BY { EXTERNAL STORE | united_keystore_password }
[ WITH BACKUP [ USING 'backup_identifier' ] ]

ASM_filename

{ fully_qualified_file_name
| numeric_file_name
| incomplete_file_name
| alias_file_name
}

XMLIndex_clause

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

affinity_clauses

{ ENABLE AFFINITY [ schema.]table [SERVICE service_name ]
| 
DISABLE AFFINITY [ schema.]table   
}

alter_cluster

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

alter_type

ALTER TYPE [ schema. ] type_name
{ alter_type_clause | { EDITIONABLE | NONEDITIONABLE } }

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

cdb_fleet_clauses

  { lead_cdb_clause | lead_cdb_uri_clause }

create_database_link

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

domain_index_clause

indextype
   [ local_domain_index_clause ]
   [ parallel_clause ]
   [ PARAMETERS ('ODCI_parameters') ]

evaluation_edition_clause

EVALUATE USING { CURRENT EDITION | EDITION edition | NULL EDITION }

hier_using_clause

USING [ schema. ] attribute_dimension level_hier_clause

ilm_policy_clause

{ ilm_compression_policy | ilm_tiering_policy | ilm_inmemory_policy }

inmemory_table_clause

[ { INMEMORY [ inmemory_attributes ] } | { NO INMEMORY } ]
[ inmemory_column_clause ]

key_clause

KEY { [(] attribute [)] | ( attribute [, attribute]... ) }

lead_cdb_uri_clause

  SET LEAD_CDB_URI = uri_string

logfile_clauses

{ { ARCHIVELOG [ MANUAL ]
  | NOARCHIVELOG
  }
| [ NO ] FORCE LOGGING
| SET STANDBY NOLOGGING FOR {DATA AVAILABILITY | LOAD PERFORMANCE}
| 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
}

migrate_key

SET [ ENCRYPTION ] KEY
  IDENTIFIED BY HSM_auth_string
  [ FORCE KEYSTORE ]
  MIGRATE USING software_keystore_password
  [ WITH BACKUP [ USING 'backup_identifier' ] ]

nested_table_partition_spec

PARTITION partition [segment_attributes_clause]

on_list_partitioned_table

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

open_keystore

SET KEYSTORE OPEN
  [ FORCE KEYSTORE ]
  IDENTIFIED BY { EXTERNAL STORE | keystore_password }
  [ CONTAINER = { ALL | CURRENT } ]

parallel_clause

{ NOPARALLEL | PARALLEL [ integer ] }

row_pattern_rows_per_match

ONE ROW PER MATCH
| ALL ROWS PER MATCH

row_pattern

[ row_pattern | ] row_pattern_term

Note: The vertical bar is part of the syntax rather than BNF notation.

create_role

CREATE ROLE role
   [ NOT IDENTIFIED
   | IDENTIFIED { BY password
                | USING [ schema. ] package
                | EXTERNALLY
                | GLOBALLY AS '{ domain_name_of directory_group | ( AZURE_ROLE=value ) | ( IAM_GROUP_NAME=value ) }'       
         }
   ] [ CONTAINER = { CURRENT | ALL } ] ;

supplemental_logging_props

SUPPLEMENTAL LOG { supplemental_log_grp_clause
                 | supplemental_id_key_clause
                 }

call

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

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

file_name_convert

FILE_NAME_CONVERT =
  { ( 'filename_pattern', 'replacement_filename_pattern'
      [, 'filename_pattern', 'replacement_filename_pattern' ]... )
    |
    NONE
  }

index_attributes

[ { physical_attributes_clause
  | logging_clause
  | ONLINE
  | TABLESPACE { tablespace | DEFAULT }
  | index_compression
  | { SORT | NOSORT }
  | REVERSE
  | VISIBLE | INVISIBLE
  | partial_index_clause
  | parallel_clause
  }...
]

pdb_refresh_mode_clause

REFRESH MODE { MANUAL | EVERY refresh_interval { MINUTES  | HOURS } | NONE }

routine_clause

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

tablespace_encryption_spec

USING 'encrypt_algorithm'

zonemap_clause

{ WITH MATERIALIZED ZONEMAP [ ( zonemap_name ) ] }
|
{ WITHOUT MATERIALIZED ZONEMAP }

add_filegroup_clause

ADD FILEGROUP filegroup_name
  { DATABASE database_name
  | CLUSTER cluster_name
  | VOLUME asm_volume
  }
[ SET '[ file_type. ] property_name' = 'property_value' ]

alter_indextype

ALTER INDEXTYPE [ schema. ] indextype
  { { ADD | DROP } [ schema. ] operator ( parameter_types ) 
      [ , { ADD | DROP } [schema. ] operator ( parameter_types ) ]... [ using_type_clause ]
  | COMPILE
  }
  [ WITH LOCAL [ RANGE ] PARTITION ] [ storage_table_clause ]
  ;

blockchain_drop_table_clause

 NO DROP [ UNTIL integer DAYS IDLE ]

drop_synonym

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

identity_options

{ START WITH ( integer | LIMIT VALUE )
| INCREMENT BY integer
| ( MAXVALUE integer | NOMAXVALUE )
| ( MINVALUE integer | NOMINVALUE )
| ( CYCLE | NOCYCLE )
| ( CACHE integer | NOCACHE )
| ( ORDER | NOORDER ) }...

is_of_type_condition

expr IS [ NOT ] OF [ TYPE ]
   ([ ONLY ] [ schema. ] type
      [, [ ONLY ] [ schema. ] type ]...
   )

list_partition_desc

PARTITION [partition]
list_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
  ]

reference_model

REFERENCE reference_model_name ON (subquery)
  model_column_clauses [ cell_reference_options ]

split_nested_table_part

NESTED TABLE column INTO
  ( nested_table_partition_spec, nested_table_partition_spec
    [split_nested_table_part]
  ) [split_nested_table_part]

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

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
}

create_analytic_view

CREATE [ OR REPLACE ] [ { FORCE | NOFORCE } ] 
   ANALYTIC VIEW [ schema. ] analytic_view 
    [ SHARING "=" ( METADATA | NONE ) ] 
    [ classification_clause ]...
    using_clause 
    dim_by_clause 
    measures_clause 
    [ default_measure_clause ] 
    [ default_aggregate_clause ]
    [ cache_clause ]
;

cycle_clause

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

drop_operator

DROP OPERATOR [ schema. ] operator [ FORCE ] ;

drop_type

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

extent_management_clause

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

grant

GRANT
  { { { grant_system_privileges | grant_object_privileges }
      [ CONTAINER = { CURRENT | ALL } ] }
  | grant_roles_to_programs
  } ;

inmemory_memcompress

MEMCOMPRESS FOR { DML | QUERY [ LOW | HIGH ] | CAPACITY [ LOW | HIGH ] }
| NO MEMCOMPRESS

instance_clauses

{ ENABLE | DISABLE } INSTANCE 'instance_name'

key_management_clauses

{ set_key
| create_key
| use_key
| set_key_tag
| export_keys
| import_keys
| migrate_key
| reverse_migrate_key
| move_keys
}

stop_standby_clause

{ STOP | ABORT } LOGICAL STANDBY APPLY

all_clause

ALL  MEMBER { NAME expression [ MEMBER CAPTION expression ]
            | CAPTION expression [ MEMBER DESCRIPTION expression ]
            | DESCRIPTION expression 
            }

consistent_hash_partitions

PARTITION BY CONSISTENT HASH (column [, column ]...)
  [ PARTITIONS AUTO ] TABLESPACE SET tablespace_set

drop_filegroup_clause

DROP FILEGROUP filegroup_name [ CASCADE ]

hint

{ /*+ hint [ string ] [ hint [ string ] ]... */
| --+ hint [ string ] [ hint [ string ] ]...
}

prepare_clause

   PREPARE MIRROR COPY copy_name 
   WITH { UNPROTECTED | MIRROR | HIGH } REDUNDANCY   

query_rewrite_clause

{ ENABLE | DISABLE } QUERY REWRITE [ unusable_editions_clause ]

set_time_zone_clause

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

tablespace_logging_clauses

{ logging_clause
| [ NO ] FORCE LOGGING
}

tablespace_state_clauses

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

LOB_storage_parameters

{ { { TABLESPACE tablespace | TABLESPACE SET tablespace_set }
  | LOB_parameters [storage_clause]
  }...
| storage_clause

create_library

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
LIBRARY plsql_library_source

create_package_body

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
PACKAGE BODY plsql_package_body_source

invoker_rights_clause

AUTHID { CURRENT_USER | DEFINER }

logfile_clause

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

logfile_descriptor

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

modify_filegroup_clause

MODIFY FILEGROUP filegroup_name
  SET '[ file_type. ] property_name' = 'property_value'

outer_join_clause

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

range_values_clause

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

replace_disk_clause

REPLACE DISK disk_name WITH 'path_name' [ FORCE | NOFORCE ]
  [, disk_name WITH 'path_name' [ FORCE | NOFORCE ] ]...
[ POWER integer ] [ WAIT | NOWAIT ]

resize_disk_clause

RESIZE ALL [ SIZE size_clause ]

XMLType_storage

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

attr_dim_using_clause

USING [ schema. ] dim_source [ [ AS ] alias]

audit

AUDIT
  { audit_operation_clause [ auditing_by_clause | IN SESSION CURRENT ]
  | audit_schema_object_clause
  | NETWORK
  | DIRECT_PATH LOAD [ auditing_by_clause ]
  } [ BY { SESSION | ACCESS } ]
    [ WHENEVER [ NOT ] SUCCESSFUL ]
    [ CONTAINER = { CURRENT | ALL } ]
;

create_package

CREATE [ OR REPLACE ]
[ EDITIONABLE | NONEDITIONABLE ]
PACKAGE plsql_package_source

deferred_segment_creation

SEGMENT CREATION { IMMEDIATE | DEFERRED }

drop_mirror_copy

  DROP MIRROR COPY mirror_name

logging_clause

{ LOGGING | NOLOGGING |  FILESYSTEM_LIKE_LOGGING }

measures_clause

MEASURES  ( av_measure [, av_measure]... )

object_view_clause

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

on_object_clause

ON { [ schema. ] object 
   | USER user [, user]...
   | DIRECTORY directory_name
   | EDITION edition_name
   | MINING MODEL [ schema. ] mining_model_name
   | JAVA { SOURCE | RESOURCE } [ schema. ] object
   | SQL TRANSLATION PROFILE [ schema. ] profile
   }

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

dim_key

dim_ref 
  [classification_clause]...
  KEY  
    {[(] [alias.] fact_column  [)] 
     |
     (  [alias.] fact_column [, [alias.] fact_column]... )
    }
  REFERENCES 
     { [DISTINCT]
       [(]  attribute  [)] 
       | 
       ( attribute [, attribute]... )
     }   
  HIERARCHIES ( hier_ref [, hier_ref]... )

diskgroup_availability

{ MOUNT [ RESTRICTED | NORMAL ] 
           [ FORCE | NOFORCE ]
| DISMOUNT [ FORCE | NOFORCE ]
}

row_pattern_subset_item

variable_name = ( variable_name [, variable_name ] )

split_index_partition

SPLIT PARTITION partition_name_old
   AT (literal [, literal ]...)
   [ INTO (index_partition_description,
           index_partition_description
          )
   ]
   [ parallel_clause ]

temporary_tablespace_clause

{ { TEMPORARY TABLESPACE }
| { LOCAL TEMPORARY TABLESPACE FOR { ALL | LEAF } }
} tablespace
[ TEMPFILE file_specification [, file_specification ]... ]
[ tablespace_group_clause ]
[ extent_management_clause ]

update_global_index_clause

{ UPDATE | INVALIDATE } GLOBAL INDEXES