| Oracle® Database SQL Language Reference 11g Release 2 (11.2) E41084-02 |
|
|
PDF · Mobi · ePub |
| Oracle® Database SQL Language Reference 11g Release 2 (11.2) E41084-02 |
|
|
PDF · Mobi · ePub |
Use the ALTER TABLE statement to alter the definition of a nonpartitioned table, a partitioned table, a table partition, or a table subpartition. For object tables or relational tables with object columns, use ALTER TABLE to convert the table to the latest definition of its referenced type after the type has been altered.
Note:
Oracle recommends that you use the
ALTER MATERIALIZED VIEW LOG statement, rather than ALTER TABLE, whenever possible for operations on materialized view log tables.See Also:
CREATE TABLE for information on creating tables
Oracle Text Reference for information on ALTER TABLE statements in conjunction with Oracle Text
The table must be in your own schema, or you must have ALTER object privilege on the table, or you must have ALTER ANY TABLE system privilege.
Additional Prerequisites for Partitioning Operations If you are not the owner of the table, then you need the DROP ANY TABLE privilege in order to use the drop_table_partition or truncate_table_partition clause.
You must also have space quota in the tablespace in which space is to be acquired in order to use the add_table_partition, modify_table_partition, move_table_partition, and split_table_partition clauses.
When a partitioning operation cascades to reference-partitioned child tables, privileges are not required on the reference-partitioned child tables.
Additional Prerequisites for Constraints and Triggers 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 Database creates an index on the columns of the unique or primary key in the schema containing the table.
To enable or disable triggers, the triggers must be in your schema or you must have the ALTER ANY TRIGGER system privilege.
See Also:
CREATE INDEX for information on the privileges needed to create indexesAdditional Prerequisites When Using Object Types To use an object type in a column definition when modifying a table, either that object must belong to the same schema as the table being altered, or you must have either the EXECUTE ANY TYPE system privilege or the EXECUTE object privilege for the object type.
Additional Prerequisites for Flashback Data Archive Operations To use the flashback_archive_clause to enable historical tracking for the table, you must have the FLASHBACK ARCHIVE object privilege on the flashback data archive that will contain the historical data. To use the flashback_archive_clause to disable historical tracking for the table, you must have the FLASHBACK ARCHIVE ADMINSTER system privilege or you must be logged in as SYSDBA.
Note:
You must specify some clause aftertable. None of the clauses after table are required, but you must specify at least one of them.Groups of ALTER TABLE syntax:
After each clause you will find links to its component subclauses.
(physical_attributes_clause::=, logging_clause::=, table_compression ::=, supplemental_table_logging ::=, allocate_extent_clause ::=, deallocate_unused_clause::= , upgrade_table_clause ::=, records_per_block_clause ::=, parallel_clause::=, row_movement_clause::=, flashback_archive_clause::=, shrink_clause::=, alter_iot_clauses::=, alter_XMLSchema_clause::=)
supplemental_table_logging ::=
supplemental_log_grp_clause::=
(alter_overflow_clause ::=, alter_mapping_table_clauses ::=)
(segment_attributes_clause::=)
(physical_attributes_clause::=, logging_clause::=)
(segment_attributes_clause::=, allocate_extent_clause ::=, shrink_clause::=, deallocate_unused_clause::=)
(segment_attributes_clause::=)
alter_mapping_table_clauses ::=
(allocate_extent_clause ::=, deallocate_unused_clause::=)
(add_column_clause ::=, modify_column_clauses::=, drop_column_clause ::=, rename_column_clause ::=, modify_collection_retrieval ::=, modify_LOB_storage_clause::=, alter_varray_col_properties::=, encryption_spec::=)
(column_definition::=, column_properties::=)
(encryption_spec::=, inline_constraint and inline_ref_constraint: constraint::=)
(encryption_spec::=, inline_constraint: constraint::=, LOB_storage_clause::=)
modify_collection_retrieval ::=
(out_of_line_constraint::=, out_of_line_ref_constraint::=, constraint_state::=)
substitutable_column_clause::=
nested_table_col_properties::=
(inline_constraint, inline_ref_constraint, out_of_line_constraint, out_of_line_ref_constraint: constraint::=)
(supplemental_log_grp_clause::=, supplemental_id_key_clause::=)
(deferred_segment_creation::=, segment_attributes_clause::=, index_org_table_clause ::=, external_data_properties::=)
(substitutable_column_clause::=, varray_storage_clause::=)
(LOB_parameters::=, storage_clause::=)
(LOB_retention_clause::=, LOB_deduplicate_clause::=, LOB_compression_clause::=, encryption_spec::=, logging_clause::=)
(storage_clause::=, LOB_retention_clause::=, LOB_compression_clause::=, encryption_spec::=, logging_clause::=, allocate_extent_clause ::=, shrink_clause::=, deallocate_unused_clause::=)
alter_varray_col_properties::=
(LOB_storage_clause::=, varray_col_properties::=, LOB_partitioning_storage::=)
(add_column_clause ::=, modify_column_clauses::=, drop_column_clause ::=, drop_constraint_clause::=, parallel_clause::=)
(modify_table_default_attrs ::=, alter_interval_partitioning::=, set_subpartition_template ::=, modify_table_partition::=, modify_table_subpartition::=, move_table_partition::=, move_table_subpartition::=, add_table_partition::=, coalesce_table_partition::=, coalesce_table_subpartition::=, drop_table_partition::=, drop_table_subpartition ::=, rename_partition_subpart::=, truncate_partition_subpart::=, split_table_partition::=, split_table_subpartition ::=, merge_table_partitions ::=, merge_table_subpartitions ::=, exchange_partition_subpart ::=
modify_table_default_attrs ::=
(partition_extended_name::=, deferred_segment_creation::=, segment_attributes_clause::=, table_compression ::=, key_compression::=, alter_overflow_clause ::=, LOB_parameters::=)
alter_interval_partitioning::=
(range_subpartition_desc::=, list_subpartition_desc::=)
(modify_range_partition::=, modify_hash_partition::=, modify_list_partition::=)
(partition_extended_name::=, partition_attributes::=, add_range_subpartition ::=, add_hash_subpartition ::=, add_list_subpartition::=, update_index_clauses::=, parallel_clause::=, alter_mapping_table_clauses ::=)
(partition_extended_name::=, partition_attributes::=, alter_mapping_table_clauses ::=)
(partition_extended_name::=, partition_attributes::=, add_range_subpartition ::=, add_list_subpartition::=, add_hash_subpartition ::=)
(subpartition_extended_name::=, allocate_extent_clause ::=, deallocate_unused_clause::=, shrink_clause::=, modify_LOB_parameters::=)
(partition_extended_name::=, table_partition_description::=, update_index_clauses::=, parallel_clause::=)
(range_subpartition_desc::=, list_subpartition_desc::=, individual_hash_subparts::=, update_index_clauses::=, parallel_clause::=)
(add_range_partition_clause::=, add_hash_partition_clause ::=, add_list_partition_clause ::=, add_system_partition_clause::=, dependent_tables_clause:=
(range_values_clause::=, table_partition_description::=, range_subpartition_desc::=, list_subpartition_desc::=, hash_subparts_by_quantity::=, update_index_clauses::=)
(partitioning_storage_clause::=, update_index_clauses::=, parallel_clause::=)
(list_values_clause::=, table_partition_description::=, range_subpartition_desc::=, list_subpartition_desc::=, hash_subparts_by_quantity::=, update_index_clauses::=)
add_system_partition_clause::=
(table_partition_description::=, update_index_clauses::=)
(range_subpartition_desc::=, update_index_clauses::=, parallel_clause::=)
(hash_subparts_by_quantity::=, update_index_clauses::=, parallel_clause::=)
(list_subpartition_desc::=, update_index_clauses::=)
(update_index_clauses::=, parallel_clause::=)
coalesce_table_subpartition::=
(update_index_clauses::=, parallel_clause::=)
(partition_extended_name::=, update_index_clauses::=, parallel_clause::=)
(subpartition_extended_name::=, update_index_clauses::=, parallel_clause::=)
(partition_extended_name::=, subpartition_extended_name::=)
(partition_extended_name::=, subpartition_extended_name::=, update_index_clauses::=, parallel_clause::=)
(partition_extended_name::=, range_partition_desc::=, list_partition_desc::=, dependent_tables_clause:=, update_index_clauses::=, parallel_clause::=)
nested_table_partition_spec::=
(subpartition_extended_name::=, range_subpartition_desc::=, list_subpartition_desc::=, dependent_tables_clause:=, update_index_clauses::=, parallel_clause::=)
(partition_spec::=, dependent_tables_clause:=, update_index_clauses::=, parallel_clause::=)
(range_subpartition_desc::=, list_subpartition_desc::=, update_index_clauses::=, parallel_clause::=)
exchange_partition_subpart ::=
(partition_extended_name::=, subpartition_extended_name::=, exceptions_clause::=, update_index_clauses::=, parallel_clause::=)
table_partition_description::=
(deferred_segment_creation::=, segment_attributes_clause::=, table_compression ::=, key_compression::=, LOB_storage_clause::=, varray_col_properties::=)
(range_values_clause::=, table_partition_description::=, range_subpartition_desc::=, list_subpartition_desc::=)
(list_values_clause::=, table_partition_description::=, range_subpartition_desc::=, list_subpartition_desc::=)
(range_values_clause::=, partitioning_storage_clause::=)
(list_values_clause::=, partitioning_storage_clause::=)
partitioning_storage_clause::=
table_compression ::=, LOB_partitioning_storage::=
(physical_attributes_clause::=, logging_clause::=, allocate_extent_clause ::=, deallocate_unused_clause::=, shrink_clause::=, table_compression ::=, modify_LOB_parameters::=)
(table_partition_description::=)
(update_global_index_clause ::=, update_all_indexes_clause::=)
update_global_index_clause ::=
(update_index_partition::=, update_index_subpartition::=)
(index_partition_description::=, index_subpartition_clause::=)
index_partition_description::=
(segment_attributes_clause::=, key_compression::=)
parallel_clause ::=
(segment_attributes_clause::=, table_compression ::=, index_org_table_clause ::=, LOB_storage_clause::=, varray_col_properties::=)
(using_index_clause::=, exceptions_clause::=,)
(create_index::=, index_properties::=)
(global_partitioned_index::=, local_partitioned_index ::=—part of CREATE INDEX, index_attributes::=, domain_index_clause: not supported in using_index_clause)
(physical_attributes_clause::=, logging_clause::=, key_compression::=, parallel_clause: not supported in using_index_clause)
Many clauses of the ALTER TABLE statement have the same functionality they have in a CREATE TABLE statement. For more information on such clauses, see CREATE TABLE.
Note:
Operations performed by theALTER TABLE statement can cause Oracle Database to invalidate procedures and stored functions that access the table. For information on how and when the database invalidates such objects, see Oracle Database Advanced Application Developer's Guide.Specify the schema containing the table. If you omit schema, then Oracle Database assumes the table is in your own schema.
Specify the name of the table to be altered.
Note:
If you alter a table that is a master table for one or more materialized views, then Oracle Database marks the materialized viewsINVALID. Invalid materialized views cannot be used by query rewrite and cannot be refreshed. For information on revalidating a materialized view, see ALTER MATERIALIZED VIEW.See Also:
Oracle Database Data Warehousing Guide for more information on materialized views in generalRestrictions on Altering Temporary Tables You can modify, drop columns from, or rename a temporary table. However, for a temporary table you cannot:
Add columns of nested table type. You can add columns of other types.
Specify referential integrity (foreign key) constraints for an added or modified column.
Specify the following clauses of the LOB_storage_clause for an added or modified LOB column: TABLESPACE, storage_clause, logging_clause, allocate_extent_clause, or deallocate_unused_clause.
Specify the physical_attributes_clause, nested_table_col_properties, parallel_clause, allocate_extent_clause, deallocate_unused_clause, or any of the index-organized table clauses.
Exchange partitions between a partition and a temporary table.
Specify the logging_clause.
Specify MOVE.
Restrictions on Altering External Tables You can add, drop, or modify the columns of an external table. However, for an external table you cannot:
Add a LONG, LOB, or object type column or change the data type of an external table column to any of these data types.
Add a constraint to an external table.
Modify the storage parameters of an external table.
Specify the logging_clause.
Specify MOVE.
Use the alter_table_clauses to modify a database table.
The physical_attributes_clause lets you change the value of the PCTFREE, PCTUSED, and INITRANS parameters and storage characteristics. Refer to physical_attributes_clause and storage_clause for a full description of these parameters and characteristics.
Restrictions on Altering Table Physical Attributes Altering physical attributes is subject to the following restrictions:
You cannot specify the PCTUSED parameter for the index segment of an index-organized table.
If you attempt to alter the storage attributes of tables in locally managed tablespaces, then Oracle Database raises an error. However, if some segments of a partitioned table reside in a locally managed tablespace and other segments reside in a dictionary-managed tablespace, then the database alters the storage attributes of the segments in the dictionary-managed tablespace but does not alter the attributes of the segments in the locally managed tablespace, and does not raise an error.
For segments with automatic segment-space management, the database ignores attempts to change the PCTUSED setting. If you alter the PCTFREE setting, then you must subsequently run the DBMS_REPAIR.SEGMENT_FIX_STATUS procedure to implement the new setting on blocks already allocated to the segment.
Cautions on Altering Tables Physical Attributes The values you specify in this clause affect the table as follows:
For a nonpartitioned table, the values you specify override any values specified for the table at create time.
For a range-, list-, or hash-partitioned table, the values you specify are the default values for the table and the actual values for every existing partition, overriding any values already set for the partitions. To change default table attributes without overriding existing partition values, use the modify_table_default_attrs clause.
For a composite-partitioned table, the values you specify are the default values for the table and all partitions of the table and the actual values for all subpartitions of the table, overriding any values already set for the subpartitions. To change default partition attributes without overriding existing subpartition values, use the modify_table_default_attrs clause with the FOR PARTITION clause.
Use the logging_clause to change the logging attribute of the table. The logging_clause specifies whether subsequent ALTER TABLE ... MOVE and ALTER TABLE ... SPLIT operations will be logged or not logged.
When used with the modify_table_default_attrs clause, this clause affects the logging attribute of a partitioned table.
See Also:
logging_clause for a full description of this clause
Oracle Database VLDB and Partitioning Guide for more information about the logging_clause and parallel DML
The table_compression clause is valid only for heap-organized tables. Use this clause to instruct Oracle Database whether to compress data segments to reduce disk and memory use. Refer to the CREATE TABLE table_compression for the full semantics of this clause and for information on creating objects with table compression.
Note:
The first time a table is altered in such a way that compressed data will be added, all bitmap indexes and bitmap index partitions on that table must be markedUNUSABLE.See Also:
Oracle Database Data Warehousing Guide for information on table compression usage scenariosUse the supplemental_table_logging clause to add or drop a redo log group or one or more supplementally logged columns in a redo log group.
In the ADD clause, use supplemental_log_grp_clause to create named supplemental log group. Use the supplemental_id_key_clause to create a system-generated log group.
On the DROP clause, use GROUP log_group syntax to drop a named supplemental log group and use the supplemental_id_key_clause to drop a system-generated log group.
The supplemental_log_grp_clause and the supplemental_id_key_clause have the same semantics in CREATE TABLE and ALTER TABLE statements. For full information on these clauses, refer to supplemental_log_grp_clause and supplemental_id_key_clause in the documentation on CREATE TABLE.
See Also:
Oracle Data Guard Concepts and Administration for information on supplemental redo log groupsUse the allocate_extent_clause to explicitly allocate a new extent for the table, the partition or subpartition, the overflow data segment, the LOB data segment, or the LOB index.
Restriction on Allocating Table Extents You cannot allocate an extent for a temporary table or for a range- or composite-partitioned table.
See Also:
allocate_extent_clause for a full description of this clause and "Allocating Extents: Example"Use the deallocate_unused_clause to explicitly deallocate unused space at the end of the table, partition or subpartition, overflow data segment, LOB data segment, or LOB index and make the space available for other segments in the tablespace.
See Also:
deallocate_unused_clause for a full description of this clause and "Deallocating Unused Space: Example"The shrink clause lets you manually shrink space in a table, index-organized table or its overflow segment, index, partition, subpartition, LOB segment, materialized view, or materialized view log. This clause is valid only for segments in tablespaces with automatic segment management. By default, Oracle Database compacts the segment, adjusts the high water mark, and releases the recuperated space immediately.
Compacting the segment requires row movement. Therefore, you must enable row movement for the object you want to shrink before specifying this clause. Further, if your application has any rowid-based triggers, you should disable them before issuing this clause.
Note:
Do not attempt to enable row movement for an index-organized table before specifying theshrink_clause. The ROWID of an index-organized table is its primary key, which never changes. Therefore, row movement is neither relevant nor valid for such tables.COMPACT If you specify COMPACT, then Oracle Database only defragments the segment space and compacts the table rows for subsequent release. The database does not readjust the high water mark and does not release the space immediately. You must issue another ALTER TABLE ... SHRINK SPACE statement later to complete the operation. This clause is useful if you want to accomplish the shrink operation in two shorter steps rather than one longer step.
For an index or index-organized table, specifying ALTER [INDEX | TABLE] ... SHRINK SPACE COMPACT is equivalent to specifying ALTER [INDEX | TABLE ... COALESCE. The shrink_clause can be cascaded (refer to the CASCADE clause, which follows) and compacts the segment more densely than does a coalesce operation, which can improve performance. However, if you do not want to release the unused space, then you can use the appropriate COALESCE clause.
CASCADE If you specify CASCADE, then Oracle Database performs the same operations on all dependent objects of table, including secondary indexes on index-organized tables.
Restrictions on the shrink_clause The shrink_clause is subject to the following restrictions:
You cannot combine this clause with any other clauses in the same ALTER TABLE statement.
You cannot specify this clause for a cluster, a clustered table, or any object with a LONG column.
Segment shrink is not supported for tables with function-based indexes, domain indexes, or bitmap join indexes.
This clause does not shrink mapping tables of index-organized tables, even if you specify CASCADE.
You cannot specify this clause for a compressed table.
You cannot shrink a table that is the master table of an ON COMMIT materialized view. Rowid materialized views must be rebuilt after the shrink operation.
The CACHE and NOCACHE clauses have the same semantics in CREATE TABLE and ALTER TABLE statements. For complete information on these clauses, refer to "CACHE | NOCACHE | CACHE READS" in the documentation on CREATE TABLE. If you omit both of these clauses in an ALTER TABLE statement, then the existing value is unchanged.
The RESULT_CACHE clause has the same semantics in CREATE TABLE and ALTER TABLE statements. For complete information on this clause, refer to "RESULT_CACHE Clause" in the documentation on CREATE TABLE. If you omit this clause in an ALTER TABLE statement, then the existing setting is unchanged.
The upgrade_table_clause is relevant for object tables and for relational tables with object columns. It lets you instruct Oracle Database to convert the metadata of the target table to conform with the latest version of each referenced type. If table is already valid, then the table metadata remains unchanged.
Restriction on Upgrading Object Tables and Columns Within this clause, you cannot specify object_type_col_properties as a clause of column_properties.
INCLUDING DATA Specify INCLUDING DATA if you want Oracle Database to convert the data in the table to the latest type version format. You can define the storage for any new column while upgrading the table by using the column_properties and the LOB_partition_storage . This is the default.
You can convert data in the table at the time you upgrade the type by specifying CASCADE INCLUDING TABLE DATA in the dependent_handling_clause of the ALTER TYPE statement. See Oracle Database PL/SQL Language Reference for information on this clause. For information on whether a table contains data based on an older type version, refer to the DATA_UPGRADED column of the USER_TAB_COLUMNS data dictionary view.
NOT INCLUDING DATA Specify NOT INCLUDING DATA if you want Oracle Database to leave column data unchanged.
Restriction on NOT INCLUDING DATA You cannot specify NOT INCLUDING DATA if the table contains columns in Oracle8 release 8.0.x image format. To determine whether the table contains such columns, refer to the V80_FMT_IMAGE column of the USER_TAB_COLUMNS data dictionary view.
See Also:
Oracle Database Reference for information on the data dictionary views
ALTER TYPE for information on converting dependent table data when modifying a type upon which the table depends
The records_per_block_clause lets you specify whether Oracle Database restricts the number of records that can be stored in a block. This clause ensures that any bitmap indexes subsequently created on the table will be as compressed as possible.
Restrictions on Records in a Block The record_per_block_clause is subject to the following restrictions:
You cannot specify either MINIMIZE or NOMINIMIZE if a bitmap index has already been defined on table. You must first drop the bitmap index.
You cannot specify this clause for an index-organized table or a nested table.
MINIMIZE Specify MINIMIZE to instruct Oracle Database to calculate the largest number of records in any block in the table and to limit future inserts so that no block can contain more than that number of records.
Oracle recommends that a representative set of data already exist in the table before you specify MINIMIZE. If you are using table compression (see table_compression ), then a representative set of compressed data should already exist in the table.
Restriction on MINIMIZE You cannot specify MINIMIZE for an empty table.
NOMINIMIZE Specify NOMINIMIZE to disable the MINIMIZE feature. This is the default.
You cannot disable row movement in a reference-partitioned table unless row movement is also disabled in the parent table. Otherwise, this clause has the same semantics in CREATE TABLE and ALTER TABLE statements. For complete information on these clauses, refer to row_movement_clause in the documentation on CREATE TABLE.
You must have the FLASHBACK ARCHIVE object privilege on the specified flashback data archive to specify this clause. Use this clause to enable or disable historical tracking for the table.
Specify FLASHBACK ARCHIVE to enable tracking for the table. You can specify flashback_archive to designate a particular flashback data archive for this table. The flashback data archive you specify much already exist.
If you omit the archive name, then the database uses the default flashback data archive designated for the system. If no default flashback data archive has been designated for the system, then you must specify flashback_archive.
You cannot specify FLASHBACK ARCHIVE to change the flashback data archive for this table. Instead you must first issue an ALTER TABLE statement with the NO FLASHBACK ARCHIVE clause and then issue an ALTER TABLE statement with the FLASHBACK ARCHIVE clause.
Specify NO FLASHBACK ARCHIVE to disable tracking for the table.
See Also:
TheCREATE TABLE flashback_archive_clause for information on creating a table with tracking enabled and CREATE FLASHBACK ARCHIVE for information on creating default flashback data archivesUse the RENAME clause to rename table to new_table_name.
Using this clause invalidates any dependent materialized views. For more information on materialized views, see CREATE MATERIALIZED VIEW and Oracle Database Data Warehousing Guide.
If a domain index is defined on the table, then the database invokes the ODCIIndexAlter() method with the RENAME option. This operation establishes correspondence between the indextype metadata and the base table.
Specify READ ONLY to put the table in read-only mode. When the table is in READ ONLY mode, you cannot issue any DML statements that affect the table or any SELECT ... FOR UPDATE statements. You can issue DDL statements as long as they do not modify any table data. Operations on indexes associated with the table are allowed when the table is in READ ONLY mode.
Specify READ WRITE to return a read-only table to read/write mode.
Use the REKEY clause to generate a new encryption key or to switch between different algorithms. This operation returns only after all encrypted columns in the table, including LOB columns, have been reencrypted.
This clause lets you alter some of the characteristics of an existing index-organized table. Index-organized tables keep data sorted on the primary key and are therefore best suited for primary-key-based access and manipulation. See index_org_table_clause in the context of CREATE TABLE.
This clause is relevant only if table is index organized. Specify COMPRESS to instruct Oracle Database to combine the primary key index blocks of the index-organized table where possible to free blocks for reuse. You can specify this clause with the parallel_clause.
PCTTHRESHOLD integer Refer to "PCTTHRESHOLD integer" in the documentation of CREATE TABLE.
INCLUDING column_name Refer to "INCLUDING column_name" in the documentation of CREATE TABLE.
The overflow_attributes let you specify the overflow data segment physical storage and logging attributes to be modified for the index-organized table. Parameter values specified in this clause apply only to the overflow data segment.
See Also:
CREATE TABLEThe add_overflow_clause lets you add an overflow data segment to the specified index-organized table. You can also use this clause to explicitly allocate an extent to or deallocate unused space from an existing overflow segment.
Use the STORE IN tablespace clause to specify tablespace storage for the entire overflow segment. Use the PARTITION clause to specify tablespace storage for the segment by partition.
For a partitioned index-organized table:
If you do not specify PARTITION, then Oracle Database automatically allocates an overflow segment for each partition. The physical attributes of these segments are inherited from the table level.
If you want to specify separate physical attributes for one or more partitions, then you must specify such attributes for every partition in the table. You need not specify the name of the partitions, but you must specify their attributes in the order in which they were created.
You can find the order of the partitions by querying the PARTITION_NAME and PARTITION_POSITION columns of the USER_IND_PARTITIONS view.
If you do not specify TABLESPACE for a particular partition, then the database uses the tablespace specified for the table. If you do not specify TABLESPACE at the table level, then the database uses the tablespace of the partition primary key index segment.
Restrictions on Overflow Attributes Within the segment_attributes_clause:
You cannot specify the OPTIMAL parameter of the physical_attributes_clause.
You cannot specify tablespace storage for the overflow segment using this clause. For a nonpartitioned table, you can use ALTER TABLE ... MOVE ... OVERFLOW to move the segment to a different tablespace. For a partitioned table, use ALTER TABLE ... MODIFY DEFAULT ATTRIBUTES ... OVERFLOW to change the default tablespace of the overflow segment.
Additional restrictions apply if table is in a locally managed tablespace, because in such tablespaces several segment attributes are managed automatically by the database.
See Also:
allocate_extent_clause and deallocate_unused_clause for full descriptions of these clauses of theadd_overflow_clauseThe alter_overflow_clause lets you change the definition of the overflow segment of an existing index-organized table.
The restrictions that apply to the add_overflow_clause also apply to the alter_overflow_clause.
Note:
When you add a column to an index-organized table, Oracle Database evaluates the maximum size of each column to estimate the largest possible row. If an overflow segment is needed but you have not specifiedOVERFLOW, then the database raises an error and does not execute the ALTER TABLE statement. This checking function guarantees that subsequent DML operations on the index-organized table will not fail because an overflow segment is lacking.The alter_mapping_table_clauses is valid only if table is index organized and has a mapping table.
allocate_extent_clause Use the allocate_extent_clause to allocate a new extent at the end of the mapping table for the index-organized table. Refer to allocate_extent_clause for a full description of this clause.
deallocate_unused_clause Specify the deallocate_unused_clause to deallocate unused space at the end of the mapping table of the index-organized table. Refer to deallocate_unused_clause for a full description of this clause.
Oracle Database automatically maintains all other attributes of the mapping table or its partitions.
Specify COALESCE to instruct Oracle Database to merge the contents of index blocks of the index the database uses to maintain the index-organized table where possible to free blocks for reuse. Refer to the shrink_clause for information on the relationship between these two clauses.
This clause is valid as part of alter_table_properties only if you are modifying an XMLType table with BINARY XML storage. Refer to XMLSchema_spec in the documentation on CREATE TABLE for more information on the ALLOW and DISALLOW clauses.
Use these clauses to add, drop, or otherwise modify a column.
The add_column_clause lets you add a column to a table.
See Also:
CREATE TABLE for a description of the keywords and parameters of this clause and "Adding a Table Column: Example"Unless otherwise noted in this section, the elements of column_definition have the same behavior when adding a column to an existing table as they do when creating a new table. Refer to column_definition for information.
Restriction on column_definition The SORT parameter is valid only when creating a new table. You cannot specify SORT in the column_definition of an ALTER TABLE ... ADD statement.
When you add a column, the initial value of each row for the new column is null.
If you specify the DEFAULT clause for a NOT NULL column, then the default value is stored as metadata but the column itself is not populated with data. However, subsequent queries that specify the new column are rewritten so that the default value is returned in the result set.
This optimized behavior differs from earlier releases, when as part of the ALTER TABLE operation Oracle Database updated each row in the newly created column with the default value, and then fired any update triggers defined on the table. In this release, no triggers are fired because the default is stored only as metadata. The optimized behavior is subject to the following restrictions:
The table cannot have any LOB columns. It cannot be index-organized, temporary, or part of a cluster. It also cannot be a queue table, an object table, or the container table of a materialized view.
If the table has a Virtual Private Database (VPD) policy on it, then the optimized behavior will not take place unless the user who issues the ALTER TABLE ... ADD statement has the EXEMPT ACCESS POLICY system privilege.
The column being added cannot be encrypted, and cannot be an object column, nested table column, or a LOB column.
If you specify the DEFAULT clause for a nullable column, then the default value is added to existing rows as part of this ALTER TABLE statement, and any update triggers defined on the table are fired. This behavior also results if you change a NOT NULL column with a default value to be nullable.
Note:
If a column has a default value, then you can use theDEFAULT clause to change the default to NULL, but you cannot remove the default value completely. If a column has ever had a default value assigned to it, then the DATA_DEFAULT column of the USER_TAB_COLUMNS data dictionary view will always display either a default value or NULL.You can add an overflow data segment to each partition of a partitioned index-organized table.
You can add LOB columns to nonpartitioned and partitioned tables. You can specify LOB storage at the table and at the partition or subpartition level.
If you previously created a view with a query that used the SELECT * syntax to select all columns from table, and you now add a column to table, then the database does not automatically add the new column to the view. To add the new column to the view, re-create the view using the CREATE VIEW statement with the OR REPLACE clause. Refer to CREATE VIEW for more information.
Restrictions on Adding Columns The addition of columns is subject to the following restrictions:
You cannot add a LOB column to a cluster table.
If you add a LOB column to a hash-partitioned table, then the only attribute you can specify for the new partition is TABLESPACE.
You cannot add a column with a NOT NULL constraint if table has any rows unless you also specify the DEFAULT clause.
If you specify this clause for an index-organized table, then you cannot specify any other clauses in the same statement.
Use the DEFAULT clause to specify a default for a new column or a new default for an existing column. Oracle Database assigns this value to the column if a subsequent INSERT statement omits a value for the column. If you are adding a new column to the table and specify the default value, then the database inserts the default column value into all rows of the table.
The data type of the default value must match the data type specified for the column. The column must also be large enough to hold the default value.
Restrictions on Default Column Values Default column values are subject to the following restrictions:
A DEFAULT expression cannot contain references to other columns, the pseudocolumns CURRVAL, NEXTVAL, LEVEL, and ROWNUM, or date constants that are not fully specified.
The expression can be of any form except a scalar subquery expression.
Use inline_constraint to add a constraint to the new column.
This clause lets you describe a new column of type REF. Refer to constraint for syntax and description of this type of constraint, including restrictions.
The virtual_column_definition has the same semantics when you add a column that it has when you create a column.
See Also:
TheCREATE TABLE virtual_column_definition and "Adding a Virtual Table Column: Example" for more informationRestriction on Adding a Virtual Column You cannot add a virtual column when the SQL expression for the virtual column involves a column on which an Oracle Data Redaction policy is defined.
The clauses of column_properties determine the storage characteristics of an object type, nested table, varray, or LOB column.
object_type_col_properties This clause is valid only when you are adding a new object type column or attribute. To modify the properties of an existing object type column, use the modify_column_clauses. The semantics of this clause are the same as for CREATE TABLE unless otherwise noted.
Use the object_type_col_properties clause to specify storage characteristics for a new object column or attribute or an element of a collection column or attribute.
For complete information on this clause, refer to object_type_col_properties in the documentation on CREATE TABLE.
nested_table_col_properties The nested_table_col_properties clause lets you specify separate storage characteristics for a nested table, which in turn lets you to define the nested table as an index-organized table. You must include this clause when creating a table with columns or column attributes whose type is a nested table. (Clauses within this clause that function the same way they function for parent object tables are not repeated here. See the CREATE TABLE clause nested_table_col_properties for more information about these clauses.)
For nested_item, specify the name of a column (or a top-level attribute of the nested table object type) whose type is a nested table.
If the nested table is a multilevel collection, and the inner nested table does not have a name, then specify COLUMN_VALUE in place of the nested_item name.
For storage_table, specify the name of the table where the rows of nested_item reside. The storage table is created in the same schema and the same tablespace as the parent table.
Restrictions on Nested Table Column Properties Nested table column properties are subject to the following restrictions:
You cannot specify the parallel_clause.
You cannot specify CLUSTER as part of the physical_properties clause.
See Also:
"Nested Tables: Examples"varray_col_properties The varray_col_properties clause lets you specify separate storage characteristics for the LOB in which a varray will be stored. If you specify this clause, then Oracle Database will always store the varray in a LOB, even if it is small enough to be stored inline. If varray_item is a multilevel collection, then the database stores all collection items nested within varray_item in the same LOB in which varray_item is stored.
Restriction on Varray Column Properties You cannot specify TABLESPACE as part of LOB_parameters for a varray column. The LOB tablespace for a varray defaults to the tablespace of the containing table.
This clause lets you specify storage attributes the newly added column for each partition or subpartition in a partitioned table. For any partition or subpartition you do not name in this clause, the storage attributes for the new column are the same as those specified in the nested_table_col_properties at the table level.
Use the LOB_storage_clause to specify the LOB storage characteristics for a newly added LOB column, LOB partition, or LOB subpartition, or when you are converting a LONG column into a LOB column. You cannot use this clause to modify an existing LOB. Instead, you must use the modify_LOB_storage_clause.
Unless otherwise noted in this section, all LOB parameters, in both the LOB_storage_clause and the modify_LOB_storage_clause, have the same semantics in an ALTER TABLE statement that they have in a CREATE TABLE statement. Refer to the CREATE TABLE LOB_storage_clause for complete information on this clause.
Restriction on LOB Parameters The only parameter of LOB_parameters you can specify for a hash partition or hash subpartition is TABLESPACE.
CACHE READS Clause When you add a new LOB column, you can specify the logging attribute with CACHE READS, as you can when defining a LOB column at create time. Refer to the CREATE TABLE clause CACHE READS for full information on this clause.
ENABLE | DISABLE STORAGE IN ROW You cannot change STORAGE IN ROW once it is set. Therefore, you cannot specify this clause as part of the modify_col_properties clause. However, you can change this setting when adding a new column (add_column_clause ) or when moving the table (move_table_clause ). Refer to the CREATE TABLE clause ENABLE STORAGE IN ROW for complete information on this clause.
CHUNK integer You use cannot use the modify_col_properties clause to change the value of CHUNK after it has been set. If you require a different CHUNK value for a column after it has been created, use ALTER TABLE … MOVE. Refer to the CREATE TABLE clause CHUNK integer for more information.
RETENTION For BasicFiles LOBs, if the database is in automatic undo mode, then you can specify RETENTION instead of PCTVERSION to instruct Oracle Database to retain old versions of this LOB. This clause overrides any prior setting of PCTVERSION. Refer to the CREATE TABLE clause LOB_retention_clause for a full description of this parameter.
FREEPOOLS integer For BasicFiles LOBs, if the database is in automatic undo mode, then you can use this clause to specify the number of freelist groups for this LOB. This clause overrides any prior setting of FREELIST GROUPS. Refer to the CREATE TABLE clause FREEPOOLS integer for a full description of this parameter. The database ignores this parameter for SecureFiles LOBs.
You can specify only one list of LOB_partition_storage clauses in a single ALTER TABLE statement, and all LOB_storage_clauses and varray_col_properties clause must precede the list of LOB_partition_storage clauses. Refer to the CREATE TABLE clause LOB_partition_storage for full information on this clause, including restrictions.
XMLType_column_properties Refer to the CREATE TABLE clause XMLType_column_properties for a full description of this clause.
See Also:
LOB_storage_clause for information on the LOB_segname and LOB_parameters clauses
"XMLType Column Examples" for an example of XMLType columns in object-relational tables and "Using XML in SQL Statements" for an example of creating an XMLSchema
Oracle XML DB Developer's Guide for more information on XMLType columns and tables and on creating an XMLSchema
Use the modify_column_clauses to modify the properties of an existing column or the substitutability of an existing object type column.
See Also:
"Modifying Table Columns: Examples"Use this clause to modify the properties of the column. Any of the optional parts of the column definition (data type, default value, or constraint) that you omit from this clause remain unchanged.
data type You can change the data type of any column if all rows of the column contain nulls. However, if you change the data type of a column in a materialized view container table, then Oracle Database invalidates the corresponding materialized view.
You can omit the data type only if the statement also designates the column as part of the foreign key of a referential integrity constraint. The database automatically assigns the column the same data type as the corresponding column of the referenced key of the referential integrity constraint.
You can always increase the size of a character or raw column or the precision of a numeric column, whether or not all the rows contain nulls. You can reduce the size of a data type of a column as long as the change does not require data to be modified.The database scans existing data and returns an error if data exists that exceeds the new length limit.
You can modify a DATE column to TIMESTAMP or TIMESTAMP WITH LOCAL TIME ZONE. You can modify any TIMESTAMP WITH LOCAL TIME ZONE to a DATE column.
Note:
When you modify aTIMESTAMP WITH LOCAL TIME ZONE column to a DATE column, the fractional seconds and time zone adjustment data is lost.
If the TIMESTAMP WITH LOCAL TIME ZONE data has fractional seconds, then Oracle Database updates the row data for the column by rounding the fractional seconds.
If the TIMESTAMP WITH LOCAL TIME ZONE data has the minute field greater than or equal to 60 (which can occur in a boundary case when the daylight saving rule switches), then Oracle Database updates the row data for the column by subtracting 60 from its minute field.
If the table is empty, then you can increase or decrease the leading field or the fractional second value of a datetime or interval column. If the table is not empty, then you can only increase the leading field or fractional second of a datetime or interval column.
You can use the TO_LOB function to change a LONG column to a CLOB or NCLOB column, and a LONG RAW column to a BLOB column. However, you cannot use the TO_LOB function from within a PL/SQL package. Instead use the TO_CLOB or TO_BLOB functions.
The modified LOB column inherits all constraints and triggers that were defined on the original LONG column. If you want to change any constraints, then you must do so in a subsequent ALTER TABLE statement.
If any domain indexes are defined on the LONG column, then you must drop them before modifying the column to a LOB.
After the modification, you will have to rebuild all other indexes on all columns of the table.
You can use the TO_CLOB function to convert NCLOB columns CLOB columns.
See Also:
Oracle Database SecureFiles and Large Objects Developer's Guide for information on LONG to LOB migration
ALTER INDEX for information on dropping and rebuilding indexes
For CHAR and VARCHAR2 columns, you can change the length semantics by specifying CHAR (to indicate character semantics for a column that was originally specified in bytes) or BYTE (to indicate byte semantics for a column that was originally specified in characters). To learn the length semantics of existing columns, query the CHAR_USED column of the ALL_, USER_, or DBA_TAB_COLUMNS data dictionary view.
See Also:
Oracle Database Globalization Support Guide for information on byte and character semantics
Oracle Database Reference for information on the data dictionary views
ENCRYPT encryption_spec | DECRYPT Use this clause to decrypt an encrypted column, to encrypt an unencrypted column, or to change the integrity algorithm or the SALT option of an encrypted column.
When encrypting an existing column, if you specify encryption_spec, it must match the encryption specification of any other encrypted columns in the same table. Refer to the CREATE TABLE clause encryption_spec for additional information and restrictions on the encryption_spec.
If a materialized view log is defined on the table, then Oracle Database encrypts or decrypts in the materialized view log any columns you encrypt or decrypt in this clause.
Restrictions on ENCRYPT encryption_spec | DECRYPT: This clause is subject to the following restrictions:
If the new or existing column is a LOB column, then it must be stored as a SecureFiles LOB, and you cannot specify the SALT option.
You cannot encrypt or decrypt a column on which a fine-grained audit policy for the UPDATE statement is enabled. However, you can disable the fine-grained audit policy, encrypt or decrypt the column, and then enable the fine-grained audit policy.
See Also:
"Data Encryption: Examples"inline_constraint This clause lets you add a constraint to a column you are modifying. To change the state of existing constraints on existing columns, use the constraint_clauses.
LOB_storage_clause The LOB_storage_clause is permitted within modify_col_properties only if you are converting a LONG column to a LOB column. In this case only, you can specify LOB storage for the column using the LOB_storage_clause. However, you can specify only the single column as a LOB_item. Default LOB storage attributes are used for any attributes you omit in the LOB_storage_clause.
alter_XMLSchema_clause This clause is valid within modify_col_properties only for XMLType tables with BINARY XML storage. Refer to XMLSchema_spec in the documentation on CREATE TABLE for more information on the ALLOW and DISALLOW clauses.
Restrictions on Modifying Column Properties The modification of column properties is subject to the following restrictions:
You cannot change the data type of a LOB column.
You cannot modify a column of a table if a domain index is defined on the column. You must first drop the domain index and then modify the column.
You cannot modify the data type or length of a column that is part of the partitioning or subpartitioning key of a table or index.
You can change a CHAR column to VARCHAR2 (or VARCHAR) and a VARCHAR2 (or VARCHAR) column to CHAR only if the BLANK_TRIMMING initialization parameter is set to TRUE and the column size stays the same or increases. If the BLANK_TRIMMING initialization parameter is set to TRUE, then you can also reduce the column size to any size greater than or equal to the maximum trimmed data value.
You cannot change a LONG or LONG RAW column to a LOB if the table is part of a cluster. If you do change a LONG or LONG RAW column to a LOB, then the only other clauses you can specify in this ALTER TABLE statement are the DEFAULT clause and the LOB_storage_clause.
You can specify the LOB_storage_clause as part of modify_col_properties only when you are changing a LONG or LONG RAW column to a LOB.
You cannot specify a column of data type ROWID for an index-organized table, but you can specify a column of type UROWID.
You cannot change the data type of a column to REF.
See Also:
ALTER MATERIALIZED VIEW for information on revalidating a materialized viewUse this clause to set or change the substitutability of an existing object type column.
The FORCE keyword drops any hidden columns containing typeid information or data for subtype attributes. You must specify FORCE if the column or any attributes of its type are not FINAL.
Restrictions on Modifying Column Substitutability The modification of column substitutability is subject to the following restrictions:
You can specify this clause only once in any ALTER TABLE statement.
You cannot modify the substitutability of a column in an object table if the substitutability of the table itself has been set.
You cannot specify this clause if the column was created or added using the IS OF TYPE syntax, which limits the range of subtypes permitted in an object column or attribute to a particular subtype. Refer to substitutable_column_clause in the documentation on CREATE TABLE for information on the IS OF TYPE syntax.
You cannot change a varray column to NOT SUBSTITUTABLE, even by specifying FORCE, if any of its attributes are nested object types that are not FINAL.
The drop_column_clause lets you free space in the database by dropping columns you no longer need or by marking them to be dropped at a future time when the demand on system resources is less.
If you drop a nested table column, then its storage table is removed.
If you drop a LOB column, then the LOB data and its corresponding LOB index segment are removed.
If you drop a BFILE column, then only the locators stored in that column are removed, not the files referenced by the locators.
If you drop or mark unused a column defined as an INCLUDING column, then the column stored immediately before this column will become the new INCLUDING column.
Specify SET UNUSED to mark one or more columns as unused. For an internal heap-organized table, specifying this clause does not actually remove the target columns from each row in the table. It does not restore the disk space used by these columns. Therefore, the response time is faster than when you execute the DROP clause.
When you specify this clause for a column in an external table, the clause is transparently converted to an ALTER TABLE ... DROP COLUMN statement. The reason for this is that any operation on an external table is a metadata-only operation, so there is no difference in the performance of the two commands.
You can view all tables with columns marked UNUSED in the data dictionary views USER_UNUSED_COL_TABS, DBA_UNUSED_COL_TABS, and ALL_UNUSED_COL_TABS.
See Also:
Oracle Database Reference for information on the data dictionary viewsUnused columns are treated as if they were dropped, even though their column data remains in the table rows. After a column has been marked UNUSED, you have no access to that column. A SELECT * query will not retrieve data from unused columns. In addition, the names and types of columns marked UNUSED will not be displayed during a DESCRIBE, and you can add to the table a new column with the same name as an unused column.
Note:
Until you actually drop these columns, they continue to count toward the absolute limit of 1000 columns in a single table. However, as with all DDL statements, you cannot roll back the results of this clause. You cannot issueSET USED counterpart to retrieve a column that you have SET UNUSED. Refer to CREATE TABLE for more information on the 1000-column limit.
Also, if you mark a LONG column as UNUSED, then you cannot add another LONG column to the table until you actually drop the unused LONG column.
Specify DROP to remove the column descriptor and the data associated with the target column from each row in the table. If you explicitly drop a particular column, then all columns currently marked UNUSED in the target table are dropped at the same time.
When the column data is dropped:
All indexes defined on any of the target columns are also dropped.
All constraints that reference a target column are removed.
If any statistics types are associated with the target columns, then Oracle Database disassociates the statistics from the column with the FORCE option and drops any statistics collected using the statistics type.
Note:
If the target column is a parent key of a nontarget column, or if a check constraint references both the target and nontarget columns, then Oracle Database returns an error and does not drop the column unless you have specified theCASCADE CONSTRAINTS clause. If you have specified that clause, then the database removes all constraints that reference any of the target columns.See Also:
DISASSOCIATE STATISTICS for more information on disassociating statistics typesSpecify DROP UNUSED COLUMNS to remove from the table all columns currently marked as unused. Use this statement when you want to reclaim the extra disk space from unused columns in the table. If the table contains no unused columns, then the statement returns with no errors.
column Specify one or more columns to be set as unused or dropped. Use the COLUMN keyword only if you are specifying only one column. If you specify a column list, then it cannot contain duplicates.
CASCADE CONSTRAINTS Specify CASCADE CONSTRAINTS if you want to drop all foreign key constraints that refer to the primary and unique keys defined on the dropped columns as well as all multicolumn constraints defined on the dropped columns. If any constraint is referenced by columns from other tables or remaining columns in the target table, then you must specify CASCADE CONSTRAINTS. Otherwise, the statement aborts and an error is returned.
INVALIDATE The INVALIDATE keyword is optional. Oracle Database automatically invalidates all dependent objects, such as views, triggers, and stored program units. Object invalidation is a recursive process. Therefore, all directly dependent and indirectly dependent objects are invalidated. However, only local dependencies are invalidated, because the database manages remote dependencies differently from local dependencies.
An object invalidated by this statement is automatically revalidated when next referenced. You must then correct any errors that exist in that object before referencing it.
See Also:
Oracle Database Concepts for more information on dependenciesCHECKPOINT Specify CHECKPOINT if you want Oracle Database to apply a checkpoint for the DROP COLUMN operation after processing integer rows; integer is optional and must be greater than zero. If integer is greater than the number of rows in the table, then the database applies a checkpoint after all the rows have been processed. If you do not specify integer, then the database sets the default of 512. Checkpointing cuts down the amount of undo logs accumulated during the DROP COLUMN operation to avoid running out of undo space. However, if this statement is interrupted after a checkpoint has been applied, then the table remains in an unusable state. While the table is unusable, the only operations allowed on it are DROP TABLE, TRUNCATE TABLE, and ALTER TABLE DROP ... COLUMNS CONTINUE (described in sections that follow).
You cannot use this clause with SET UNUSED, because that clause does not remove column data.
Specify DROP COLUMNS CONTINUE to continue the drop column operation from the point at which it was interrupted. Submitting this statement while the table is in an invalid state results in an error.
Restrictions on Dropping Columns Dropping columns is subject to the following restrictions:
Each of the parts of this clause can be specified only once in the statement and cannot be mixed with any other ALTER TABLE clauses. For example, the following statements are not allowed:
ALTER TABLE t1 DROP COLUMN f1 DROP (f2); ALTER TABLE t1 DROP COLUMN f1 SET UNUSED (f2); ALTER TABLE t1 DROP (f1) ADD (f2 NUMBER); ALTER TABLE t1 SET UNUSED (f3) ADD (CONSTRAINT ck1 CHECK (f2 > 0));
You can drop an object type column only as an entity. To drop an attribute from an object type column, use the ALTER TYPE ... DROP ATTRIBUTE statement with the CASCADE INCLUDING TABLE DATA clause. Be aware that dropping an attribute affects all dependent objects. See Oracle Database PL/SQL Language Reference for more information.
You can drop a column from an index-organized table only if it is not a primary key column. The primary key constraint of an index-organized table can never be dropped, so you cannot drop a primary key column even if you have specified CASCADE CONSTRAINTS.
You can export tables with dropped or unused columns. However, you can import a table only if all the columns specified in the export files are present in the table (none of those columns has been dropped or marked unused). Otherwise, Oracle Database returns an error.
You can set unused a column from a table that uses COMPRESS BASIC, but you cannot drop the column. However, all clauses of the drop_column_clause are valid for tables that use COMPRESS FOR OLTP. See the semantics for table_compression for more information.
You cannot drop a column on which a domain index has been built.
You cannot drop a SCOPE table constraint or a WITH ROWID constraint on a REF column.
You cannot use this clause to drop:
A pseudocolumn, cluster column, or partitioning column. You can drop nonpartitioning columns from a partitioned table if all the tablespaces where the partitions were created are online and in read/write mode.
A column from a nested table, an object table, or a table owned by SYS.
See Also:
"Dropping a Column: Example"Use the rename_column_clause to rename a column of table. The new column name must not be the same as any other column name in table.
When you rename a column, Oracle Database handles dependent objects as follows:
Function-based indexes and check constraints that depend on the renamed column remain valid.
Dependent views, triggers, functions, procedures, and packages are invalidated. Oracle Database attempts to revalidate them when they are next accessed, but you may need to alter these objects with the new column name if revalidation fails.
If a domain index is defined on the column being renamed, then the database invokes the ODCIIndexAlter method with the RENAME option. This operation establishes correspondence between the indextype metadata and the base table
Restrictions on Renaming Columns Renaming columns is subject to the following restrictions:
You cannot combine this clause with any of the other column_clauses in the same statement.
You cannot rename a column that is used to define a join index. Instead you must drop the index, rename the column, and re-create the index.
See Also:
"Renaming a Column: Example"Use the modify_collection_retrieval clause to change what Oracle Database returns when a collection item is retrieved from the database.
collection_item Specify the name of a column-qualified attribute whose type is nested table or varray.
RETURN AS Specify what Oracle Database should return as the result of a query:
LOCATOR specifies that a unique locator for the nested table is returned.
VALUE specifies that a copy of the nested table itself is returned.
See Also:
"Collection Retrieval: Example"The modify_LOB_storage_clause lets you change the physical attributes of LOB_item. You can specify only one LOB_item for each modify_LOB_storage_clause.
The sections that follow describe the semantics of parameters specific to modify_LOB_parameters. Unless otherwise documented in this section, the remaining LOB parameters have the same semantics when altering a table that they have when you are creating a table. Refer to the restrictions at the end of this section and to the CREATE TABLE clause LOB_storage_parameters for more information.
Notes:
You can modify LOB storage with an ALTER TABLE statement or with online redefinition by using the DBMS_REDEFINITION package. If you have not enabled LOB encryption, compression, or deduplication at create time, Oracle recommends that you use online redefinition to enable them after creation, as this process is more disk space efficient for changes to these three parameters. See Oracle Database PL/SQL Packages and Types Reference for more information on DBMS_REDEFINITION.
You cannot convert a LOB from one type of storage to the other. Instead you must migrate to SecureFiles or BasicFiles by using online redefinition or partition exchange.
PCTVERSION integer Refer to the CREATE TABLE clause PCTVERSION integer for information on this clause.
LOB_retention_clause If the database is in automatic undo mode, then you can specify RETENTION instead of PCTVERSION to instruct Oracle Database to retain old versions of this LOB. This clause overrides any prior setting of PCTVERSION.
FREEPOOLS integer For BasicFiles LOBs, if the database is in automatic undo mode, then you can use this clause to specify the number of freelist groups for this LOB. This clause overrides any prior setting of FREELIST GROUPS. Refer to the CREATE TABLE clause FREEPOOLS integer for a full description of this parameter. The database ignores this parameter for SecureFiles LOBs.
REBUILD FREEPOOLS This clause applies only to BasicFiles LOBs, not to SecureFiles LOBs. The REBUILD FREEPOOLS clause removes all the old versions of data from the LOB column. This clause is useful for removing all retained old version space in a LOB segment, freeing that space to be used immediately by new LOB data.
LOB_deduplicate_clause This clause is valid only for SecureFiles LOBs. KEEP_DUPLICATES disables LOB deduplication. DEDUPLICATE enables LOB deduplication. All lobs in the segment are read, and any matching LOBs are deduplicated before returning.
LOB_compression_clause This clause is valid only for SecureFiles LOBs. COMPRESS compresses all LOBs in the segment and then returns. NOCOMPRESS uncompresses all LOBs in the segment and then returns.
ENCRYPT | DECRYPT LOB encryption has the same semantics as column encryption in general. See "ENCRYPT encryption_spec | DECRYPT" for more information.
CACHE, NOCACHE, CACHE READS When you modify a LOB column from CACHE or NOCACHE to CACHE READS, or from CACHE READS to CACHE or NOCACHE, you can change the logging attribute. If you do not specify LOGGING or NOLOGGING, then this attribute defaults to the current logging attribute of the LOB column. If you do not specify CACHE, NOCACHE, or CACHE READS, then Oracle Database retains the existing values of the LOB attributes.
Restrictions on Modifying LOB Storage Modifying LOB storage is subject to the following restrictions:
You cannot modify the value of the INITIAL parameter in the storage_clause when modifying the LOB storage attributes.
You cannot specify both the allocate_extent_clause and the deallocate_unused_clause in the same statement.
You cannot specify both the PCTVERSION and RETENTION parameters.
You cannot specify the shrink_clause for SecureFiles LOBs.
See Also:
LOB_storage_clause (inCREATE TABLE) for information on setting LOB parameters and "LOB Columns: Examples"The alter_varray_col_properties clause lets you change the storage characteristics of an existing LOB in which a varray is stored.
Restriction on Altering Varray Column Properties You cannot specify the TABLESPACE clause of LOB_parameters as part of this clause. The LOB tablespace for a varray defaults to the tablespace of the containing table.
The REKEY clause causes the database to generate a new encryption key. All encrypted columns in the table are reencrypted using the new key and, if you specify the USING clause of the encryption_spec, a new encryption algorithm. You cannot combine this clause with any other clauses in this ALTER TABLE statement.
See Also:
Oracle Database Advanced Security Administrator's Guide for more information on transparent column encryptionUse the constraint_clauses to add a new constraint using out-of-line declaration, modify the state of an existing constraint, or drop a constraint. Refer to constraint for a description of all the keywords and parameters of out-of-line constraints and constraint_state.
The ADD clause lets you add a new out-of-line constraint or out-of-line REF constraint to the table.
See Also:
"Disabling a CHECK Constraint: Example", "Specifying Object Identifiers: Example", and "REF Columns: Examples"The MODIFY CONSTRAINT clause lets you change the state of an existing constraint.
The CASCADE keyword is valid only when you are disabling a unique or primary key constraint on which a foreign key constraint is defined. In this case, you must specify CASCADE so that the unique or primary key constraint and all of its dependent foreign key constraints are disabled.
Restrictions on Modifying Constraints Modifying constraints is subject to the following restrictions:
You cannot change the state of a NOT DEFERRABLE constraint to INITIALLY DEFERRED.
If you specify this clause for an index-organized table, then you cannot specify any other clauses in the same statement.
You cannot change the NOT NULL constraint on a foreign key column of a reference-partitioned table, and you cannot change the state of a partitioning referential constraint of a reference-partitioned table.
The RENAME CONSTRAINT clause lets you rename any existing constraint on table. The new constraint name cannot be the same as any existing constraint on any object in the same schema. All objects that are dependent on the constraint remain valid.
See Also:
"Renaming Constraints: Example"The drop_constraint_clause lets you drop an integrity constraint from the database. Oracle Database stops enforcing the constraint and removes it from the data dictionary. You can specify only one constraint for each drop_constraint_clause, but you can specify multiple drop_constraint_clause in one statement.
Restrictions on Dropping Constraints You cannot drop the NOT NULL constraint on a foreign key column of a reference-partitioned table, and you cannot drop a partitioning referential constraint of a reference-partitioned table.
PRIMARY KEY Specify PRIMARY KEY to drop the primary key constraint of table.
UNIQUE Specify UNIQUE to drop the unique constraint on the specified columns.
If you drop the primary key or unique constraint from a column on which a bitmap join index is defined, then Oracle Database invalidates the index. See CREATE INDEX for information on bitmap join indexes.
CONSTRAINT Specify CONSTRAINT constraint_name to drop an integrity constraint other than a primary key or unique constraint.
CASCADE Specify CASCADE if you want all other integrity constraints that depend on the dropped integrity constraint to be dropped as well.
KEEP INDEX | DROP INDEX Specify KEEP INDEX or DROP INDEX to indicate whether Oracle Database should preserve or drop the index it has been using to enforce the PRIMARY KEY or UNIQUE constraint.
Restrictions on Dropping Constraints Dropping constraints is subject to the following restrictions:
You cannot drop a primary key or unique key constraint that is part of a referential integrity constraint without also dropping the foreign key. To drop the referenced key and the foreign key together, use the CASCADE clause. If you omit CASCADE, then Oracle Database does not drop the primary key or unique constraint if any foreign key references it.
You cannot drop a primary key constraint (even with the CASCADE clause) on a table that uses the primary key as its object identifier (OID).
If you drop a referential integrity constraint on a REF column, then the REF column remains scoped to the referenced table.
You cannot drop the scope of a REF column.
See Also:
"Dropping Constraints: Examples"Use the alter_external_table clauses to change the characteristics of an external table. This clause has no affect on the external data itself. The syntax and semantics of the parallel_clause, enable_disable_clause, external_data_properties, and REJECT LIMIT clause are the same as described for CREATE TABLE. See the external_table_clause (in CREATE TABLE).
PROJECT COLUMN Clause This clause lets you determine how the access driver validates the rows of an external table in subsequent queries. The default is PROJECT COLUMN ALL, which means that the access driver processes all column values, regardless of which columns are selected, and validates only those rows with fully valid column entries. If any column value would raise an error, such as a data type conversion error, then the row is rejected even if that column was not referenced in the select list. If you specify PROJECT COLUMN REFERENCED, then the access driver processes only those columns in the select list.
The ALL setting guarantees consistent result sets. The REFERENCED setting can result in different numbers of rows returned, depending on the columns referenced in subsequent queries, but is faster than the ALL setting. If a subsequent query selects all columns of the external table, then the settings behave identically.
Restrictions on Altering External Tables Altering external tables is subject to the following restrictions:
You cannot modify an external table using any clause outside of this clause.
You cannot add a LONG, varray, or object type column to an external table, nor can you change the data type of an external table column to any of these data types.
You cannot add a constraint to an external table.
You cannot modify the storage parameters of an external table.
The clauses in this section apply only to partitioned tables. You cannot combine partition operations with other partition operations or with operations on the base table in the same ALTER TABLE statement.
Notes on Changing Table Partitioning The following notes apply when changing table partitioning:
If you drop, exchange, truncate, move, modify, or split a partition on a table that is a master table for one or more materialized views, then existing bulk load information about the table will be deleted. Therefore, be sure to refresh all dependent materialized views before performing any of these operations.
If a bitmap join index is defined on table, then any operation that alters a partition of table causes Oracle Database to mark the index UNUSABLE.
The only alter_table_partitioning clauses you can specify for a reference-partitioned table are modify_table_default_attrs, move_table_[sub]partition, truncate_partition_subpart, and exchange_partition_subpart. None of these operations cascade to any child table of the reference-partitioned table. No other partition maintenance operations are valid on a reference-partitioned table, but you can specify the other partition maintenance operations on the parent table of a reference-partitioned table, and the operation will cascade to the child reference-partitioned table.
When adding partitions and subpartitions, bear in mind that you can specify up to a total of 1024K-1 partitions and subpartitions for each table.
When you add a table partition or subpartition and you omit the partition name, the database generates a name using the rules described in "Notes on Partitioning in General".
When you move, add (hash only), coalesce, drop, split, merge, rename, or truncate a table partition or subpartition, the procedures, functions, packages, package bodies, views, type bodies, and triggers that reference the table remain valid. All other dependent objects are invalidated.
For additional information on partition operations on tables with an associated CONTEXT domain index, refer to Oracle Text Reference.
The storage of partitioned database entities in tablespaces of different block sizes is subject to several restrictions. Refer to Oracle Database VLDB and Partitioning Guide for a discussion of these restrictions.
The modify_table_default_attrs clause lets you specify new default values for the attributes of table. Only attributes named in the statement are affected. Partitions and LOB partitions you create subsequently will inherit these values unless you override them explicitly when creating the partition or LOB partition. Existing partitions and LOB partitions are not affected by this clause.
Only attributes named in the statement are affected, and the default values specified are overridden by any attributes specified at the individual partition or LOB partition level.
FOR partition_extended_name applies only to composite-partitioned tables. This clause specifies new default values for the attributes of the partition identified in partition_extended_name. Subpartitions and LOB subpartitions of that partition that you create subsequently will inherit these values unless you override them explicitly when creating the subpartition or LOB subpartition. Existing subpartitions are not affected by this clause.
PCTTHRESHOLD, key_compression, and the alter_overflow_clause are valid only for partitioned index-organized tables.
You can specify the key compression only if key compression is already specified at the table level. Further, you cannot specify an integer after the COMPRESS keyword. Key compression length can be specified only when you create the table.
You cannot specify the PCTUSED parameter in segment_attributes for the index segment of an index-organized table.
Use this clause:
To convert an existing range-partitioned table to interval partitioning. The database automatically creates partitions of the specified numeric range or datetime interval as needed for data beyond the highest value allowed for the last range partition.
To change the interval of an existing interval-partitioned table. The database converts existing interval partitions to range partitions, and then automatically creates partitions of the specified numeric range or datetime interval as needed for data beyond the highest value allowed for the last range partition.
To change the tablespace storage for an existing interval-partitioned table.
To change an interval-partitioned table back to a range-partitioned table. Use SET INTERVAL () to disable interval partitioning. The database converts existing interval partitions to range partitions, using the higher boundaries of created interval partitions as upper boundaries for the range partitions to be created.
For expr, specify a valid number or interval expression.
See Also:
TheCREATE TABLE "INTERVAL Clause" and Oracle Database VLDB and Partitioning Guide for more information on interval partitioningUse the set_subpartition_template clause to create or replace existing default range, list, or hash subpartition definitions for each table partition. This clause is valid only for composite-partitioned tables. It replaces the existing subpartition template or creates a new template if you have not previously created one. Existing subpartitions are not affected, nor are existing local and global indexes. However, subsequent partitioning operations (such as add and merge operations) will use the new template.
You can drop an existing subpartition template by specifying ALTER TABLE table SET SUBPARTITION TEMPLATE ().
Note:
When you specify tablespace storage for the subpartition template, it does not override any tablespace storage you have specified explicitly for the partitions oftable. To specify tablespace storage for subpartitions, do one of these things:
Omit tablespace storage at the partition level and specify tablespace storage in the subpartition template.
Define individual subpartitions with specific tablespace storage.
Restrictions on Subpartition Templates Refer to "Restrictions on Subpartition Templates" in the documentation on CREATE TABLE.
The modify_table_partition clause lets you change the real physical attributes of a range, hash, list partition, or system partition. This clause optionally modifies the storage attributes of one or more LOB items for the partition. You can specify new values for physical attributes (with some restrictions, as noted in the sections that follow), logging, and storage parameters.
For all types of partitions, you can also specify how Oracle Database should handle local indexes that become unusable as a result of the modification to the partition. See "UNUSABLE LOCAL INDEXES Clauses".
For partitioned index-organized tables, you can also update the mapping table in conjunction with partition changes. See the alter_mapping_table_clauses .
Notes on Modifying Table Partitions The following notes apply to operations on range, list, and hash table partition:
For all types of table partition, in the partition_attributes clause, the shrink_clause lets you compact an individual partition segment. Refer to shrink_clause for additional information on this clause.
The syntax and semantics for modifying a system partition are the same as those for modifying a hash partition. Refer to modify_hash_partition.
If table is composite partitioned, then:
If you specify the allocate_extent_clause, then Oracle Database allocates an extent for each subpartition of partition.
If you specify the deallocate_unused_clause, then Oracle Database deallocates unused storage from each subpartition of partition.
Any other attributes changed in this clause will be changed in subpartitions of partition as well, overriding existing values. To avoid changing the attributes of existing subpartitions, use the FOR PARTITION clause of modify_table_default_attrs.
When you modify the partition_attributes of a table partition with equipartitioned nested tables, the changes do not apply to the nested table partitions corresponding to the table partition being modified. However, you can modify the storage table of the nested table partition directly with an ALTER TABLE statement.
Unless otherwise documented, the remaining clauses of partition_attributes have the same behavior they have when you are creating a partitioned table. Refer to the CREATE TABLE table_partitioning_clauses for more information.
See Also:
"Modifying Table Partitions: Examples"Use this clause to modify the characteristics of a range partition.
add_range_subpartition This clause is valid only for range-range composite partitions. It lets you add a range subpartition to partition.
add_hash_subpartition This clause is valid only for range-hash composite partitions. The add_hash_subpartition clause lets you add a hash subpartition to partition. Oracle Database populates the new subpartition with rows rehashed from the other subpartition(s) of partition as determined by the hash function. For optimal load balancing, the total number of subpartitions should be a power of 2.
In the partitioning_storage_clause, the only clause you can specify for subpartitions is the TABLESPACE clause. If you do not specify TABLESPACE, then the new subpartition will reside in the default tablespace of partition.
Oracle Database adds local index partitions corresponding to the selected partition.
Oracle Database marks UNUSABLE the local index partitions corresponding to the added partitions. The database invalidates any indexes on heap-organized tables. You can update these indexes during this operation using the update_index_clauses.
add_list_subpartition This clause is valid only for range-list and list-list composite partitions. It lets you add a list subpartition to partition, and only if you have not already created a DEFAULT subpartition.
The list_values_clause is required in this operation, and the values you specify in the list_values_clause cannot exist in any other subpartition of partition. However, these values can duplicate values found in subpartitions of other partitions.
In the partitioning_storage_clause, the only clauses you can specify for subpartitions are the TABLESPACE clause and table compression.
Oracle Database also adds a subpartition with the same value list to all local index partitions of the table. The status of existing local and global index partitions of table are not affected.
Restriction on Adding List Subpartitions You cannot specify this clause if you have already created a DEFAULT subpartition for this partition. Instead you must split the DEFAULT partition using the split_list_subpartition clause.
COALESCE SUBPARTITION COALESCE SUBPARTITION applies only to hash subpartitions. Use the COALESCE SUBPARTITION clause if you want Oracle Database to select the last hash subpartition, distribute its contents into one or more remaining subpartitions (determined by the hash function), and then drop the last subpartition.
Oracle Database drops local index partitions corresponding to the selected partition.
Oracle Database marks UNUSABLE the local index partitions corresponding to one or more absorbing partitions. The database invalidates any global indexes on heap-organized tables. You can update these indexes during this operation using the update_index_clauses.
When modifying a hash partition, in the partition_attributes clause, you can specify only the allocate_extent_clause and deallocate_unused_clause. All other attributes of the partition are inherited from the table-level defaults except TABLESPACE, which stays the same as it was at create time.
Clauses available to you when modifying a list partition have the same semantics as when you are modifying a range partition. When modifying a list partition, the following additional clauses are available:
ADD | DROP VALUES Clauses These clauses are valid only when you are modifying composite partitions. Local and global indexes on the table are not affected by either of these clauses.
Use the ADD VALUES clause to extend the partition_key_value list of partition to include additional values. The added partition values must comply with all rules and restrictions listed in the CREATE TABLE clause list_partitions .
Use the DROP VALUES clause to reduce the partition_key_value list of partition by eliminating one or more partition_key_value. When you specify this clause, Oracle Database checks to ensure that no rows with this value exist. If such rows do exist, then Oracle Database returns an error.
Note:
ADD VALUES and DROP VALUES operations on a table with a DEFAULT list partition are enhanced if you have defined a local prefixed index on the table.Restrictions on Adding and Dropping List Values Adding and dropping list values are subject to the following restrictions:
You cannot add values to or drop values from a DEFAULT list partition.
If table contains a DEFAULT partition and you attempt to add values to a nondefault partition, then Oracle Database will check that the values being added do not already exist in the DEFAULT partition. If the values do exist in the DEFAULT partition, then Oracle Database returns an error.
This clause applies only to composite-partitioned tables. Its subclauses let you modify the characteristics of an individual range, list, or hash subpartition.
The shrink_clause lets you compact an individual subpartition segment. Refer to shrink_clause for additional information on this clause.
You can also specify how Oracle Database should handle local indexes that become unusable as a result of the modification to the partition. See "UNUSABLE LOCAL INDEXES Clauses".
Restriction on Modifying Hash Subpartitions The only modify_LOB_parameters you can specify for subpartition are the allocate_extent_clause and deallocate_unused_clause.
ADD | DROP VALUES Clauses These clauses are valid only when you are modifying list subpartitions. Local and global indexes on the table are not affected by either of these clauses.
Use the ADD VALUES clause to extend the subpartition_key_value list of subpartition to include additional values. The added partition values must comply with all rules and restrictions listed in the CREATE TABLE clause list_partitions .
Use the DROP VALUES clause to reduce the subpartition_key_value list of subpartition by eliminating one or more subpartition_key_value. When you specify this clause, Oracle Database checks to ensure that no rows with this value exist. If such rows do exist, then Oracle Database returns an error.
You can also specify how Oracle Database should handle local indexes that become unusable as a result of the modification to the partition. See "UNUSABLE LOCAL INDEXES Clauses".
Restriction on Modifying List Subpartitions The only modify_LOB_parameters you can specify for subpartition are the allocate_extent_clause and deallocate_unused_clause.
Use the move_table_partition clause to move partition to another segment. You can move partition data to another tablespace, recluster data to reduce fragmentation, or change create-time physical attributes.
If the table contains LOB columns, then you can use the LOB_storage_clause to move the LOB data and LOB index segments associated with this partition. Only the LOBs named are affected. If you do not specify the LOB_storage_clause for a particular LOB column, then its LOB data and LOB index segments are not moved.
If the table contains nested table columns, then you can use the nested_table_col_properties clause of the table_partition_description to move the nested table segments associated with this partition. Only the nested table items named are affected. If you do not specify the nested_table_col_properties clause of the table_partition_description for a particular nested table column, then its segments are not moved.
Oracle Database moves local index partitions corresponding to the specified partition. If the moved partitions are not empty, then the database marks them UNUSABLE. The database invalidates global indexes on heap-organized tables. You can update these indexes during this operation using the update_index_clauses.
When you move a LOB data segment, Oracle Database drops the old data segment and corresponding index segment and creates new segments even if you do not specify a new tablespace.
The move operation obtains its parallel attribute from the parallel_clause, if specified. When it is not specified, the default parallel attributes of the table, if any, are used. If neither is specified, then Oracle Database performs the move serially.
Specifying the parallel_clause in MOVE PARTITION does not change the default parallel attributes of table.
Note:
For index-organized tables, Oracle Database uses the address of the primary key, as well as its value, to construct logical rowids. The logical rowids are stored in the secondary index of the table. If you move a partition of an index-organized table, then the address portion of the rowids will change, which can hamper performance. To ensure optimal performance, rebuild the secondary index(es) on the moved partition to update the rowids.See Also:
"Moving Table Partitions: Example"MAPPING TABLE The MAPPING TABLE clause is relevant only for an index-organized table that already has a mapping table defined for it. Oracle Database moves the mapping table along with the moved index-organized table partition. The mapping table partition inherits the physical attributes of the moved index-organized table partition. This is the only way you can change the attributes of the mapping table partition. If you omit this clause, then the mapping table partition retains its original attributes.
Oracle Database marks UNUSABLE all corresponding bitmap index partitions.
Refer to the mapping_table_clauses (in CREATE TABLE) for more information on this clause.
Restrictions on Moving Table Partitions Moving table partitions is subject to the following restrictions:
If partition is a hash partition, then the only attribute you can specify in this clause is TABLESPACE.
You cannot specify this clause for a partition containing subpartitions. However, you can move subpartitions using the move_table_subpartition clause.
Use the move_table_subpartition clause to move subpartition to another segment. If you do not specify TABLESPACE, then the subpartition remains in the same tablespace.
If the subpartition is not empty, then Oracle Database marks UNUSABLE all local index subpartitions corresponding to the subpartition being moved. You can update all indexes on heap-organized tables during this operation using the update_index_clauses.
If the table contains LOB columns, then you can use the LOB_storage_clause to move the LOB data and LOB index segments associated with this subpartition. Only the LOBs specified are affected. If you do not specify the LOB_storage_clause for a particular LOB column, then its LOB data and LOB index segments are not moved.
When you move a LOB data segment, Oracle Database drops the old data segment and corresponding index segment and creates new segments even if you do not specify a new tablespace.
Restriction on Moving Table Subpartitions In the subpartition descriptions, the only clauses of the partitioning_storage_clause you can specify are the TABLESPACE clause and table_compression.
Use the add_table_partition clause to add a hash, range, list, or system partition to table.
Oracle Database adds to any local index defined on table a new partition with the same name as that of the base table partition. If the index already has a partition with such a name, then Oracle Database generates a partition name of the form SYS_Pn.
If table is index organized, then Oracle Database adds a partition to any mapping table and overflow area defined on the table as well.
If table is the parent table of a reference-partitioned table, then you can use the dependent_tables_clause to propagate the partition maintenance operation you are specifying in this statement to all the reference-partitioned child tables.
For composite-partitioned tables, Oracle Database adds a new index partition with the same subpartition descriptions to all local indexes defined on table. Global indexes defined on table are not affected.
The add_range_partition_clause lets you add a new range partition to the high end of a range-partitioned or composite range-partitioned table (after the last existing partition).
If a domain index is defined on table, then the index must not be marked IN_PROGRESS or FAILED.
Restrictions on Adding Range Partitions Adding range partitions is subject to the following restrictions:
If the upper partition bound of each partitioning key in the existing high partition is MAXVALUE, then you cannot add a partition to the table. Instead, use the split_table_partition clause to add a partition at the beginning or the middle of the table.
The key_compression and OVERFLOW clauses are valid only for a partitioned index-organized table. You can specify OVERFLOW only if the partitioned table already has an overflow segment. You can specify key compression only if key compression is enabled at the table level.
You cannot specify the PCTUSED parameter for the index segment of an index-organized table.
range_values_clause Specify the upper bound for the new partition. The value_list is a comma-delimited, ordered list of literal values corresponding to the partitioning key columns. The value_list must collate greater than the partition bound for the highest existing partition in the table.
table_partition_description Use this clause specify any create-time physical attributes for the new partition. If the table contains LOB columns, then you can also specify partition-level attributes for one or more LOB items.
Subpartition Descriptions These clauses are valid only for composite-partitioned tables. Use the range_subpartition_desc, list_subpartition_desc, or hash_subpartition_desc, as appropriate, if you want to specify subpartitions for the new partition. This clause overrides any subpartition descriptions defined in subpartition_template at the table level.
The add_hash_partition_clause lets you add a new hash partition to the high end of a hash-partitioned table. Oracle Database populates the new partition with rows rehashed from other partitions of table as determined by the hash function. For optimal load balancing, the total number of partitions should be a power of 2.
You can specify a name for the partition, and optionally a tablespace where it should be stored. If you do not specify a name, then the database assigns a partition name of the form SYS_Pn. If you do not specify TABLESPACE, then the new partition is stored in the default tablespace of the table. Other attributes are always inherited from table-level defaults.
If this operation causes data to be rehashed among partitions, then the database marks UNUSABLE any corresponding local index partitions. You can update all indexes on heap-organized tables during this operation using the update_index_clauses.
Use the parallel_clause to specify whether to parallelize the creation of the new partition.
See Also:
CREATE TABLE and Oracle Database VLDB and Partitioning Guide for more information on hash partitioningThe add_list_partition_clause lets you add a new partition to table using a new set of partition values. You can specify any create-time physical attributes for the new partition. If the table contains LOB columns, then you can also specify partition-level attributes for one or more LOB items.
Restrictions on Adding List Partitions You cannot add a list partition if you have already defined a DEFAULT partition for the table. Instead, you must use the split_table_partition clause to split the DEFAULT partition.
See Also:
list_partitions of CREATE TABLE for more information and restrictions on list partitions
Use this clause to add a partition to a system-partitioned table. Oracle Database adds a corresponding index partition to all local indexes defined on the table.
The BEFORE clause lets you specify where the new partition should be added in relation to existing partitions. You cannot split a system partition. Therefore, this clause is useful if you want to divide the contents of one existing partition among multiple new partitions. If you omit this clause, then the database adds the new partition after the existing partitions.
The table_partition_description lets you specify partition-level attributes of the new partition. The values of any unspecified attributes are inherited from the table-level values.
Restriction on Adding System Partitions You cannot specify the OVERFLOW clause when adding a system partition.
COALESCE applies only to hash partitions. Use the coalesce_table_partition clause to indicate that Oracle Database should select the last hash partition, distribute its contents into one or more remaining partitions as determined by the hash function, and then drop the last partition.
Oracle Database drops local index partitions corresponding to the selected partition. The database marks UNUSABLE the local index partitions corresponding to one or more absorbing partitions. The database invalidates any indexes on heap-organized tables. You can update all indexes during this operation using the update_index_clauses.
Restriction on Coalescing Table Partitions If you update global indexes using the update_all_indexes_clause, then you can specify only the keywords UPDATE INDEXES, not the subclause.
The drop_table_partition clause removes the partition identified by partition_extended_name, and the data in that partition, from a partitioned table. If you want to drop a partition but keep its data in the table, then you must merge the partition into one of the adjacent partitions.
See Also:
merge_table_partitionsIf table has LOB columns, then Oracle Database also drops the LOB data and LOB index partitions and any subpartitions corresponding to partition.
If table has equipartitioned nested table columns, then Oracle Database also drops the nested table partitions corresponding to the table partition being dropped.
If table is index organized and has a mapping table defined on it, then the database drops the corresponding mapping table partition as well.
Oracle Database drops local index partitions and subpartitions corresponding to the dropped partition, even if they are marked UNUSABLE.
You can update indexes on table during this operation using the update_index_clauses. If you specify the parallel_clause with the update_index_clauses, then the database parallelizes the index update, not the drop operation.
If you drop a range partition and later insert a row that would have belonged to the dropped partition, then the database stores the row in the next higher partition. However, if that partition is the highest partition, then the insert will fail, because the range of values represented by the dropped partition is no longer valid for the table.
Restrictions on Dropping Table Partitions Dropping table partitions is subject to the following restrictions:
You cannot drop a partition of a hash-partitioned table. Instead, use the coalesce_table_partition clause.
If table contains only one partition, then you cannot drop that partition. Instead, drop the table.
If you update global indexes using the update_index_clauses, then you can specify only the UPDATE INDEXES keywords but not the subclause.
See Also:
"Dropping a Table Partition: Example"Use this clause to drop a range or list subpartition from a range, list, or hash composite-partitioned table. Oracle Database deletes any rows in the dropped subpartition.
Oracle Database drops the corresponding subpartition of any local index. Other index subpartitions are not affected. Any global indexes are marked UNUSABLE unless you specify the update_global_index_clause or update_all_indexes_clause.
Restrictions on Dropping Table Subpartitions Dropping table subpartitions is subject to the following restrictions:
You cannot drop a hash subpartition. Instead use the MODIFY PARTITION ... COALESCE SUBPARTITION syntax.
If a partition contains only one subpartition, then you cannot drop that subpartition. Instead, use the drop_table_partition clause.
If you update the global indexes, then you cannot specify the optional subclause of the update_all_indexes_clause.
Use the rename_partition_subpart clause to rename a table partition or subpartition to new_name. For both partitions and subpartitions, new_name must be different from all existing partitions and subpartitions of the same table.
If table is index organized, then Oracle Database assigns the same name to the corresponding primary key index partition as well as to any existing overflow partitions and mapping table partitions.
See Also:
"Renaming Table Partitions: Examples"Specify TRUNCATE PARTITION to remove all rows from the partition identified by partition_extended_name or, if the table is composite partitioned, all rows from the subpartitions of that partition. Specify TRUNCATE SUBPARTITION to remove all rows from an individual subpartition. If table is index organized, then Oracle Database also truncates any corresponding mapping table partitions and overflow area partitions.
If the partition or subpartition to be truncated contains data, then you must first disable any referential integrity constraints on the table. Alternatively, you can delete the rows and then truncate the partition.
If table contains any LOB columns, then the LOB data and LOB index segments for this partition are also truncated. If table is composite partitioned, then the LOB data and LOB index segments for the subpartitions of the partition are truncated.
If table contains any equipartitioned nested tables, then you cannot truncate the parent partition unless its corresponding nested table partition is empty.
If a domain index is defined on table, then the index must not be marked IN_PROGRESS or FAILED, and the index partition corresponding to the table partition being truncated must not be marked IN_PROGRESS.
For each partition or subpartition truncated, Oracle Database also truncates corresponding local index partitions and subpartitions. If those index partitions or subpartitions are marked UNUSABLE, then the database truncates them and resets the UNUSABLE marker to VALID.
You can update global indexes on table during this operation using the update_global_index_clause or the update_all_indexes_clause. If you specify the parallel_clause with one of these clauses, then the database parallelizes the index update, not the truncate operation.
DROP STORAGE Specify DROP STORAGE to deallocate all space from the deleted rows, except the space allocated by the MINEXTENTS parameter. This space can subsequently be used by other objects in the tablespace.
DROP ALL STORAGE Specify DROP ALL STORAGE to deallocate all space from the deleted rows, including the space allocated by the MINEXTENTS parameter. All segments for the partition or subpartition, as well as all segments for its dependent objects, will be deallocated.
Restrictions on DROP ALL STORAGE This clause is subject to the same restrictions as described in "Restrictions on Deferred Segment Creation".
Note:
TheDROP ALL STORAGE clause is available starting with Oracle Database 11g Release 2 (11.2.0.2).REUSE STORAGE Specify REUSE STORAGE to keep space from the deleted rows allocated to the partition or subpartition. The space is subsequently available only for inserts and updates to the same partition or subpartition.
See Also:
"Truncating Table Partitions: Example"Restriction on Truncating Table Partitions and Subpartitions If you update global indexes using the update_all_indexes_clause, then you can specify only the UPDATE INDEXES keywords, not the subclause.
The split_table_partition clause lets you create, from the partition identified by partition_extended_name, two new partitions, each with a new segment, new physical attributes, and new initial extents. The segment associated with the current partition is discarded.
The new partitions inherit all unspecified physical attributes from the current partition.
Note:
Oracle Database can optimize and speed upSPLIT PARTITION and SPLIT SUBPARTITION operations if specific conditions are met. Refer to Oracle Database VLDB and Partitioning Guide for information on optimizing these operations.If you split a DEFAULT list partition, then the first of the resulting partitions will have the split values, and the second resulting partition will have the DEFAULT value.
If table is index organized, then Oracle Database splits any corresponding mapping table partition and places it in the same tablespace as the parent index-organized table partition. The database also splits any corresponding overflow area, and you can use the OVERFLOW clause to specify segment attributes for the new overflow areas.
If table contains LOB columns, then you can use the LOB_storage_clause to specify separate LOB storage attributes for the LOB data segments resulting from the split. The database drops the LOB data and LOB index segments of the current partition and creates new segments for each LOB column, for each partition, even if you do not specify a new tablespace.
If table contains nested table columns, then you can use the split_nested_table_part clause to specify the storage table names and segment attributes of the nested table segments resulting from the split. The database drops the nested table segments of the current partition and creates new segments for each nested table column, for each partition. This clause allows for multiple nested table columns in the parent table as well as multilevel nested table columns.
Oracle Database splits the corresponding local index partition, even if it is marked UNUSABLE. The database marks UNUSABLE, and you must rebuild the local index partitions corresponding to the split partitions. The new index partitions inherit their attributes from the partition being split. The database stores the new index partitions in the default tablespace of the index partition being split. If that index partition has no default tablespace, then the database uses the tablespace of the new underlying table partitions.
AT Clause The AT clause applies only to range partitions. Specify the new noninclusive upper bound for the first of the two new partitions. The value list must compare less than the original partition bound for the current partition and greater than the partition bound for the next lowest partition (if there is one).
VALUES Clause The VALUES clause applies only to list partitions. Specify the partition values you want to include in the first of the two new partitions. Oracle Database creates the first new partition using the partition value list you specify and creates the second new partition using the remaining partition values from the current partition. Therefore, the value list cannot contain all of the partition values of the current partition, nor can it contain any partition values that do not already exist for the current partition.
INTO Clause The INTO clause lets you describe the two partitions resulting from the split. In range_partition_desc or list_partition_desc, as appropriate, the keyword PARTITION is required even if you do not specify the optional names and physical attributes of the two partitions resulting from the split. If you do not specify new partition names, then Oracle Database assigns names of the form SYS_Pn. Any attributes you do not specify are inherited from the current partition.
For range-hash composite-partitioned tables, if you specify subpartitioning for the new partitions, then you can specify only TABLESPACE and table compression for the subpartitions. All other attributes are inherited from the current partition. If you do not specify subpartitioning for the new partitions, then their tablespace is also inherited from the current partition.
For range-list and list-list composite-partitioned tables, you cannot specify subpartitions for the new partitions at all. The list subpartitions of the split partition inherit the number of subpartitions and value lists from the current partition.
For all composite-partitioned tables for which you do not specify subpartition names for the newly created subpartitions, the newly created subpartitions inherit their names from the parent partition as follows:
For those subpartitions in the parent partition with names of the form partition_name underscore (_) subpartition_name (for example, P1_SUBP1), Oracle Database generates corresponding names in the newly created subpartitions using the new partition names (for example P1A_SUB1 and P1B_SUB1).
For those subpartitions in the parent partition with names of any other form, Oracle Database generates subpartition names of the form SYS_SUBPn.
Oracle Database splits the corresponding partition in each local index defined on table, even if the index is marked UNUSABLE.
Oracle Database invalidates any indexes on heap-organized tables. You can update these indexes during this operation using the update_index_clauses.
If table is the parent table of a reference-partitioned table, then you can use the dependent_tables_clause to propagate the partition maintenance operation you are specifying in this statement to all the reference-partitioned child tables.
The parallel_clause lets you parallelize the split operation but does not change the default parallel attributes of the table.
Restrictions on Splitting Table Partitions You cannot specify this clause for a hash partition.
Use this clause to split a list subpartition into two separate subpartitions with nonoverlapping value lists.
Note:
Oracle Database can optimize and speed upSPLIT PARTITION and SPLIT SUBPARTITION operations if specific conditions are met. Refer to Oracle Database VLDB and Partitioning Guide for information on optimizing these operations.AT Clause The AT clause is valid only for range subpartitions. Specify the new noninclusive upper bound for the first of the two new subpartitions. The value list must compare less than the original subpartition bound for the subpartition identified by subpartition_extended_name and greater than the partition bound for the next lowest subpartition (if there is one).
VALUES Clause The VALUES clause is valid only for list subpartitions. Specify the subpartition values you want to include in the first of the two new subpartitions. You can specify NULL if you have not already specified NULL for another subpartition in the same partition. Oracle Database creates the first new subpartition using the subpartition value list you specify and creates the second new partition using the remaining partition values from the current subpartition. Therefore, the value list cannot contain all of the partition values of the current subpartition, nor can it contain any partition values that do not already exist for the current subpartition.
INTO Clause For both range and list subpartitions, the INTO clause lets you describe the two subpartitions resulting from the split. In range_subpartition_desc or list_subpartition_desc, as appropriate, the keyword SUBPARTITION is required even if you do not specify the optional names and attributes of the two new subpartitions. Any attributes you do not specify are inherited from the current subpartition.
Oracle Database splits any corresponding local subpartition index, even if it is marked UNUSABLE. The new index subpartitions inherit the names of the new table subpartitions unless those names are already held by index subpartitions. In that case, the database assigns new index subpartition names of the form SYS_SUBPn. The new index subpartitions inherit physical attributes from the parent subpartition. However, if the parent subpartition does not have a default TABLESPACE attribute, then the new subpartitions inherit the tablespace of the corresponding new table subpartitions.
Oracle Database invalidates indexes on heap-organized tables. You can update these indexes by using the update_index_clauses.
Restrictions on Splitting Table Subpartitions Splitting table subpartitions is subject to the following restrictions:
You cannot specify this clause for a hash subpartition.
In subpartition descriptions, the only clauses of partitioning_storage_clause you can specify are TABLESPACE and table compression.
The merge_table_partitions clause lets you merge the contents of two range partitions, two list partitions, or two system partitions of table into one new partition and then drop the original two partitions. This clause is not valid for hash partitions. Use the coalesce_table_partition clause instead.
For each partition, use partition to specify a partition name or the FOR clause to specify a partition without using its name. See "References to Partitioned Tables and Indexes" for more information on the FOR clause.
The two partitions to be merged must be adjacent if they are range partitions. List partitions and system partitions need not be adjacent in order to be merged.
When you merge two range partitions, the new partition inherits the partition bound of the higher of the two original partitions.
When you merge two list partitions, the resulting partition value list is the union of the set of the two partition values lists of the partitions being merged. If you merge a DEFAULT list partition with another list partition, then the resulting partition will be the DEFAULT partition and will have the DEFAULT value.
When you merge two composite range partitions or two composite list partitions, range-list or list-list composite partitions, you cannot specify subpartition descriptions. Oracle Database obtains the subpartitioning information from the subpartition template. If you have not specified a subpartition template, then the database creates one MAXVALUE subpartition from range subpartitions or one DEFAULT subpartition from list subpartitions.
Any attributes not specified in the segment_attributes_clause are inherited from table-level defaults.
Oracle Database drops local index partitions corresponding to the selected partitions and marks UNUSABLE the local index partition corresponding to merged partition. The database also marks UNUSABLE any global indexes on heap-organized tables. You can update all these indexes during this operation using the update_index_clauses.
If table is the parent table of a reference-partitioned table, then you can use the dependent_tables_clause to propagate the partition maintenance operation you are specifying in this statement to all the reference-partitioned child tables.
See Also:
"Merging Two Table Partitions: Example" and "Working with Default List Partitions: Example"The merge_table_subpartitions clause lets you merge the contents of two range or list subpartitions of table into one new subpartition and then drop the original two subpartitions. This clause is not valid for hash subpartitions. Use the coalesce_hash_subpartition clause instead.
For each subpartition, use subpartition to specify a subpartition name or the FOR clause to specify a subpartition without using its name. See "References to Partitioned Tables and Indexes" for more information on the FOR clause.
The two subpartitions to be merged must belong to the same partition. If they are range subpartitions, then they must be adjacent. If they are list subpartitions, then they need not be adjacent. The data in the resulting subpartition consists of the combined data from the merged subpartitions.
If you specify the INTO clause, then in the range_subpartition_desc or list_subpartition_desc you cannot specify the range_values_clause or list_values_clause, respectively. Further, the only clauses you can specify in the partitioning_storage_clause are the TABLESPACE clause and table_compression.
Any attributes you do not specify explicitly for the new subpartition are inherited from partition-level values. However, if you reuse one of the subpartition names for the new subpartition, then the new subpartition inherits values from the subpartition whose name is being reused rather than from partition-level default values.
Oracle Database merges corresponding local index subpartitions and marks the resulting index subpartition UNUSABLE. The database also marks UNUSABLE both partitioned and nonpartitioned global indexes on heap-organized tables. You can update all indexes during this operation using the update_index_clauses.
Use the EXCHANGE PARTITION or EXCHANGE SUBPARTITION clause to exchange the data and index segments of:
One nonpartitioned table with:
one range, list, or hash partition
one range, list, or hash subpartition
One range-partitioned table with the range subpartitions of a range-range or list-range composite-partitioned table partition
One hash-partitioned table with the hash subpartitions of a range-hash or list-hash composite-partitioned table partition
One list-partitioned table with the list subpartitions of a range-list or hash-list composite-partitioned table partition
In all cases, the structure of the table and the partition or subpartition being exchanged, including their partitioning keys, must be identical. In the case of list partitions and subpartitions, the corresponding value lists must also match.
This clause facilitates high-speed data loading when used with transportable tablespaces.
See Also:
Oracle Database Administrator's Guide for information on transportable tablespacesIf table contains LOB columns, then for each LOB column Oracle Database exchanges LOB data and LOB index partition or subpartition segments with corresponding LOB data and LOB index segments of table.
If table has nested table columns, then for each such column Oracle Database exchanges nested table partition segments with corresponding nested table segments of the nonpartitioned table.
All of the segment attributes of the two objects (including tablespace and logging) are also exchanged.
Existing statistics for the table being exchanged into the partitioned table will be exchanged. However, the global statistics for the partitioned table will not be altered. Use the DBMS_STATS.GATHER_TABLE_STATS procedure to re-create global statistics. You can set the GRANULARITY attribute equal to 'APPROX_GLOBAL AND PARTITION' to speed up the process and aggregate new global statistics based on the existing partition statistics. See Oracle Database PL/SQL Packages and Types Reference for more information on this packaged procedure.
Oracle Database invalidates any global indexes on the objects being exchanged. You can update the global indexes on the table whose partition is being exchanged by using either the update_global_index_clause or the update_all_indexes_clause clause. For the update_all_indexes_clause, you can specify only the keywords UPDATE INDEXES, not the subclause. Global indexes on the table being exchanged remain invalidated. If you specify the parallel_clause with either of these clauses, then the database parallelizes the index update, not the exchange operation.
WITH TABLE Specify the table with which the partition or subpartition will be exchanged. If you omit schema, then Oracle Database assumes that table is in your own schema.
INCLUDING | EXCLUDING INDEXES Specify INCLUDING INDEXES if you want local index partitions or subpartitions to be exchanged with the corresponding table index (for a nonpartitioned table) or local indexes (for a hash-partitioned table). Specify EXCLUDING INDEXES if you want all index partitions or subpartitions corresponding to the partition and all the regular indexes and index partitions on the exchanged table to be marked UNUSABLE. If you omit this clause, then the default is EXCLUDING INDEXES.
WITH | WITHOUT VALIDATION Specify WITH VALIDATION if you want Oracle Database to return an error if any rows in the exchanged table do not map into partitions or subpartitions being exchanged. Specify WITHOUT VALIDATION if you do not want Oracle Database to check the proper mapping of rows in the exchanged table. If you omit this clause, then the default is WITH VALIDATION.
exceptions_clause See "Handling Constraint Exceptions" for information on this clause. In the context of exchanging partitions, this clause is valid only when if the partitioned table has been defined with a UNIQUE constraint, and that constraint must be in DISABLE VALIDATE state. This clause is valid only for exchanging partition, not subpartitions.
See Also:
The DBMS_IOT package in Oracle Database PL/SQL Packages and Types Reference for information on the SQL scripts
Oracle Database Administrator's Guide for information on eliminating migrated and chained rows
constraint for more information on constraint checking and "Creating an Exceptions Table for Index-Organized Tables: Example"
Notes on Exchanging Partitions and Subpartitions The following notes apply when exchanging partitions and subpartitions:
Both tables involved in the exchange must have the same primary key, and no validated foreign keys can be referencing either of the tables unless the referenced table is empty.
When exchanging partitioned index-organized tables:
The source and target table or partition must have their primary key set on the same columns, in the same order.
If key compression is enabled, then it must be enabled for both the source and the target, and with the same prefix length.
Both the source and target must be index organized.
Both the source and target must have overflow segments, or neither can have overflow segments. Also, both the source and target must have mapping tables, or neither can have a mapping table.
Both the source and target must have identical storage attributes for any LOB columns.
See Also:
"Exchanging Table Partitions: Example"This clause is valid only when you are altering the parent table of a reference-partitioned table. The clause lets you specify attributes of partitions that are created by the operation for reference-partitioned child tables of the parent table.
If the parent table is not composite partitioned, then specify one or more child tables, and for each child table specify one partition_spec for each partition created in the parent table.
If the parent table is composite, then specify one or more child tables, and for each child table specify one partition_spec for each subpartition created in the parent table.
See Also:
TheCREATE TABLE clause reference_partitioning for information on creating reference-partitioned tables and Oracle Database VLDB and Partitioning Guide for information on partitioning by reference in generalUNUSABLE LOCAL INDEXES Clauses
These two clauses modify the attributes of local index partitions and index subpartitions corresponding to partition, depending on whether you are modifying a partition or subpartition.
UNUSABLE LOCAL INDEXES marks UNUSABLE the local index partition or index subpartition associated with partition.
REBUILD UNUSABLE LOCAL INDEXES rebuilds the unusable local index partition or index subpartition associated with partition.
Restrictions on UNUSABLE LOCAL INDEXES This clause is subject to the following restrictions:
You cannot specify this clause with any other clauses of the modify_table_partition clause.
You cannot specify this clause in the modify_table_partition clause for a partition that has subpartitions. However, you can specify this clause in the modify_table_subpartition clause.
Use the update_index_clauses to update the indexes on table as part of the table partitioning operation. When you perform DDL on a table partition, if an index is defined on table, then Oracle Database invalidates the entire index, not just the partitions undergoing DDL. This clause lets you update the index partition you are changing during the DDL operation, eliminating the need to rebuild the index after the DDL.
The update_index_clauses are not needed, and are not valid, for partitioned index-organized tables. Index-organized tables are primary key based, so Oracle can keep global indexes USABLE during operations that move data but do not change its value.
Use this clause to update global indexes on table.
Use this clause to update all indexes on table.
update_index_partition This clause is valid only for operations on table partitions and affects only local indexes.
The index_partition_description lets you specify physical attributes, tablespace storage, and logging for each partition of each local index. If you specify only the PARTITION keyword, then Oracle Database updates the index partition as follows:
For operations on a single table partition (such as MOVE PARTITION and SPLIT PARTITION), the corresponding index partition inherits the attributes of the affected index table partition, Oracle Database does not generate names for new index partitions, so any new index partitions resulting from this operation inherit their names from the corresponding new table partition.
For MERGE PARTITION operations, the resulting local index partition inherits its name from the resulting table partition and inherits its attributes from the local index.
For a domain index, you can use the PARAMETERS clause to specify the parameter string that is passed uninterpreted to the appropriate ODCI indextype routine. The PARAMETERS clause is valid only for domain indexes, and is the only part of the index_partition_description you can specify for a domain index.
For more information on the UNUSABLE clause, refer to ALTER INDEX ... UNUSABLE.
See Also:
Oracle Database Data Cartridge Developer's Guide for more information on domain indexesFor a composite-partitioned index, the index_subpartition_clause lets you specify tablespace storage for each subpartition. Refer to the index_subpartition_clause (in CREATE INDEX) for more information on this component of the update_index_partition clause.
update_index_subpartition This clause is valid only for operations on subpartitions of composite-partitioned tables and affects only local indexes on composite-partitioned tables. It lets you specify tablespace storage for one or more subpartitions.
Restriction on Updating All Indexes You cannot specify this clause for index-organized tables.
Use this clause to update only global indexes on table. Oracle Database marks UNUSABLE all local indexes on table.
UPDATE GLOBAL INDEXES Specify UPDATE GLOBAL INDEXES to update the global indexes defined on table.
Restriction on Updating Global Indexes If the global index is a global domain index defined on a LOB column, then Oracle Database marks the domain index UNUSABLE instead of updating it.
INVALIDATE GLOBAL INDEXES Specify INVALIDATE GLOBAL INDEXES to invalidate the global indexes defined on table.
If you specify neither, then Oracle Database invalidates the global indexes.
Restrictions on Invalidating Global Indexes This clause is supported only for global indexes. It is not supported for index-organized tables. In addition, this clause updates only indexes that are USABLE and VALID. UNUSABLE indexes are left unusable, and INVALID global indexes are ignored.
The parallel_clause lets you change the default degree of parallelism for queries and DML on the table.
For complete information on this clause, refer to parallel_clause in the documentation on CREATE TABLE.
Restrictions on Changing Table Parallelization Changing parallelization is subject to the following restrictions:
If table contains any columns of LOB or user-defined object type, then subsequent INSERT, UPDATE, and DELETE operations on table are executed serially without notification. Subsequent queries, however, are executed in parallel.
If you specify the parallel_clause in conjunction with the move_table_clause, then the parallelism applies only to the move, not to subsequent DML and query operations on the table.
The move_table_clause lets you relocate data of a nonpartitioned table or of a partition of a partitioned table into a new segment, optionally in a different tablespace, and optionally modify any of its storage attributes.
You can also move any LOB data segments associated with the table or partition using the LOB_storage_clause and varray_col_properties clause. LOB items not specified in this clause are not moved.
If you move the table to a different tablespace and the COMPATIBLE parameter is set to 10.0 or higher, then Oracle Database leaves the storage table of any nested table columns in the tablespace in which it was created. If COMPATIBLE is set to any value less than 10.0, then the database silently moves the storage table to the new tablespace along with the table.
ONLINE Clause This clause is valid only for top-level index-organized tables and for nested table storage tables that are index organized. Specify ONLINE if you want DML operations on the index-organized table to be allowed during rebuilding of the primary key index of the table.
Restrictions on Moving Tables Online Moving tables online is subject to the following restrictions:
You cannot combine this clause with any other clause in the same statement.
You cannot specify this clause for a partitioned index-organized table.
Parallel DML and direct path INSERT operations require an exclusive lock on the table. Therefore, these operations are not supported concurrently with an ongoing online table MOVE, due to conflicting locks.
You cannot specify this clause if the index-organized table contains any LOB, VARRAY, Oracle-supplied type, or user-defined object type columns.
For an index-organized table, the index_org_table_clause of the move_table_clause lets you additionally specify overflow segment attributes. The move_table_clause rebuilds the primary key index of the index-organized table. The overflow data segment is not rebuilt unless the OVERFLOW keyword is explicitly stated, with two exceptions:
If you alter the values of PCTTHRESHOLD or the INCLUDING column as part of this ALTER TABLE statement, then the overflow data segment is rebuilt.
If you explicitly move any of out-of-line columns (LOBs, varrays, nested table columns) in the index-organized table, then the overflow data segment is also rebuilt.
The index and data segments of LOB columns are not rebuilt unless you specify the LOB columns explicitly as part of this ALTER TABLE statement.
mapping_table_clause Specify MAPPING TABLE if you want Oracle Database to create a mapping table if one does not already exist. If it does exist, then the database moves the mapping table along with the index-organized table, and marks any bitmapped indexes UNUSABLE. The new mapping table is created in the same tablespace as the parent table.
Specify NOMAPPING to instruct the database to drop an existing mapping table.
Refer to mapping_table_clauses (in CREATE TABLE) for more information on this clause.
Restriction on Mapping Tables You cannot specify NOMAPPING if any bitmapped indexes have been defined on table.
key_compression Use the key_compression clause to enable or disable key compression in an index-organized table.
COMPRESS enables key compression, which eliminates repeated occurrence 1of 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 disables key compression in index-organized tables. This is the default.
TABLESPACE tablespace Specify the tablespace into which the rebuilt index-organized table is to be stored.
LOB_storage_clause Use this clause to move a LOB segment to a different tablespace. You cannot use this clause to move a LOB segment if the table contains a LONG column. Instead, you must either convert the LONG column to a LOB, or you must export the table, re-create the table specifying the desired tablespace storage for the LOB column, and re-import the table data.
Restrictions on Moving Tables Moving tables is subject to the following restrictions:
If you specify MOVE, then it must be the first clause in the ALTER TABLE statement, and the only clauses outside this clause that are allowed are the physical_attributes_clause, the parallel_clause, and the LOB_storage_clause.
You cannot move a table containing a LONG or LONG RAW column.
You cannot MOVE an entire partitioned table (either heap or index organized). You must move individual partitions or subpartitions.
Notes Regarding LOBs:
For any LOB columns you specify in amove_table_clause:
Oracle Database drops the old LOB data segment and corresponding index segment and creates new segments, even if you do not specify a new tablespace.
If the LOB index in table resided in a different tablespace from the LOB data, then Oracle Database collocates the LOB index in the same tablespace with the LOB data after the move.
The enable_disable_clause lets you specify whether and how Oracle Database should apply an integrity constraint. The DROP and KEEP clauses are valid only when you are disabling a unique or primary key constraint.
See Also:
The enable_disable_clause (in CREATE TABLE) for a complete description of this clause, including notes and restrictions that relate to this statement
"Using Indexes to Enforce Constraints" for information on using indexes to enforce constraints
TABLE LOCK Oracle Database permits DDL operations on a table only if the table can be locked during the operation. Such table locks are not required during DML operations.
Note:
Table locks are not acquired on temporary tables.Specify ENABLE TABLE LOCK to enable table locks, thereby allowing DDL operations on the table. All currently executing transactions must commit or roll back before Oracle Database enables the table lock.
Caution:
Oracle Database waits until active DML transactions in the database have completed before locking the table. Sometimes the resulting delay is considerable.Specify DISABLE TABLE LOCK to disable table locks, thereby preventing DDL operations on the table.
Note:
Parallel DML operations are not performed when the table lock of the target table is disabled.ALL TRIGGERS Use the ALL TRIGGERS clause to enable or disable all triggers associated with the table.
Specify ENABLE ALL TRIGGERS to enable all triggers associated with the table. Oracle Database fires the triggers whenever their triggering condition is satisfied.
To enable a single trigger, use the enable_clause of ALTER TRIGGER.
Specify DISABLE ALL TRIGGERS to disable all triggers associated with the table. Oracle Database does not fire a disabled trigger even if the triggering condition is satisfied.
Collection Retrieval: Example The following statement modifies nested table column ad_textdocs_ntab in the sample table sh.print_media so that when queried it returns actual values instead of locators:
ALTER TABLE print_media MODIFY NESTED TABLE ad_textdocs_ntab RETURN AS VALUE;
Specifying Parallel Processing: Example The following statement specifies parallel processing for queries to the sample table oe.customers:
ALTER TABLE customers PARALLEL;
Changing the State of a Constraint: Examples The following statement places in ENABLE VALIDATE state an integrity constraint named emp_manager_fk in the employees table:
ALTER TABLE employees ENABLE VALIDATE CONSTRAINT emp_manager_fk EXCEPTIONS INTO exceptions;
Each row of the employees table must satisfy the constraint for Oracle Database to enable the constraint. If any row violates the constraint, then the constraint remains disabled. The database lists any exceptions in the table exceptions. You can also identify the exceptions in the employees table with the following statement:
SELECT e.*
FROM employees e, exceptions ex
WHERE e.rowid = ex.row_id
AND ex.table_name = 'EMPLOYEES'
AND ex.constraint = 'EMP_MANAGER_FK';
The following statement tries to place in ENABLE NOVALIDATE state two constraints on the employees table:
ALTER TABLE employees ENABLE NOVALIDATE PRIMARY KEY ENABLE NOVALIDATE CONSTRAINT emp_last_name_nn;
This statement has two ENABLE clauses:
The first places a primary key constraint on the table in ENABLE NOVALIDATE state.
The second places the constraint named emp_last_name_nn in ENABLE NOVALIDATE state.
In this case, Oracle Database enables the constraints only if both are satisfied by each row in the table. If any row violates either constraint, then the database returns an error and both constraints remain disabled.
Consider the foreign key constraint on the location_id column of the departments table, which references the primary key of the locations table. The following statement disables the primary key of the locations table:
ALTER TABLE locations MODIFY PRIMARY KEY DISABLE CASCADE;
The unique key in the locations table is referenced by the foreign key in the departments table, so you must specify CASCADE to disable the primary key. This clause disables the foreign key as well.
Creating an Exceptions Table for Index-Organized Tables: Example The following example creates the except_table table to hold rows from the index-organized table hr.countries that violate the primary key constraint:
EXECUTE DBMS_IOT.BUILD_EXCEPTIONS_TABLE ('hr', 'countries', 'except_table');
ALTER TABLE countries ENABLE PRIMARY KEY EXCEPTIONS INTO except_table;
To specify an exception table, you must have the privileges necessary to insert rows into the table. To examine the identified exceptions, you must have the privileges necessary to query the exceptions table.
Disabling a CHECK Constraint: Example The following statement defines and disables a CHECK constraint on the employees table:
ALTER TABLE employees ADD CONSTRAINT check_comp CHECK (salary + (commission_pct*salary) <= 5000) DISABLE;
The constraint check_comp ensures that no employee's total compensation exceeds $5000. The constraint is disabled, so you can increase an employee's compensation above this limit.
Enabling Triggers: Example The following statement enables all triggers associated with the employees table:
ALTER TABLE employees ENABLE ALL TRIGGERS;
Deallocating Unused Space: Example The following statement frees all unused space for reuse in table employees, where the high water mark is above MINEXTENTS:
ALTER TABLE employees
DEALLOCATE UNUSED;
Renaming a Column: Example The following example renames the credit_limit column of the sample table oe.customers to credit_amount:
ALTER TABLE customers RENAME COLUMN credit_limit TO credit_amount;
Dropping a Column: Example This statement illustrates the drop_column_clause with CASCADE CONSTRAINTS. Assume table t1 is created as follows:
CREATE TABLE t1 ( pk NUMBER PRIMARY KEY, fk NUMBER, c1 NUMBER, c2 NUMBER, CONSTRAINT ri FOREIGN KEY (fk) REFERENCES t1, CONSTRAINT ck1 CHECK (pk > 0 and c1 > 0), CONSTRAINT ck2 CHECK (c2 > 0) );
An error will be returned for the following statements:
/* The next two statements return errors:
ALTER TABLE t1 DROP (pk); -- pk is a parent key
ALTER TABLE t1 DROP (c1); -- c1 is referenced by multicolumn
-- constraint ck1
Submitting the following statement drops column pk, the primary key constraint, the foreign key constraint, ri, and the check constraint, ck1:
ALTER TABLE t1 DROP (pk) CASCADE CONSTRAINTS;
If all columns referenced by the constraints defined on the dropped columns are also dropped, then CASCADE CONSTRAINTS is not required. For example, assuming that no other referential constraints from other tables refer to column pk, then it is valid to submit the following statement without the CASCADE CONSTRAINTS clause:
ALTER TABLE t1 DROP (pk, fk, c1);
Modifying Index-Organized Tables: Examples This statement modifies the INITRANS parameter for the index segment of index-organized table countries_demo, which is based on hr.countries:
ALTER TABLE countries_demo INITRANS 4;
The following statement adds an overflow data segment to index-organized table countries:
ALTER TABLE countries_demo ADD OVERFLOW;
This statement modifies the INITRANS parameter for the overflow data segment of index-organized table countries:
ALTER TABLE countries_demo OVERFLOW INITRANS 4;
Splitting Table Partitions: Examples The following statement splits the old partition sales_q4_2000 in the sample table sh.sales, creating two new partitions, naming one sales_q4_2000b and reusing the name of the old partition for the other:
ALTER TABLE sales SPLIT PARTITION SALES_Q4_2000
AT (TO_DATE('15-NOV-2000','DD-MON-YYYY'))
INTO (PARTITION SALES_Q4_2000, PARTITION SALES_Q4_2000b);
The following statements create a partitioned version of the pm.print_media table. The LONG column in the print_media table has been converted to LOB. The table is stored in tablespaces created in "Creating Oracle Managed Files: Examples". The object types underlying the ad_textdocs_ntab and ad_header columns are created in the script that creates the pm sample schema:
CREATE TABLE print_media_part (
product_id NUMBER(6),
ad_id NUMBER(6),
ad_composite BLOB,
ad_sourcetext CLOB,
ad_finaltext CLOB,
ad_fltextn NCLOB,
ad_textdocs_ntab TEXTDOC_TAB,
ad_photo BLOB,
ad_graphic BFILE,
ad_header ADHEADER_TYP)
NESTED TABLE ad_textdocs_ntab STORE AS textdoc_nt
PARTITION BY RANGE (product_id)
(PARTITION p1 VALUES LESS THAN (100),
PARTITION p2 VALUES LESS THAN (200));
The following statement splits partition p2 of that table into partitions p2a and p2b:
ALTER TABLE print_media_part
SPLIT PARTITION p2 AT (150) INTO
(PARTITION p2a TABLESPACE omf_ts1
LOB (ad_photo, ad_composite) STORE AS (TABLESPACE omf_ts2),
PARTITION p2b
LOB (ad_photo, ad_composite) STORE AS (TABLESPACE omf_ts2))
NESTED TABLE ad_textdocs_ntab INTO (PARTITION nt_p2a, PARTITION nt_p2b);
In both partitions p2a and p2b, Oracle Database creates the LOB segments for columns ad_photo and ad_composite in tablespace omf_ts2. The LOB segments for the remaining columns in partition p2a are stored in tablespace omf_ts1. The LOB segments for the remaining columns in partition p2b remain in the tablespaces in which they resided prior to this ALTER statement. However, the database creates new segments for all the LOB data and LOB index segments, even if they are not moved to a new tablespace.
The database also creates new segments for nested table column ad_textdocs_ntab. The storage tables is those new segments are nt_p2a and nt_p2b.
Merging Two Table Partitions: Example The following statement merges back into one partition the partitions created in "Splitting Table Partitions: Examples":
ALTER TABLE sales MERGE PARTITIONS sales_q4_2000, sales_q4_2000b INTO PARTITION sales_q4_2000;
The next statement reverses the example in "Splitting Table Partitions: Examples":
ALTER TABLE print_media_part MERGE PARTITIONS p2a, p2b INTO PARTITION p2ab TABLESPACE example NESTED TABLE ad_textdocs_ntab STORE AS nt_p2ab;
Adding a Table Partition with a LOB and Nested Table Storage: Examples The following statement adds a partition p3 to the print_media_part table (see preceding example) and specifies storage characteristics for the BLOB, CLOB, and nested table columns of that table:
ALTER TABLE print_media_part ADD PARTITION p3 VALUES LESS THAN (400) LOB(ad_photo, ad_composite) STORE AS (TABLESPACE omf_ts1) LOB(ad_sourcetext, ad_finaltext) STORE AS (TABLESPACE omf_ts2) NESTED TABLE ad_textdocs_ntab STORE AS nt_p3;
The LOB data and LOB index segments for columns ad_photo and ad_composite in partition p3 will reside in tablespace omf_ts1. The remaining attributes for these LOB columns will be inherited first from the table-level defaults, and then from the tablespace defaults.
The LOB data segments for columns ad_source_text and ad_finaltext will reside in the omf_ts2 tablespace, and will inherit all other attributes first from the table-level defaults, and then from the tablespace defaults.
The partition for the storage table for nested table storage column ad_textdocs_ntab corresponding to partition p3 of the base table is named nt_p3 and inherits all other attributes first from the table-level defaults, and then from the tablespace defaults.
Working with Default List Partitions: Example The following statements use the list partitioned table created in "List Partitioning Example". The first statement splits the existing default partition into a new south partition and a default partition:
ALTER TABLE list_customers SPLIT PARTITION rest
VALUES ('MEXICO', 'COLOMBIA')
INTO (PARTITION south, PARTITION rest);
The next statement merges the resulting default partition with the asia partition:
ALTER TABLE list_customers MERGE PARTITIONS asia, rest INTO PARTITION rest;
The next statement re-creates the asia partition by splitting the default partition:
ALTER TABLE list_customers SPLIT PARTITION rest
VALUES ('CHINA', 'THAILAND')
INTO (PARTITION asia, PARTITION rest);
Dropping a Table Partition: Example The following statement drops partition p3 created in "Adding a Table Partition with a LOB and Nested Table Storage: Examples":
ALTER TABLE print_media_part DROP PARTITION p3;
Exchanging Table Partitions: Example
This example creates the table exchange_table with the same structure as the partitions of the list_customers table created in "List Partitioning Example". It then replaces partition rest of table list_customers with table exchange_table without exchanging local index partitions with corresponding indexes on exchange_table and without verifying that data in exchange_table falls within the bounds of partition rest:
CREATE TABLE exchange_table ( customer_id NUMBER(6), cust_first_name VARCHAR2(20), cust_last_name VARCHAR2(20), cust_address CUST_ADDRESS_TYP, nls_territory VARCHAR2(30), cust_email VARCHAR2(30)); ALTER TABLE list_customers EXCHANGE PARTITION rest WITH TABLE exchange_table WITHOUT VALIDATION;
Modifying Table Partitions: Examples The following statement marks all the local index partitions corresponding to the asia partition of the list_customers table UNUSABLE:
ALTER TABLE list_customers MODIFY PARTITION asia UNUSABLE LOCAL INDEXES;
The following statement rebuilds all the local index partitions that were marked UNUSABLE:
ALTER TABLE list_customers MODIFY PARTITION asia REBUILD UNUSABLE LOCAL INDEXES;
Moving Table Partitions: Example The following statement moves partition p2b (from "Splitting Table Partitions: Examples") to tablespace omf_ts1:
ALTER TABLE print_media_part MOVE PARTITION p2b TABLESPACE omf_ts1;
Renaming Table Partitions: Examples The following statement renames a partition of the sh.sales table:
ALTER TABLE sales RENAME PARTITION sales_q4_2003 TO sales_currentq;
Truncating Table Partitions: Example The following statement uses the print_media_demo table created in "Partitioned Table with LOB Columns Example". It deletes all the data in the p1 partition and deallocates the freed space:
ALTER TABLE print_media_demo TRUNCATE PARTITION p1 DROP STORAGE;
Updating Global Indexes: Example The following statement splits partition sales_q1_2000 of the sample table sh.sales and updates any global indexes defined on it:
ALTER TABLE sales SPLIT PARTITION sales_q1_2000
AT (TO_DATE('16-FEB-2000','DD-MON-YYYY'))
INTO (PARTITION q1a_2000, PARTITION q1b_2000)
UPDATE GLOBAL INDEXES;
Updating Partitioned Indexes: Example The following statement splits partition costs_Q4_2003 of the sample table sh.costs and updates the local index defined on it. It uses the tablespaces created in "Creating Basic Tablespaces: Examples".
CREATE INDEX cost_ix ON costs(channel_id) LOCAL;
ALTER TABLE costs
SPLIT PARTITION costs_q4_2003 at
(TO_DATE('01-Nov-2003','dd-mon-yyyy'))
INTO (PARTITION c_p1, PARTITION c_p2)
UPDATE INDEXES (cost_ix (PARTITION c_p1 tablespace tbs_02,
PARTITION c_p2 tablespace tbs_03));
Specifying Object Identifiers: Example The following statements create an object type, a corresponding object table with a primary-key-based object identifier, and a table having a user-defined REF column:
CREATE TYPE emp_t AS OBJECT (empno NUMBER, address CHAR(30)); CREATE TABLE emp OF emp_t ( empno PRIMARY KEY) OBJECT IDENTIFIER IS PRIMARY KEY; CREATE TABLE dept (dno NUMBER, mgr_ref REF emp_t SCOPE is emp);
The next statements add a constraint and a user-defined REF column, both of which reference table emp
ALTER TABLE dept ADD CONSTRAINT mgr_cons FOREIGN KEY (mgr_ref) REFERENCES emp; ALTER TABLE dept ADD sr_mgr REF emp_t REFERENCES emp;
Adding a Table Column: Example The following statement adds to the countries table a column named duty_pct of data type NUMBER and a column named visa_needed of data type VARCHAR2 with a size of 3 and a CHECK integrity constraint:
ALTER TABLE countries
ADD (duty_pct NUMBER(2,2) CHECK (duty_pct < 10.5),
visa_needed VARCHAR2(3));
Adding a Virtual Table Column: Example The following statement adds to a copy of the hr.employees table a column named income, which is a combination of salary plus commission. Both salary and commission are NUMBER columns, so the database creates the virtual column as a NUMBER column even though the data type is not specified in the statement:
CREATE TABLE emp2 AS SELECT * FROM employees; ALTER TABLE emp2 ADD (income AS (salary + (salary*commission_pct)));
Modifying Table Columns: Examples The following statement increases the size of the duty_pct column:
ALTER TABLE countries MODIFY (duty_pct NUMBER(3,2));
Because the MODIFY clause contains only one column definition, the parentheses around the definition are optional.
The following statement changes the values of the PCTFREE and PCTUSED parameters for the employees table to 30 and 60, respectively:
ALTER TABLE employees PCTFREE 30 PCTUSED 60;
Data Encryption: Examples The following statement encrypts the salary column of the hr.employees table using the encryption algorithm AES256. As described in "Semantics" above, you must first enable Transparent Data Encryption:
ALTER TABLE employees MODIFY (salary ENCRYPT USING 'AES256' 'NOMAC');
The following statement adds a new encrypted column online_acct_pw to the oe.customers table, using the default encryption algorithm AES192. Specifying NO SALT will allow a B-tree index to be created on the column, if desired.
ALTER TABLE customers ADD (online_acct_pw VARCHAR2(8) ENCRYPT NO SALT 'NOMAC');
The following example decrypts the customer.online_acct_pw column:
ALTER TABLE customers MODIFY (online_acct_pw DECRYPT);
Allocating Extents: Example The following statement allocates an extent of 5 kilobytes for the employees table and makes it available to instance 4:
ALTER TABLE employees ALLOCATE EXTENT (SIZE 5K INSTANCE 4);
Because this statement omits the DATAFILE parameter, Oracle Database allocates the extent in one of the data files belonging to the tablespace containing the table.
Specifying Default Column Value: Examples This statement modifies the min_price column of the product_information table so that it has a default value of 10:
ALTER TABLE product_information MODIFY (min_price DEFAULT 10);
If you subsequently add a new row to the product_information table and do not specify a value for the min_price column, then the value of the min_price column is automatically 10:
INSERT INTO product_information (product_id, product_name,
list_price)
VALUES (300, 'left-handed mouse', 40.50);
SELECT product_id, product_name, list_price, min_price
FROM product_information
WHERE product_id = 300;
PRODUCT_ID PRODUCT_NAME LIST_PRICE MIN_PRICE
---------- -------------------- ---------- ----------
300 left-handed mouse 40.5 10
To discontinue previously specified default values, so that they are no longer automatically inserted into newly added rows, replace the values with NULL, as shown in this statement:
ALTER TABLE product_information MODIFY (min_price DEFAULT NULL);
The MODIFY clause need only specify the column name and the modified part of the definition, rather than the entire column definition. This statement has no effect on any existing values in existing rows.
Adding a Constraint to an XMLType Table: Example The following example adds a primary key constraint to the xwarehouses table, created in "XMLType Examples":
ALTER TABLE xwarehouses ADD (PRIMARY KEY(XMLDATA."WarehouseID"));
Refer to XMLDATA Pseudocolumn for information about this pseudocolumn.
Renaming Constraints: Example The following statement renames the cust_fname_nn constraint on the sample table oe.customers to cust_firstname_nn:
ALTER TABLE customers RENAME CONSTRAINT cust_fname_nn TO cust_firstname_nn;
Dropping Constraints: Examples The following statement drops the primary key of the departments table:
ALTER TABLE departments
DROP PRIMARY KEY CASCADE;
If you know that the name of the PRIMARY KEY constraint is pk_dept, then you could also drop it with the following statement:
ALTER TABLE departments
DROP CONSTRAINT pk_dept CASCADE;
The CASCADE clause causes Oracle Database to drop any foreign keys that reference the primary key.
The following statement drops the unique key on the email column of the employees table:
ALTER TABLE employees
DROP UNIQUE (email);
The DROP clause in this statement omits the CASCADE clause. Because of this omission, Oracle Database does not drop the unique key if any foreign key references it.
LOB Columns: Examples The following statement adds CLOB column resume to the employee table and specifies LOB storage characteristics for the new column:
ALTER TABLE employees ADD (resume CLOB) LOB (resume) STORE AS resume_seg (TABLESPACE example);
To modify the LOB column resume to use caching, enter the following statement:
ALTER TABLE employees MODIFY LOB (resume) (CACHE);
The following statement adds a SecureFiles CLOB column resume to the employee table and specifies LOB storage characteristics for the new column. SecureFiles LOBs must be stored in tablespaces with automatic segment-space management. Therefore, the LOB data in this example is stored in the auto_seg_ts tablespace, which was created in "Specifying Segment Space Management for a Tablespace: Example":
ALTER TABLE employees ADD (resume CLOB) LOB (resume) STORE AS SECUREFILE resume_seg (TABLESPACE auto_seg_ts);
To modify the LOB column resume so that it does not use caching, enter the following statement:
ALTER TABLE employees MODIFY LOB (resume) (NOCACHE);
Nested Tables: Examples The following statement adds the nested table column skills to the employee table:
ALTER TABLE employees ADD (skills skill_table_type)
NESTED TABLE skills STORE AS nested_skill_table;
You can also modify nested table storage characteristics. Use the name of the storage table specified in the nested_table_col_properties to make the modification. You cannot query or perform DML statements on the storage table. Use the storage table only to modify the nested table column storage characteristics.
The following statement creates table vet_service with nested table column client and storage table client_tab. Nested table client_tab is modified to specify constraints:
CREATE TYPE pet_t AS OBJECT
(pet_id NUMBER, pet_name VARCHAR2(10), pet_dob DATE);
/
CREATE TYPE pet AS TABLE OF pet_t;
/
CREATE TABLE vet_service (vet_name VARCHAR2(30),
client pet)
NESTED TABLE client STORE AS client_tab;
ALTER TABLE client_tab ADD UNIQUE (pet_id);
The following statement alters the storage table for a nested table of REF values to specify that the REF is scoped:
CREATE TYPE emp_t AS OBJECT (eno number, ename char(31)); CREATE TYPE emps_t AS TABLE OF REF emp_t; CREATE TABLE emptab OF emp_t; CREATE TABLE dept (dno NUMBER, employees emps_t) NESTED TABLE employees STORE AS deptemps; ALTER TABLE deptemps ADD (SCOPE FOR (COLUMN_VALUE) IS emptab);
Similarly, to specify storing the REF with rowid:
ALTER TABLE deptemps ADD (REF(column_value) WITH ROWID);
In order to execute these ALTER TABLE statements successfully, the storage table deptemps must be empty. Also, because the nested table is defined as a table of scalar values (REF values), Oracle Database implicitly provides the column name COLUMN_VALUE for the storage table.
See Also:
CREATE TABLE for more information about nested table storage
Oracle Database Object-Relational Developer's Guide for more information about nested tables
REF Columns: Examples The following statement creates an object type dept_t and then creates table staff:
CREATE TYPE dept_t AS OBJECT
(deptno NUMBER, dname VARCHAR2(20));
/
CREATE TABLE staff
(name VARCHAR(100),
salary NUMBER,
dept REF dept_t);
An object table offices is created as:
CREATE TABLE offices OF dept_t;
The dept column can store references to objects of dept_t stored in any table. If you would like to restrict the references to point only to objects stored in the departments table, then you could do so by adding a scope constraint on the dept column as follows:
ALTER TABLE staff
ADD (SCOPE FOR (dept) IS offices);
The preceding ALTER TABLE statement will succeed only if the staff table is empty.
If you want the REF values in the dept column of staff to also store the rowids, then issue the following statement:
ALTER TABLE staff ADD (REF(dept) WITH ROWID);
Additional Examples For examples of defining integrity constraints with the ALTER TABLE statement, see the constraint.
For examples of changing the storage parameters of a table, see the storage_clause .
|
 Copyright © 1996, 2013, Oracle and/or its affiliates. All rights reserved. Legal Notices |
|