| Oracle9i SQL Reference Release 2 (9.2) Part Number A96540-02 |
|
|
View PDF |
| Oracle9i SQL Reference Release 2 (9.2) Part Number A96540-02 |
|
|
View PDF |
Use the CREATE TABLE statement to create one of the following types of tables:
You can also create an object type and then use it in a column when creating a relational table.
Tables are created with no data unless a query is specified. You can add rows to a table with the INSERT statement. After creating a table, you can define additional columns, partitions, and integrity constraints with the ADD clause of the ALTER TABLE statement. You can change the definition of an existing column or partition with the MODIFY clause of the ALTER TABLE statement.
See Also:
|
To create a relational table in your own schema, you must have the CREATE TABLE system privilege. To create a table in another user's schema, you must have CREATE ANY TABLE system privilege. Also, the owner of the schema to contain the table must have either space quota on the tablespace to contain the table or UNLIMITED TABLESPACE system privilege.
In addition to these table privileges, to create an object table (or a relational table with an object type column), the owner of the table must have the EXECUTE object privilege in order to access all types referenced by the table, or you must have the EXECUTE ANY TYPE system privilege. These privileges must be granted explicitly and not acquired through a role.
Additionally, if the table owner intends to grant access to the table to other users, then the owner must have been granted the EXECUTE privileges on the referenced types with the GRANT OPTION, or have the EXECUTE ANY TYPE system privilege with the ADMIN OPTION. Without these privileges, the table owner has insufficient privileges to grant access to the table to other users.
To enable a unique or primary key constraint, you must have the privileges necessary to create an index on the table. You need these privileges because Oracle creates an index on the columns of the unique or primary key in the schema containing the table.
To create an external table, you must have the READ object privilege on the directory in which the external data resides.
See Also:
|
create_table::=
relational_table::=
object_table::=
object_table_substitution::=, object_properties::=, OID_clause::=, OID_index_clause::=, physical_properties::=, table_properties::=)
OID_clause::=
segment_attributes_clause::=, data_segment_compression::=, index_org_table_clause::=, external_table_clause::=)
object_type_col_properties::=, nested_table_col_properties::=, varray_col_properties::=, LOB_storage_clause::=, LOB_partition_storage::=, XMLType_column_properties::=)
substitutable_column_clause::=
nested_table_col_properties::=
substitutable_column_clause::=, object_properties::=, physical_properties::=, column_properties::=)
logging_clause::=
LOB_partition_storage::=
XMLType_storage::=
XMLSchema_spec::=
external_data_properties::=
opaque_format_spec: See Oracle9i Database Utilities for information on how to specify values for the opaque_format_spec.)
subpartition_by_list::=, subpartition_by_hash::=, range_values_clause::=, table_partition_description::=)
individual_hash_partitions::=
hash_partitions_by_quantity::=
subpartition_by_list::=
range_values_clause::=
list_values_clause::=
table_partition_description::=
segment_attributes_clause::=, data_segment_compression::=, LOB_storage_clause::=, varray_col_properties::=, partition_level_subpartition::=)partition_level_subpartition::=
subpartition_spec::=
partitioning_storage_clause::=
using_index_clause::=, exceptions_clause not supported in CREATE TABLE statements)
global_partitioned_index::=
index_partitioning_clause::=
Specify GLOBAL TEMPORARY to indicate that the table is temporary and that its definition is visible to all sessions. The data in a temporary table is visible only to the session that inserts the data into the table.
A temporary table has a definition that persists the same as the definitions of regular tables, but it contains either session-specific or transaction-specific data. You specify whether the data is session- or transaction-specific with the ON COMMIT keywords.
| See Also:
Oracle9i Database Concepts for information on temporary tables and "Temporary Table Example" |
LOB_storage_clause: TABLESPACE, storage_clause, logging_clause, MONITORING or NOMONITORING, or LOB_index_clause.parallel_clause returns an error.)segment_attributes_clause, nested_table_col_properties, or parallel_clause.Specify the schema to contain the table. If you omit schema, then Oracle creates the table in your own schema.
Specify the name of the table (or object table) to be created.
The relational properties describe the components of a relational table.
Specify the name of a column of the table.
If you also specify AS subquery, then you can omit column and datatype unless you are creating an index-organized table. If you specify AS subquery when creating an index-organized table, then you must specify column, and you must omit datatype.
The absolute maximum number of columns in a table is 1000. However, when you create an object table (or a relational table with columns of object, nested table, varray, or REF type), Oracle maps the columns of the user-defined types to relational columns, creating in effect "hidden columns" that count toward the 1000-column limit.
Specify the datatype of a column.
You can specify a column of type ROWID, but Oracle does not guarantee that the values in such columns are valid rowids.
| See Also:
"Datatypes" for information on Oracle-supplied datatypes |
The DEFAULT clause lets you specify a value to be assigned to the column if a subsequent INSERT statement omits a value for the column. The datatype of the expression must match the datatype of the column. The column must also be long enough to hold this expression.
The DEFAULT expression can include any SQL function as long as the function does not return a literal argument, a column reference, or a nested function invocation.
A DEFAULT expression cannot contain references to PL/SQL functions or to other columns, the pseudocolumns LEVEL, PRIOR, and ROWNUM, or date constants that are not fully specified.
| See Also:
"About SQL Expressions" for the syntax of |
These clauses let you describe a column of type REF. The only difference between these clauses is that you specify out_of_line_ref_constraint from the table level, so you must identify the REF column or attribute you are defining. You specify inline_ref_constraint after you have already identified the REF column or attribute.
| See Also:
|
Use the inline_constraint to define an integrity constraint as part of the column definition.
You can create UNIQUE, PRIMARY KEY, and REFERENCES constraints on scalar attributes of object type columns. You can also create NOT NULL constraints on object type columns, and CHECK constraints that reference object type columns or any attribute of an object type column.
| See Also:
|
Use the out_of_line_constraint syntax to define an integrity constraint as part of the table definition.
|
Note: You must specify a |
| See Also:
the syntax description of |
The supplemental_logging_props clause lets you instruct Oracle to put additional data into the log stream to support log-based tools.
The ON COMMIT clause is relevant only if you are creating a temporary table. This clause specifies whether the data in the temporary table persists for the duration of a transaction or a session.
Specify DELETE ROWS for a transaction-specific temporary table (this is the default). Oracle will truncate the table (delete all its rows) after each commit.
Specify PRESERVE ROWS for a session-specific temporary table. Oracle will truncate the table (delete all its rows) when you terminate the session.
The physical properties relate to the treatment of extents and segments and to the storage characteristics of the table.
The physical_attributes_clause lets you specify the value of the PCTFREE, PCTUSED, INITRANS, and MAXTRANS parameters and the storage characteristics of the table.
CREATE statement (and in subsequent ALTER TABLE ... ADD PARTITION statements), unless you explicitly override that value in the PARTITION clause of the statement that creates the partition.If you omit this clause, then Oracle uses the following default values:
PCTFREE: 10PCTUSED: 40INITRANS: 1MAXTRANS: Depends on data block size
See Also:
|
Specify the tablespace in which Oracle creates the table, object table OID index, partition, LOB data segment, LOB index segment, or index-organized table overflow data segment. If you omit TABLESPACE, then Oracle creates that item in the default tablespace of the owner of the schema containing the table.
For heap-organized tables with one or more LOB columns, if you omit the TABLESPACE clause for LOB storage, then Oracle creates the LOB data and index segments in the tablespace where the table is created.
However, for an index-organized table with one or more LOB columns, if you omit TABLESPACE, then the LOB data and index segments are created in the tablespace in which the primary key index segment of the index-organized table is created.
For nonpartitioned tables, the value specified for TABLESPACE is the actual physical attribute of the segment associated with the table. For partitioned tables, the value specified for TABLESPACE is the default physical attribute of the segments associated with all partitions specified in the CREATE statement (and on subsequent ALTER TABLE ... ADD PARTITION statements), unless you specify TABLESPACE in the PARTITION description.
| See Also:
CREATE TABLESPACE for more information on tablespaces |
Specify whether the creation of the table (and any indexes required because of constraints), partition, or LOB storage characteristics will be logged in the redo log file (LOGGING) or not (NOLOGGING).The logging attribute of the table is independent of that of its indexes.
This attribute also specifies whether subsequent Direct Loader (SQL*Loader) and direct-path INSERT operations against the table, partition, or LOB storage are logged (LOGGING) or not logged (NOLOGGING).
| See Also:
|
The data_segment_compression clause is valid only for heap-organized tables. Use this clause to instruct Oracle whether to compress data segments to reduce disk use. The COMPRESS keyword enables data segment compression. The NOCOMPRESS keyword disables data segment compression. NOCOMPRESS is the default.
When you enable data segment compression, Oracle attempts to compress data when it is productive to do so. LOB data segments are not compressed. This clause is especially useful in environments such as data warehouses, where the amount of insert and update operations is small. You can specify data segment compression for the following portions of a heap-organized table:
physical_properties clause of relational_table or object_table)table_partition_description of the range_partitioning clause)table_partition_description of the list_partitioning clause)nested_table_col_properties clause)
| See Also:
Oracle9i Database Performance Tuning Guide and Reference for information on calculating the compression ratio and to Oracle9i Data Warehousing Guide for information on data compression usage scenarios |
These keywords are deprecated and have been replaced with LOGGING and NOLOGGING, respectively. Although RECOVERABLE and UNRECOVERABLE are supported for backward compatibility, Oracle Corporation strongly recommends that you use the LOGGING and NOLOGGING keywords.
RECOVERABLE for partitioned tables or LOB storage characteristics.UNRECOVERABLE for a partitioned or index-organized tables.UNRECOVERABLE only with AS subquery.The ORGANIZATION clause lets you specify the order in which the data rows of the table are stored.
HEAP indicates that the data rows of table are stored in no particular order. This is the default.
INDEX indicates that table is created as an index-organized table. In an index-organized table, the data rows are held in an index defined on the primary key for the table.
EXTERNAL indicates that table is a read-only table located outside the database.
Use the index_org_table_clause to create an index-organized table. Oracle maintains the table rows (both primary key column values and nonkey column values) in an index built on the primary key. Index-organized tables are therefore best suited for primary key-based access and manipulation. An index-organized table is an alternative to:
CREATE INDEX statementCREATE CLUSTER statement that maps the primary key for the table to the cluster keyYou must specify a primary key for an index-organized table, because the primary key uniquely identifies a row. The primary key cannot be DEFERRABLE. Use the primary key instead of the rowid for directly accessing index-organized rows.
If an index-organized table is partitioned and contains LOB columns, then you should specify the index_org_table_clause first, then the LOB_storage_clause, and then the appropriate table_partitioning_clauses.
ROWID for an index-organized table.composite_partitioning_clause for an index-organized table.
Specify the percentage of space reserved in the index block for an index-organized table row. PCTTHRESHOLD must be large enough to hold the primary key. All trailing columns of a row, starting with the column that causes the specified threshold to be exceeded, are stored in the overflow segment. PCTTHRESHOLD must be a value from 1 to 50. If you do not specify PCTTHRESHOLD, the default is 50.
You cannot specify PCTTHRESHOLD for individual partitions of an index-organized table.
Specify MAPPING TABLE to instruct Oracle to create a mapping of local to physical ROWIDs and store them in a heap-organized table. This mapping is needed in order to create a bitmap index on the index-organized table.
Oracle creates the mapping table in the same tablespace as its parent index-organized table. You cannot query, perform DML operations on, or modify the storage characteristics of the mapping table.
You cannot specify the mapping_table_clause for a partitioned index-organized table.
The key_compression clauses let you enable or disable key compression for index-organized tables.
COMPRESS to enable key compression, which eliminates repeated occurrence of primary key column values in index-organized tables. Use integer to specify the prefix length (number of prefix columns to compress).
The valid range of prefix length values is from 1 to the number of primary key columns minus 1. The default prefix length is the number of primary key columns minus 1.
NOCOMPRESS to disable key compression in index-organized tables. This is the default.At the partition level, you can specify COMPRESS, but you cannot specify the prefix length with integer.
The index_org_overflow_clause lets you instruct Oracle that index-organized table data rows exceeding the specified threshold are placed in the data segment specified in this clause.
OVERFLOW, then Oracle raises an error and does not execute the CREATE TABLE statement. This checking function guarantees that subsequent DML operations on the index-organized table will not fail because an overflow segment is lacking.OVERFLOW keyword apply only to the overflow segment of the table. Physical attributes and storage characteristics for the index-organized table itself, default values for all its partitions, and values for individual partitions must be specified before this keyword.OVERFLOW, even if they would otherwise be small enough be to stored inline.Specify a column at which to divide an index-organized table row into index and overflow portions. The primary key columns are always stored in the index. column_name can be either the last primary-key column or any non-primary-key column. All non-primary-key columns that follow column_name are stored in the overflow data segment.
You cannot specify this clause for individual partitions of an index-organized table.
Use the external_table_clause to create an external table, which is a read-only table whose metadata is stored in the database but whose data in stored outside database. External tables let you query data without first loading it into the database, among other capabilities.
| See Also:
Oracle9i Data Warehousing Guide, Oracle9i Database Administrator's Guide, and Oracle9i Database Utilities for information on the uses for external tables |
Because external tables have no data in the database, you define them with a small subset of the clauses normally available when creating tables.
relational_properties clause, you can specify only column, datatype, and inline_constraint.physical_properties_clause, you can specify only the organization of the table (ORGANIZATION EXTERNAL external_table_clause).table_properties clause, you can specify only the parallel_clause. The parallel_clause lets you parallelize subsequent queries on the external data.
CREATE TABLE statement if you specify the external_table_clause.LONG columns.TYPE access_driver_type indicates the access driver of the external table. The access driver is the API that interprets the external data for the database. If you do not specify TYPE, then Oracle uses the default access driver, ORACLE_LOADER.
| See Also:
Oracle9i Database Utilities for information about the |
DEFAULT DIRECTORY lets you specify a default directory object corresponding to a directory on the file system where the external data sources may reside. The default directory can also be used by the access driver to store auxiliary files such as error logs.
The optional ACCESS PARAMETERS clause lets you assign values to the parameters of the specific access driver for this external table:
opaque_format_spec lets you list the parameters and their values. Please refer to Oracle9i Database Utilities for information on how to specify values for the opaque_format_spec.
Field names specified in the opaque_format_spec must match columns in the table definition. Oracle ignores any field in the opaque_format_spec that is not matched by a column in the table definition.
USING CLOB subquery lets you derive the parameters and their values through a subquery. The subquery cannot contain any set operators or an ORDER BY clause. It must return one row containing a single item of datatype CLOB.Whether you specify the parameters in an opaque_format_spec or derive them using a subquery, Oracle does not interpret anything in this clause. It is up to the access driver to interpret this information in the context of the external data.
The LOCATION clause lets you specify one or more external data sources. Usually the location_specifier is a file, but it need not be. Oracle does not interpret this clause. It is up to the access driver to interpret this information in the context of the external data.
The REJECT LIMIT clause lets you specify how many conversion errors can occur during a query of the external data before an Oracle error is returned and the query is aborted. The default value is 0.
The CLUSTER clause indicates that the table is to be part of cluster. The columns listed in this clause are the table columns that correspond to the cluster's columns. Generally, the cluster columns of a table are the column or columns that make up its primary key or a portion of its primary key.
Specify one column from the table for each column in the cluster key. The columns are matched by position, not by name.
A clustered table uses the cluster's space allocation. Therefore, do not use the PCTFREE, PCTUSED, INITRANS, or MAXTRANS parameters, the TABLESPACE clause, or the storage_clause with the CLUSTER clause.
CLUSTER with either ROWDEPENDENCIES or NOROWDEPENDENCIES unless the cluster has been created with the same ROWDEPENDENCIES or NOROWDEPENDENCIES setting.Use the column_properties clauses to specify the storage attributes of a column.
The object_type_col_properties determine storage characteristics of an object column or attribute or an element of a collection column or attribute.
For column, specify an object column or attribute.
The substitutable_column_clause indicates whether object columns or attributes in the same hierarchy are substitutable for each other. You can specify that a column is of a particular type, or whether it can contain instances of its subtypes, or both.
ELEMENT, you constrain the element type of a collection column or attribute to a subtype of its declared type.IS OF [TYPE] (ONLY type) clause constrains the type of the object column to a subtype of its declared type.NOT SUBSTITUTABLE AT ALL LEVELS indicates that the object column cannot hold instances corresponding to any of its subtypes. Also, substitution is disabled for any embedded object attributes and elements of embedded nested tables and varrays. The default is SUBSTITUTABLE AT ALL LEVELS.[NOT] SUBSTITUTABLE AT ALL LEVELS.The LOB_storage_clause lets you specify the storage attributes of LOB data segments.
For a nonpartitioned table (that is, when specified in the physical_properties clause without any of the partitioning clauses), this clause specifies the table's storage attributes of LOB data segments.
For a partitioned table, Oracle implements this clause depending on where it is specified:
physical_properties clause along with one of the partitioning clauses), this clause specifies the default storage attributes for LOB data segments associated with each partition or subpartition. These storage attributes apply to all partitions or subpartitions unless overridden by a LOB_storage_clause at the partition or subpartition level.table_partition_description), this clause specifies the storage attributes of the data segments of the partition or the default storage attributes of any subpartitions of the partition. A partition-level LOB_storage_clause overrides a table-level LOB_storage_clause.subpartition_by_hash or subpartition_by_list), this clause specifies the storage attributes of the data segments of the subpartition. A subpartition-level LOB_storage_clause overrides both partition-level and table-level LOB_storage_clauses.You cannot specify the LOB_index_clause if table is partitioned.
Specify the LOB column name or LOB object attribute for which you are explicitly defining tablespace and storage characteristics that are different from those of the table. Oracle automatically creates a system-managed index for each LOB_item you create.
Specify the name of the LOB data segment. You cannot use LOB_segname if you specify more than one LOB_item.
The LOB_parameters clause lets you specify various elements of LOB storage.
If you enable storage in row, then the LOB value is stored in the row (inline) if its length is less than approximately 4000 bytes minus system control information. This is the default.
For an index-organized table, you cannot specify this parameter unless you have specified an OVERFLOW segment in the index_org_table_clause.
If you disable storage in row, then the LOB value is stored out of line (outside of the row) regardless of the length of the LOB value.
|
Note: The LOB locator is always stored inline (inside the row) regardless of where the LOB value is stored. You cannot change the value of |
Specify the number of bytes to be allocated for LOB manipulation. If integer is not a multiple of the database block size, then Oracle rounds up (in bytes) to the next multiple. For example, if the database block size is 2048 and integer is 2050, then Oracle allocates 4096 bytes (2 blocks). The maximum value is 32768 (32K), which is the largest Oracle block size allowed. The default CHUNK size is one Oracle database block.
Specify the maximum percentage of overall LOB storage space used for maintaining old versions of the LOB. The default value is 10, meaning that older versions of the LOB data are not overwritten until they consume 10% of the overall LOB storage space.
You can specify the PCTVERSION parameter whether the database is running in manual or automatic undo mode. PCTVERSION is the default in manual undo mode. RETENTION is the default in automatic undo mode.
You cannot specify both PCTVERSION and RETENTION.
Use this clause to indicate that Oracle should retain old versions of this LOB column. Oracle uses the value of the UNDO_RETENTION initialization parameter to determine the amount (in time) of committed undo data to retain in the database.
You can specify the RETENTION parameter only if the database is running in automatic undo mode. In this mode, RETENTION is the default value unless you specify PCTVERSION.
You cannot specify both PCTVERSION and RETENTION.
Specify the number of groups of free lists for the LOB segment. Normally integer will be the number of instances in a Real Application Clusters environment or 1 for a single-instance database.
You can specify this parameter only if the database is running in automatic undo mode. In this mode, FREEPOOLS is the default unless you specify the FREELIST GROUPS parameter of the storage_clause. If you specify neither FREEPOOLS nor FREELIST GROUPS, then Oracle uses a default of FREEPOOLS 1 if the database is in automatic undo management mode and a default of FREELIST GROUPS 1 if the database is in manual undo management mode.
You cannot specify both FREEPOOLS and the FREELIST GROUPS parameter of the storage_clause.
This clause has been deprecated. If you specify this clause, then Oracle ignores it. Oracle automatically generates an index for each LOB column and names and manages the LOB indexes internally.
See Also:
|
The varray_col_properties let you specify separate storage characteristics for the LOB in which a varray will be stored. If varray_item is a multilevel collection, then Oracle stores all collection items nested within varray_item in the same LOB in which varray_item is stored.
physical_properties clause without any of the partitioning clauses), this clause specifies the storage attributes of the LOB data segments of the varray.physical_properties clause along with one of the partitioning clauses), this clause specifies the default storage attributes for the varray's LOB data segments associated with each partition (or its subpartitions, if any).table_partition_description), this clause specifies the storage attributes of the varray's LOB data segments of that partition or the default storage attributes of the varray's LOB data segments of any subpartitions of this partition. A partition-level varray_col_properties overrides a table-level varray_col_properties.subpartition_by_hash or subpartition_by_list), this clause specifies the storage attributes of the varray's data segments of this subpartition. A subpartition-level varray_col_properties overrides both partition-level and table-level varray_col_properties.If you specify STORE AS LOB,
If you do not specify STORE AS LOB, then Oracle handles varray storage differently from other LOBs. Storage is based on the maximum possible size of the varray (that is the number of elements times the element size, plus a small amount for system control information) rather than on the actual size of a varray column.
You cannot specify the TABLESPACE parameter of LOB_parameters as part of this clause. The LOB tablespace for a varray defaults to the containing table's tablespace.
The substitutable_column_clause has the same behavior as described for object_type_col_properties.
The nested_table_col_properties let you specify separate storage characteristics for a nested table, which in turn enables you to define the nested table as an index-organized table. The storage table is created in the same tablespace as its parent table (using the default storage characteristics) and stores the nested table values of the column for which it was created.
You must include this clause when creating a table with columns or column attributes whose type is a nested table. Clauses within nested_table_col_properties that function the same way they function for parent object tables are not repeated here.
Specify the name of a column (or a top-level attribute of the table's object type) whose type is a nested table.
If the nested table is a multilevel collection, then the inner nested table or varray may not have a name. In this case, specify COLUMN_VALUE in place of the nested_item name.
| See Also:
"Multi-level Collection Example" for examples using |
Specify the name of the table where the rows of nested_item reside. For a nonpartitioned table, the storage table is created in the same schema and the same tablespace as the parent table. For a partitioned table, the storage table is created in the default tablespace of the schema.
storage_table directly, but you can modify its storage characteristics by specifying its name in an ALTER TABLE statement.
| See Also:
ALTER TABLE for information about modifying nested table column storage characteristics |
Specify what Oracle returns as the result of a query.
VALUE returns a copy of the nested table itself.LOCATOR returns a collection locator to the copy of the nested table.
If you do not specify the segment_attributes_clause or the LOB_storage_clause, then the nested table is heap organized and is created with default storage characteristics.
OID_clause.TABLESPACE (as part of the segment_attributes_clause) for a nested table. The tablespace is always that of the parent table.object_properties) an out_of_line_ref_constraint, inline_ref_constraint, or foreign key constraint for the attributes of a nested table. However, you can modify a nested table to add such constraints using ALTER TABLE.ALTER TABLE statement.
See Also:
|
The XMLType_column_properties let you specify storage attributes for an XMLTYPE column.
XMLType columns can be stored either in LOB or object-relational columns.
STORE AS OBJECT RELATIONAL if you want Oracle to store the XMLType data in object-relational columns. Storing data object relationally lets you define indexes on the relational columns and enhances query performance.
If you specify object-relational storage, you must also specify the XMLSchema_spec clause.
STORE AS CLOB if you want Oracle to store the XMLType data in a CLOB column. Storing data in a CLOB column preserves the original content and enhances retrieval time.
If you specify LOB storage, you can specify either LOB parameters or the XMLSchema_spec clause, but not both. Specify the XMLSchema_spec clause if you want to restrict the table or column to particular schema-based XML instances.
This clause lets you specify the URL of a registered XMLSchema (in the XMLSCHEMA clause or as part of the ELEMENT clause) and an XML element name. You must specify an element, although the XMLSchema URL is optional. If you do specify an XMLSchema URL, you must already have registered the XMLSchema using the DBMS_XMLSCHEMA package.
See Also:
|
Use the table_partitioning_clauses to create a partitioned table.
LONG or LONG RAW columns.
|
Note: The storage of partitioned database entities in tablespaces of different block sizes is subject to several restrictions. Please refer to Oracle9i Database Administrator's Guide for a discussion of these restrictions. |
Use the range_partitioning clause to partition the table on ranges of values from the column list. For an index-organized table, the column list must be a subset of the primary key columns of the table.
Specify an ordered list of columns used to determine into which partition a row belongs (the partitioning key).
The columns in the column list can be of any built-in datatype except ROWID, LONG, LOB, or TIMESTAMP WITH TIME ZONE.
The name partition must conform to the rules for naming schema objects and their part as described in "Schema Object Naming Rules". If you omit partition, then Oracle generates a name with the form SYS_Pn.