Skip Header s

Oracle® Database Administrator's Guide
10g Release 1 (10.1)

Part Number B10739-01
Go to Documentation H
ome
Home
Go to Book List
Book List
Go to Table of Contents
Contents
Go to Index
Index
Go to Master Index
Master Index

Feedback

< /tr>
Go to previous page
Previous
Go to next page
Ne xt
View PDF

8 Managing Tablespaces

This chapter describes the various aspects of tablespace management, an d contains the following topics:

Guidelines for Managing Tablespaces

Before working with table spaces of an Oracle Database, familiarize yourself with the guidelines provided in the following sections:

Specifying Nonstandard Block Sizes for Tablespaces

You can create tablespaces with block sizes different from the standard database block size, which is specified by the DB_BLOCK_SIZE in itialization parameter. This feature lets you transport tablespaces with unlike block sizes between databases.

Use the B LOCKSIZE clause of the CREATE TABLESPACE statement to create a tablespace with a block size different from the da tabase standard block size. In order for the BLOCKSIZE clause to succeed, you must have already set the DB_CACHE_SIZE and at least one DB_nK_CACHE_SIZE< /code> initialization parameter. Further, and the integer you specify in the BLOCKSIZE clause must correspond with the s etting of one DB_nK_CACHE_SIZE parameter setting. Although redundant, specifying a BLOCKSIZE equal to the standard block size, as specified by the DB_BLOCK_SIZE initialization parameter, is allowed.

The following statement creates ta blespace lmtbsb, but specifies a block size that differs from the standard database block size (as specified by the DB_BLOCK_SIZE initialization parameter):

CREATE TABLESPACE lmtbsb DATAFILE '/u02/oracle/data/l
mtbsb01.dbf' SIZE 50M
    EXTENT MANAGEMENT LOCAL UNIFORM SIZE 128K
    BLOCKSIZE 8K; 


Controlling the Writ ing of Redo Records

For some database operatio ns, you can control whether the database generates redo records. Without redo, no media recovery is possible. However, suppressing re do generation can improve performance, and may be appropriate for easily recoverable operations. An example of such an operation is a CREATE TABLE...AS SELECT statement, which can be repeated in case of database or instance failure.

Specify the < code>NOLOGGING clause in the CREATE TABLESPACE statement if you wish to suppress redo when these operations are p erformed for objects within the tablespace. If you do not include this clause, or if you specify LOGGING instead, then t he database generates redo when changes are made to objects in the tablespace. Redo is never generated for temporary segments or in t emporary tablespaces, regardless of the logging attribute.

The logging attribute specified at the tablespace level is the defa ult attribute for objects created within the tablespace. You can override this default logging attribute by specifying LOGGING< /code> or NOLOGGING at the schema object level--for example, in a CREATE TABLE statement.

If you hav e a standby database, NOLOGGING mode causes problems with the availability and accuracy of the standby database. To over come this problem, you can specify FORCE LOGGING mode. When you include the FORCE LOGGING clause in the CREATE TABLESPACE statement, you force the generation of redo records for all operations that make changes to objects in a tablespace. This overrides any specification made at the object level.

If you transport a tablespace that is in FORCE LO GGING mode to another database, the new tablespace will not maintain the FORCE LOGGING mode.


< p>See Also:


Altering Tablesp ace Availability

You can take an online tablespace offline so that it is temporarily unavailable for general use. The rest of the database remains open and available for users to access data. Conversely, you can bring an offline tablespace online to m ake the schema objects within the tablespace available to database users. The database must be open to alter the availability of a ta blespace.

To alter the availability of a tablespace, use the ALTER TABLESPACE statement. You must have the ALTER TABLESPACE or MANAGE TABLESPACE system privilege.


See Also:

See Also:

"Altering Datafile Availability" for information about altering the availability of individual datafiles within a tablespace

< !-- class="inftblnotealso -->
< /a>

Taking Tablespaces Offline

You may want to take a tablespace offline for any of the following reasons:

  • To make a portion of the database unavailable while allowing normal access to the remainder of the database

  • To perform an off line tablespace backup (even though a tablespace can be backed up while online and in use)

  • To make an ap plication and its group of tables temporarily unavailable while updating or maintaining the application

When a table space is taken offline, the database takes all the associated files offline.

You cannot take the following tablespaces offline :

  • SYSTEM

  • The undo tablespace

  • Temp orary tablespaces

Before taking a tablespace offline, consider altering the tablespace allocation of any users who h ave been assigned the tablespace as a default tablespace. Doing so is advisable because those users will not be able to access object s in the tablespace while it is offline.

You can specify any of the following parameters as part of the ALTER TABLESPACE ... OFFLINE statement:

Clause Description
NORMAL A tablesp ace can be taken offline normally if no error conditions exist for any of the datafiles of the tablespace. No datafile in the tablesp ace can be currently offline as the result of a write error. When you specify OFFLINE NORMAL, the database takes a check point for all datafiles of the tablespace as it takes them offline. NORMAL is the default.
TEMPORARY A tablespace can be taken offline temporarily, even if there are error conditions for one or more files of the tablespace. When you specify OFFLINE TEMPORARY, the database takes offline the datafiles that are not already offline, checkpointing them as it does so.

If no files are offline, but you use the temporary clause, media recovery is not required to bring the tablespace ba ck online. However, if one or more files of the tablespace are offline because of write errors, and you take the tablespace offline t emporarily, the tablespace requires recovery before you can bring it back online.

IMMEDIATE A tablespace can be taken offline immediately, without the database taking a checkpoint on any of the datafiles. When you specify OFFLINE IMMED IATE, media recovery for the tablespace is required before the tablespace can be brought online. You cannot take a tablespace offline immediately if the database is running in NOARCHIVELOG mode.


Caution: If you must take a tablespace offline, use the NORMAL clause (the default) if possible. This setting guarantees that the tablespace will not require recovery to come back online, even if after incomplete recovery you reset the redo log sequence using an ALTER DATABASE OPEN RESETLOGS statement.


Specify TEMPORARY only when you cannot take the tablespace offline normally. In this case, only the files taken offline because of errors need to be recovered before the tablespace can be brought online. Specify IMMEDIATE only after trying both the normal and temporary settings.

The following example takes the users tablespace offline normally:

< pre xml:space="preserve">ALTER TABLESPACE users OFFLINE NORMAL;

Br inging Tablespaces Online

You can bring any tablespace in an Oracle Database online whenever the database is open. A t ablespace is normally online so that the data contained within it is available to database users.

If a tablespace to be brough t online was not taken offline "cleanly" (that is, using the NORMAL clause of the ALTER TABLESPACE OFFLINE statement), you must first perform media recovery on the tablespace before bringing it online. Otherwise, the database returns an err or and the tablespace remains offline.


See Also:

Depending upon your archiving strategy, refer to one of the following books for information about perfo rming media recovery:

The following statement brings the users tablespac e online:

ALTER TABLESPACE users ONLINE;

Using Read-Only Tablespaces

Making a table space read-only prevents write operations on the datafiles in the tablespace. The primary purpose of read-only tablespaces is to elim inate the need to perform backup and recovery of large, static portions of a database. Read-only tablespaces also provide a way to pr otecting historical data so that users cannot modify it. Making a tablespace read-only prevents updates on all tables in the tablespa ce, regardless of a user's update privilege level.


Note:

Making a tablespace read-only cannot in itself be used to satisfy archiving or data publishing requir ements, because the tablespace can only be brought online in the database in which it was created. However, you can meet such require ments by using the transportable tablespace feature, as described in "Transporting Tablespaces Between Databases" .

You can drop items, such as tables or indexes, from a read-only tablespace, but you cannot create or alter objects in a read-only tablespace. You can execute statements that update the file description in the data dictionary, such as ALTER TABLE ... ADD or ALTER TABLE ... MODIFY, but you wi ll not be able to utilize the new description until the tablespace is made read/write.

Read-only tablespaces can be transporte d to other databases. And, since read-only tablespaces can never be updated, they can reside on CD-ROM or WORM (Write Once-Read Many) devices.

The following topics are discussed in this section:

Making a Tablespace Read-Only< a id="sthref1177" name="sthref1177">

All tablespaces are initially created as read/write. Use the READ ONLY< /code> clause in the ALTER TABLESPACE statement to change a tablespace to read- only. You must have the ALTER TABLESPACE or MANAGE TABLESPACE system privilege.

Before you can make a tablespace read-only, the following conditions must be met.

  • The tablespace must be online. This is nec essary to ensure that there is no undo information that needs to be applied to the tablespace.

  • The table space cannot be the active undo tablespace or SYSTEM tablespace.

  • The tablespace must not currently be involved in an online backup, because the end of a backup updates the header file of all datafiles in the tablespace.

For better performance while accessing data in a read-only tablespace, you can issue a query that accesses all of the blocks of the tables in the tablespace just before making it read-only. A simple query, such a s SELECT COUNT (*), executed against each table ensures that the data blocks in the tablespace can be subsequently acces sed most efficiently. This eliminates the need for the database to check the status of the transactions that most recently modified t he blocks.

The following statement makes the flights tablespace read-only:

ALTER TA
BLESPACE flights READ ONLY;

You can issue the ALTER TABLESPACE ... READ ONLY statement while the database is processing transactions. Once the statement is issued, no transactions are allowed to make further changes (using DML statements) to the tablespace being made read-only. Transactions that have already made changes to the tablespace are allowed to commit or terminat e.

If any transactions are ongoing, then the ALTER TABLESPACE ... READ ONLY statement may not return instantaneou sly. The database waits for all transactions started before you issued READ ONLY to either commit or terminate.


Note:

This transitional read-only state only occurs if the value of the initialization parameter COMPATIBLE is 8.1.0 or greater. If this parameter is set to a value less than 8.1.0, the ALTER TABLESPACE ... READ ONLY statement fails if any active transactions exist.

If you find it is taking a long time for the ALTER TABLESPACE s tatement to complete, you can identify the transactions that are preventing the read-only state from taking effect. You can then noti fy the owners of those transactions and decide whether to terminate the transactions, if necessary.

The following example iden tifies the transaction entry for the ALTER TABLESPACE ... READ ONLY statement and note its session address (saddr< /code>):

SELECT SQL_TEXT, SADDR 
    FROM V$SQLAREA,V$SESSION
    WHERE V$SQLAREA.ADDRESS = V$SESSION.S
QL_ADDRESS    
        AND SQL_TEXT LIKE 'alter tablespace%'; 

SQL_TEXT                                 SADDR   
-------------------
--------------------- --------
alter tablespace tbs1 read only          80034AF0

The start SCN of each active transaction is stored in the V$TRANSACTION view. Displaying this view sorted by ascending start SCN lists the transactions in execu tion order. From the preceding example, you already know the session address of the transaction entry for the read-only statement, an d you can now locate it in the V$TRANSACTION view. All transactions with smaller start SCN, which indicates an earlier e xecution, can potentially hold up the quiesce and subsequent read-only state of the tablespace.

SELECT
SES_ADDR, START_SCNB 
    FROM V$TRANSACTION
    ORDER BY START_SCNB;

SES_ADDR START_SCNB
-------- ----------
800352A0       3621
--> waiting on this txn
80035A50       3623   --> waiting on this txn
80034AF0       3628   --> this is the ALTER TABLESPACE
 statement
80037910       3629   --> don't care about this txn

After making the tablespace read-only, it is advisable to back it up immediately. As long as the tablespace remains read-only, no further backups of the tablespace are necessary, because n o changes can be made to it.


See Also:< /strong>

Depending upon your backup and recovery strategy, refer to one of the following books for information about backi ng up and recovering a database with read-only datafiles:

Making a Rea d-Only Tablespace Writable

Use the READ WRITE keywords in the ALTER TABLESPACE statement to change a tablespace to allow write operations. You must have the ALTER TABLESPACE or MANAGE TABLESPACE system privilege.

A prerequisite to making the t ablespace read/write is that all of the datafiles in the tablespace, as well as the tablespace itself, must be online. Use the DATAFILE ... ONLINE clause of the ALTER DATABASE statement to bring a datafile online. The V$DATAFILE view lists the current status of datafiles.

The following statement makes the flights tablespace writable:

ALTER TABLESPACE flights READ WRITE;

Making a read-only tablespace writable updates the control file entry for the datafiles, so that you can use the read-only version of the datafiles as a starting point for recovery.

Creating a Read-Only Tablespace on a WORM Device

Follow these steps to create a read-only tablespace on a CD-ROM or WORM (Write Once-Read Many) device.

  1. Create a writable t ablespace on another device. Create the objects that belong in the tablespace and insert your data.

  2. Alter the tables pace to make it read-only.

  3. Copy the datafiles of the tablespace onto the WORM device. Use operating system commands to copy the files.

  4. Take the tablespace offline.

  5. Rename the datafiles to coincide with the names of the datafiles you copied onto your WORM device. Use ALTER TABLESPACE with the RENAME DATAFILE clause. Renam ing the datafiles changes their names in the control file.

  6. Bring the tablespace back online.

Delaying the Opening of Datafiles in Read-Only Tablespaces

When subs tantial portions of a very large database are stored in read-only tablespaces that are locat ed on slow-access devices or hierarchical storage, you should consider setting the READ_ONLY_OPEN_DELAYED initialization parameter to TRUE. This speeds certain operations, primarily opening the database, by causing datafiles in read-only ta blespaces to be accessed for the first time only when an attempt is made to read data stored within them.

Setting READ_O NLY_OPEN_DELAYED=TRUE has the following side-effects:

  • A missing or bad read-only file is not dete cted at open time. It is only discovered when there is an attempt to access it.

  • ALTER SYSTEM CHECK DATAFILES does not check read-only files.

  • ALTER TABLESPACE ... ONLINE and ALT ER DATABASE DATAFILE ... ONLINE do not check read-only files. They are checked only upon the first access.

  • V$RECOVER_FILE, V$BACKUP, and V$DATAFILE_HEADER do not access read-only files. Read-only files are indicated in the results list with the error "DELAYED OPEN", with zeroes for the values of o ther columns.

  • V$DATAFILE does not access read-only files. Read-only files have a size of "0 " listed.

  • V$RECOVER_LOG does not access read-only files. Logs they could need for recovery are not added to the list.

  • ALTER DATABASE NOARCHIVELOG does not access read-only files.It p roceeds even if there is a read-only file that requires recovery.


    Notes:

    • RECOVER DATABASE and ALTER DATABASE OPEN RESETLOGS continue to access all read-only datafiles regardless of the parameter value. If you want to avoid accessing read-on ly files for these operations, those files should be taken offline.

    • If a backup control file is used, th e read-only status of some files may be inaccurate. This can cause some of these operations to return unexpected results. Care should be taken in this situation.


< !-- class="sect2" -->

Renaming T ablespaces

Using the RENAME TO clause of the ALTER TABLESPACE, you can rename a permanent or temporary tablespace. For example, the following s tatement renames the users tablespace:

ALTER TABLESPACE users RENAME TO usersts;

When you rename a tablespace the database updates all references to the tablespace name in the data dictionary, control file, and (online) datafile headers. The database does not change the tablespace ID so if this tablespace were, for example, the default tables pace for a user, then the renamed tablespace would show as the default tablespace for the user in the DBA_USERS view.

The following affect the operation of this statement:

  • The COMPATIBLE parameter must be set to 10.0 or higher.

  • If the tablespace being renamed is the SYSTEM tablespace or the SYSAUX< /code> tablespace, then it will not be renamed and an error is raised.

  • If any datafile in the tablespace is offline, or if the tablespace is offline, then the tablespace is not renamed and an error is raised.

  • If the tablespace is read only, then datafile headers are not updated. This should not be regarded as corruption; instead, it causes a message to be written to the alert log indicating that datafile headers have not been renamed. The data dictionary and control file are upda ted.

  • If the tablespace is the default temporary tablespace, then the corresponding entry in the database properties table is updated and the DATABASE_PROPERTIES view shows the new name.

  • If the tablespace i s an undo tablespace and if the following conditions are met, then the tablespace name is ch anged to the new tablespace name in the server parameter file (SPFILE).

    • The server parame ter file was used to start up the database.

    • The tablespace name is specified as the UNDO_TABLESP ACE for any instance.

    If a traditional initialization parameter file (PFILE) is being used then a message is written to the alert file stating that the initialization parameter file must be manually changed.

< !-- class="sect1" -->

Dropping Tablespaces

You can drop a tablespace and its contents (the segments contained in the tablespace) from the d atabase if the tablespace and its contents are no longer required. You must have the DROP TABLESPACE system privilege to drop a tablespace.


Caution:

Once a tablespace has been dropped, the data in the tablespace is not recoverable. Therefore, make sure that all dat a contained in a tablespace to be dropped will not be required in the future. Also, immediately before and after dropping a tablespac e from a database, back up the database completely. This is strongly recommended so that you can recover the database if you mistakenly drop a tablespace, or if the database experiences a problem in the future after the tablespace has been dropped.

When you drop a tablespace, the file pointers in the control file of the associated database are removed. You can optionally direct Oracle Database to delete the operating system files (datafiles) t hat constituted the dropped tablespace. If you do not direct the database to delete the datafiles at the same time that it deletes th e tablespace, you must later use the appropriate commands of your operating system to delete them.

You cannot drop a tablespac e that contains any active segments. For example, if a table in the tablespace is currently being used or the tablespace contains und o data needed to roll back uncommitted transactions, you cannot drop the tablespace. The tablespace can be online or offline, but it is best to take the tablespace offline before dropping it.

To drop a tablespace, use the DROP TABLESPACE statemen t. The following statement drops the users tablespace, including the segments in the tablespace:

DROP TABLESPACE users INCLUDING CONTENTS;

<
/pre>

If the tablespace is empty (does not contain any tables, views, or other structures), you do not need to specify the INCLUDING CONTENTS clause. Use the CASCADE CONSTRAINTS clause to drop all referential integrity constraints from tables outside the tablespace that refer to primary and unique keys of tables inside the tablespace.

To delete the datafiles a ssociated with a tablespace at the same time that the tablespace is dropped, use the INCLUDING CONTENTS AND DATAFILES cl ause. The following statement drops the users tablespace and its associated datafiles:

DRO
P TABLESPACE users INCLUDING CONTENTS AND DATAFILES;

A message is written to the alert file for each datafile that is del eted. If an operating system error prevents the deletion of a file, the DROP TABLESPACE statement still succeeds, but a message describing the error is written to the alert file.

Managing th e SYSAUX Tablespace

The SYSAUX tablespace was installed as an au xiliary tablespace to the SYSTEM tablespace when you created your database. Some database components that formerly creat ed and used separate tablespaces now occupy the SYSAUX tablespace.

If the SYSAUX tablespace becomes unavailable, core database functionality will remain operational. The database features that use the SYSAUX tablespace c ould fail, or function with limited capability.

Monitoring Occupants of the SYSAUX Tablespace

The list of registered occupants of the SYSAUX tablespace are discussed in "Cr eating the SYSAUX Tablespace". These components can use the SYSAUX tablespace, and their installation provides the m eans of establishing their occupancy of the SYSAUX tablespace.

You can monitor the occupants of the SYSAUX< /code> tablespace using the V$SYSAUX_OCCUPANTS view. This view lists the following information about the occupants of th e SYSAUX tablespace:

  • Name of the occupant

  • Occupant description

  • Schema name

  • Move procedure

  • Current space usag e

View information is maintained by the occupants.


See Also:

Oracle Database Reference for a detailed description of the V$SYSAUX_OCCUPANTS view

Moving Occupants Out Of or Into the SYSAUX Tablespace

You will have an option at component install time to specify that you do not want the component to reside in SYSAUX. Also, if you later decide that the component should be relocated to a designated tablespace, you can use the move procedure for that component, as specified in the V$SYSAUX_OCCUPANTS view, to perform the move.

For example, assume that you install Oracle Ultra Search into t he default tablespace, which is SYSAUX. Later you discover that Ultra Search is using up too much space. To alleviate th is space pressure on SYSAUX, you can call a PL/SQL move procedure specified in the V$SYSAUX_OCCUPANTS view to relocate Ultra Search to another tablespace.

The move procedure also lets you move a component from another tablespace into the SYSAUX tablespace.

Controlling the Size of the SYSAU X Tablespace

The SYSAUX tablespace is occupied by a number of database components (see Table 2-2), and its total size is governed by the space consumed by those components. The space consumed by the compo nents, in turn, depends on which features or functionality are being used and on the nature of the database workload.

The larg est portion of the SYSAUX tablespace is occupied by the Automatic Workload Repository (AWR). The space consumed by the A WR is determined by several factors, including the number of active sessions in the system at any given time, the snapshot interval, and the historical data retention period. A typical system with an average of 30 concurrent active sessions may require approximately 200 to 300 MB of space for its AWR data. You can control the size of the AWR by changing the snapshot interval and historical data r etention period. For more information on managing the AWR snapshot interval and retention period, please refer to Oracle Database Performance Tuning Guide.

Anot her major occupant of the SYSAUX tablespace is the embedded Enterprise Manager (EM) repository. This repository is used by Oracle Enterprise Manager Database Control to store its metadata. The size of this repository depends on database activity and on configuration-related information stored in the repository.

Other database components in the SYSAUX tablespace wi ll grow in size only if their associated features (for example, Oracle UltraSearch, Oracle Text, Oracle Streams) are in use. If the f eatures are not used, then these components do not have any significant effect on the size of the SYSAUX tablespace.

Diagnosing and Repairing Locally Managed Ta blespace Problems


Note:

The DBMS_SPACE_ADMIN package provides administrators with defect diagnos is and repair functionality for locally managed tablespaces. It cannot be used in this capacity for dictionary-managed tablespaces.

It also provides procedures for migrating from dictionary- managed tablespaces to locally managed tablespaces, and the reverse.


The DBMS_SPACE_ADM IN package contains the following procedures:

< font face="Arial, Helvetica, sans-serif">Procedure Description
SEGMENT_VERIFY Verifies the consistency of the extent map of the segment.
SEGMENT_CORRUPT Marks the segment corrupt or valid so that app ropriate error recovery can be done. Cannot be used for a locally managed SYSTEM tablespace.
SEGMENT_DROP_CORRUPT Drops a segment currently marked corrupt (without reclaiming space). Cannot be used for a locally managed SYSTEM tablespace.
SEGMENT_DUMP Dumps the segment header and extent map of a given segment.
TABLESPACE_VERIFY Verifies that the bitmaps and extent maps for the segments in the tablespace are in sync.
TABLESPACE_REBUILD_BITMAPS Rebuilds the appropriate bitmap. Cannot be used for a locally managed SYSTEM tablespace.
TABLESPACE_FIX_BITMAPS Marks the appropriate data block address range (extent) as free or used in bitmap. Cannot be us ed for a locally managed SYSTEM tablespace.
TABLESPACE_REBUILD_QUOTAS Rebuilds quotas for given tab lespace.
TABLESPACE_MIGRATE_FROM_LO CAL Migrates a locally managed tablespace to dictionary-managed tablespace. Cannot be used to migrate a locally managed SYSTEM tablespace to a dictionary-managed SYSTEM tablespace.
TABLESPACE_MIGRATE_TO_LOCAL Migrates a tablespace from dictionary-managed format to locally managed format.
TABLESPACE_RELOCATE_BITMAPS Relocates the bitmaps to the destination specified. Cannot be used for a locally mana ged system tablespace.
TABLESPACE_F IX_SEGMENT_STATES Fixes the state of the segments in a tablespace in which migration was aborted.

The following scenarios descr ibe typical situations in which you can use the DBMS_SPACE_ADMIN package to diagnose and resolve problems.


< tr>

Note:

Some of these procedures can res ult in lost and unrecoverable data if not used properly. You should work with Oracle Support Services if you have doubts about these procedures.


See Also:

PL/SQL Packages and Types Reference for details about the DBMS_SPACE_ADMIN package

Scenario 1: Fixing Bitmap When Allocated Blocks are Marked Free (No Overlap)

The TABLESPACE_VERIFY procedure discovers that a segment has allocated blocks that are marked fr ee in the bitmap, but no overlap between segments is reported.

In this scenario, perform the following tasks:

  1. Call the SEGMENT_DUMP procedure to dump the ranges that the administrator allocated to the segment.< /p>

  2. For each range, call the TABLESPACE_FIX_BITMAPS procedure with the TABLESPACE_EXTENT_MAKE_USED option to mark the space as used.

  3. Call TABLESPACE_REBUILD_QUOTAS to fix up quotas.

Scenario 2: Dropping a Corrupted Segment

You cannot drop a segment because the bitmap has segment b locks marked "free". The system has automatically marked the segment corrupted.

In this scenario, perform the following tasks:

  1. Call the SEGMENT_VERIFY procedure with the SEGMENT_VERIFY_EXTENTS_GLOBAL option. If no overlaps are reported, then proceed with steps 2 through 5.

  2. Call the SEGMENT_DUMP proc edure to dump the DBA ranges allocated to the segment.

  3. For each range, call TABLESPACE_FIX_BITMAPS with the TABLESPACE_EXTENT_MAKE_FREE option to mark the space as free.

  4. Call SEGMENT_DROP_CORRUPT to drop the SEG$ entry.

  5. Call TABLESPACE_REBUILD_QUOTAS to fix up quotas.

< /div>

Scenario 3: Fixing Bitmap Where Overlap is Reported

The TABLESPACE_VERIFY procedure r eports some overlapping. Some of the real data must be sacrificed based on previous internal errors.

After choosing the object to be sacrificed, in this case say, table t1, perform the following tasks:

  1. Make a l ist of all objects that t1 overlaps.

  2. Drop table t1. If necessary, follow up by calling the SEGMENT_DROP_CORRUPT procedure.

  3. Call the SEGMENT_VERIFY procedure on all objects that t1 overlapped. If necessary, call the TABLESPACE_FIX_BITMAPS procedure to mark appropriate bitmap blocks as us ed.

  4. Rerun the TABLESPACE_VERIFY procedure to verify the problem is resolved.

Scenario 4: Correcting Media Corruption of Bitmap Blocks

A set of bitmap blocks has media corruption.

I n this scenario, perform the following tasks:

  1. Call the TABLESPACE_REBUILD_BITMAPS pr ocedure, either on all bitmap blocks, or on a single block if only one is corrupt.

  2. Call the TABLESPACE_REBUILD _QUOTAS procedure to rebuild quotas.

  3. Call the TABLESPACE_VERIFY procedure to verify that the bit maps are consistent.

Scenario 5: Migrating from a Dictionary-Managed to a Locally Managed Tablespac e

You migrate a dictionary-managed tablespace to a locally managed tablespace. You use the TABLESPACE_MIGRATE_TO _LOCAL procedure. This operation is done online, but space management operations are blocked pending completion of the migrati on. In other words, you can read or modify data while the migration is in progress, but if you are loading a large amount of data tha t requires the allocation of additional extents, then the operation may be blocked.

Let us assume that the database block size is 2K, and the existing extent sizes in tablespace tbs_1 are 10, 50, and 10,000 blocks (used, used, and free). The MINIMUM EXTENT value is 20K (10 blocks). In this scenario, you allow the bitmap allocation unit to be chosen by the system. The value of 10 blocks is chosen, because it is the highest common denominator and does not exceed MINIMUM EXTENT.

< p>The statement to convert tbs_1 to a locally managed tablespace is as follows:

EXEC DBMS_
SPACE_ADMIN.TABLESPACE_MIGRATE_TO_LOCAL ('tbs_1');

If you choose to specify an allocation unit size, it must be a factor of the unit size calculated by the system, otherwise an error message is issued.

Migrating the SYSTEM Tablespace to a Locally Managed Tablespace

Use the DBMS_SPAC E_ADMIN package to migrate the SYSTEM tablespace from dictionary-managed to locally managed. The following statement performs the migration:

SQL> EXECUTE DBMS_SPACE_ADMIN.T
ABLESPACE_MIGRATE_TO_LOCAL('SYSTEM');

Before performing the migration the following conditions must be met:

  • The database has a default temporary tablespace that is not SYSTEM.

  • There a re no rollback segments in dictionary-managed tablespaces.

  • There is at least one online rollback segment in a locally managed tablespace, or if using automatic undo management, an undo tablespace is online.

  • A ll tablespaces other than the tablespace containing the undo space (that is, the tablespace containing the rollback segment or the un do tablespace) are in read-only mode.

  • There is a cold backup of the database.

  • The system is in restricted mode.

All of these conditions, except for the cold backup, are enforced by the TABLESPACE_MIGRATE_TO_LOCAL procedure.


< /tr>

Note:

After the SYSTEM tablespace is migrated to locally managed, any dictionary-managed tablespace s in the database cannot be made read/write. If you want to be able to use the dictionary-managed tablespaces in read/write mode, Ora cle recommends that you first migrate these tablespaces to locally managed before migrating the SYSTEM tablespace.

Transp orting Tablespaces Between Databases

This section describes how to transport tablespaces between databases, and contains the following topics:

Introduction to Transportable Tablespaces


Note:

You must be using the Enterprise Edition of Oracle8i or higher to generate a transportable tablespace set. However, you can use any edition of Oracle8i or higher to plug a transportable tablespace set into an Oracle Database on the same platform. To plug a transportable tablespace set into an Oracle Database on a different platform, both databases must have compatibility set to at least 10.0. Please refer to "Compatibility Considerations for T ransportable Tablespaces" for a discussion of database compatibility for transporting tablespaces across release levels.

You can use the transpor table tablespaces feature to move a subset of an Oracle Database and "plug" it in to another Oracle Database, essentially moving tabl espaces between the databases. The tablespaces being transported can be either dictionary managed or locally managed. Starting with O racle9i, the transported tablespaces are not required to be of the same block size as the target database standard block siz e.

Moving data using transportable tablespaces is much faster than performing either an export/import or unload/load of the sa me data. This is because the datafiles containing all of the actual data are simply copied to the destination location, and you use a n import utility to transfer only the metadata of the tablespace objects to the new database.


< font face="arial, helvetica, sans-serif">Note:

The remainder of this chapter uses Data Pump as the import /export utility to use. However, the transportable tablespaces feature supports both Data Pump and the original import and export uti lities. Please refer to Oracle Database Utilities for m ore information on these utilities.

The transportable tab lespace feature is useful in a number of scenarios, including:

  • Exporting and importing partitions in dat a warehousing tables

  • Publishing structured data on CDs

  • Copying multiple rea d-only versions of a tablespace on multiple databases

  • Archiving historical data

  • Performing tablespace point-in-time-recovery (TSPITR)

These scenarios are discussed in "Usi ng Transportable Tablespaces: Scenarios"


< /table>

About Transport ing Tablespaces Across Platforms

Starting with Oracle Database 10g, you can transport tablespaces across plat forms. This functionality can be used to:

  • Allow a database to be migrated from one platform to another

  • Provide an easier and more efficient means for content providers to publish structured data and distribut e it to customers running Oracle Database on different platforms

  • Simplify the distribution of data from a data warehouse environment to data marts, which are often running on smaller platforms

  • Enable the shar ing of read-only tablespaces between Oracle Database installations on different operating systems or platforms, assuming that your st orage system is accessible from those platforms and the platforms all have the same endianness, as described in the sections that fol low

Many, but not all, platforms are supported for cross-platform tablespace transport. You can query the V$TR ANSPORTABLE_PLATFORM view to see the platforms that are supported, and to determine their platform IDs and their endian format (byte ordering). For example, the following query displays the currently supported platforms:

SQL>
COLUMN PLATFORM_NAME FORMAT A30
SQL> SELECT * FROM V$TRANSPORTABLE_PLATFORM;

PLATFORM_ID PLATFORM_NAME                  ENDIAN_FO
RMAT
----------- ------------------------------ --------------
          1 Solaris[tm] OE (32-bit)        Big
          2 Solaris[tm]
 OE (64-bit)        Big
          7 Microsoft Windows NT           Little
         10 Linux IA (32-bit)              Little
 6 AIX-Based Systems (64-bit)     Big
          3 HP-UX (64-bit)                 Big
          5 HP Tru64 UNIX                  Littl
e
          4 HP-UX IA (64-bit)              Big
         11 Linux IA (64-bit)              Little
         15 HP Open VMS
         Little

10 rows selected.

If the source platform and the target platform are of different endianness, then an ad ditional step must be done on either the source or target platform to convert the tablespace being transported to the target format. If they are of the same endianness, then no conversion is necessary and tablespaces can be transported as if they were on the same pl atform.

Before a tablespace can be transported to a different platform, the datafile header must identify the platform to whic h it belongs. In an Oracle Database with compatibility set to 10.0.0 or higher, you can accomplish this by making the datafile read/w rite at least once.

Limitations on Transportable Tablespace Use

Be aware of the following limitations as you plan to transport tablespaces:

  • The source and target database must use the same character set and national character set.

  • You cannot transport a tablespace to a target database in which a tablespace with the same name already exists. However, you can rename either the tablespace to be transported or the destination tablespace before the transport operation.

  • Objects with underlying objects (such as materialized views) or contained objects (such as partitioned tables) are not tran sportable unless all of the underlying or contained objects are in the tablespace set.

Most database entities, such as data in a tablespace or structural information associated with the tablespace, behave normally after being transported to a differ ent database. Some exceptions arise with the following entities:


Advance d Queues

Transportable tablespaces do not support 8.0-compatible advanced queues with multiple recipients.
SYSTEM Tablespace Objects

You cannot transport t he SYSTEM tablespace or objects owned by the user SYS. Some examples of such objects are PL/SQL, Java classes, callouts, views, synon yms, users, privileges, dimensions, directories, and sequences.


Opaque T ypes

Types whose interpretation is application-specific and opaque to the database (such as RAW , BFILE, and the AnyTypes) can be transported, but they are not converted as part of the cross-platform transport operat ion. Their actual structure is known only to the application, so the application must address any endianness issues after these types are moved to the new platform. Types and objects that use these opaque types, either directly or indirectly, are also subject to thi s limitation.


Floating-Point Numbers

BINA RY_FLOAT and BINARY_DOUBLE types are transportable using Data Pump but not using the original export utility.

Compatibility Considerations for Transportable Tablespaces

When you create a transportable tablespace set, Oracle Database computes the lowest compati bility level at which the target database must run. This is referred to as the compatibility level of the transportable set. Beginnin g with Oracle Database 10g, a tablespace can always be transported to a database with the same or higher compatibility setti ng, whether the target database is on the same or a different platform. The database signals an error if the compatibility level of t he transportable set is higher than the compatibility level of the target database.

The following table shows the minimum comp atibility requirements of the source and target tablespace in various scenarios. The source and target database need not have the sam e compatibility setting.

Table 8-1 Minimum Compatibility Requirements

See Also:

Oracle Data Warehousing Guide for information about using transportable tablespaces in a data warehousing environment
Transport Scenario Minimum Compatibili ty Setting
Source Database Target Database
Databases on the same platform 8.0 8 .0
Tablespace with different data base block size than the target database 9.0 9.0
Data bases on different platforms 10.0 10.0

Transporting Tablespaces Between Databases: A Procedure and Example

To move or copy a set of tablespaces, perform the following steps.

  1. For cross-platform transpor t, check the endian format of both platforms by querying the V$TRANSPORTABLE_PLATFORM view.

    If you are transporti ng the tablespace set to a platform different from the source platform, then determine if the source and target platforms are support ed and their endianness. If both platforms have the same endianness, no conversion is necessary. Otherwise you must do a conversion o f the tablespace set either at the source or target database.

    Ignore this step if you are transporting your tablespace set to the same platform.

  2. Pick a self-contained set of tablespaces.

  3. Generate a transportable tablespace se t.

    A transportable tablespace set consists of datafiles for the set of tablespaces being transported and an export file contai ning structural information for the set of tablespaces.

    If you are transporting the tablespace set to a platform with differen t endianness from the source platform, you must convert the tablespace set to the endianness of the target platform. You can perform a source-side conversion at this step in the procedure, or you can perform a target-side conversion as part of step 4.

  4. Transport the tablespace set.

    Copy the datafiles and the export file to the target database. You can do this using any faci lity for copying flat files (for example, an operating system copy utility, ftp, the DBMS_FILE_COPY package, or publishi ng on CDs).

    If you have transported the tablespace set to a platform with different endianness from the source platform, and y ou have not performed a source-side conversion to the endianness of the target platform, you should perform a target-side conversion now.

  5. Plug in the tablespace.

    Invoke the Data Pump utility to plug the set of tablespaces into the target data base.

These steps are illustrated more fully in the example that follows, where it is assumed the following datafile s and tablespaces exist:

< /tr>
Tablespace Datafile:
sales_1 /u01/oracle/oradata/salesdb/sales_101.dbf
sales_2 /u01/oracle/oradata/salesdb/sales_201.dbf

St ep 1: Determine if Platforms are Supported and Endianness

This step is only necessary if you are transporting the tabl espace set to a platform different from the source platform. If sales_1 and sales_2 were being transported to a different platform, you can execute the following query on both platforms to determine if the platforms are supported and their endian formats:

SELECT d.PLATFORM_NAME, ENDIAN_FORMAT
     FROM V$TRANSPORTABLE_PLATFORM tp, V$DATABASE
 d
     WHERE tp.PLATFORM_NAME = d.PLATFORM_NAME;

The following is the query result from the source platform:

PLATFORM_NAME             ENDIAN_FORMAT
------------------------- --------------
Solaris[tm] OE (32-bit)   Big



The following is the result from the target platform:

PLATFORM_NAME             ENDIAN_FORMAT
------------------------- --------------
Microsoft Windows NT      Little

You can see that the endian formats are differe nt and thus a conversion is necessary for transporting the tablespace set.

Step 2: Pick a Self-Contained Set of Tablespaces

There may be logical or physical dependencies between objects in the transportable set and those outsid e of the set. You can only transport a set of tablespaces that is self-contained. In this co ntext "self-contained" means that there are no references from inside the set of tablespaces pointing outside of the tablespaces. Som e examples of self contained tablespace violations are:

  • An index inside the set of tablespaces is for a table outside of the set of tablespaces.


    Note :

    It is not a violation if a corresponding index for a table is outside of the set of tablespaces.

  • A partitioned table is partially contained in the set of tablespaces.

    The tablespace set you want to copy must contain either all partitions of a partitioned table, or none of the partitions of a partitioned table. If you want to transport a subset of a partition table, you must exchange the partitions into tables.

  • A referential integrity constraint points to a table across a set boundary.

    When transpo rting a set of tablespaces, you can choose to include referential integrity constraints. However, doing so can affect whether or not a set of tablespaces is self-contained. If you decide not to transport constraints, then the constraints are not considered as pointe rs.

  • A table inside the set of tablespaces contains a LOB column that points to LOBs outside the set of tablespaces.

To determine whether a set of tablespaces is self-contained, you can invoke th e TRANSPORT_SET_CHECK procedure in the Oracle supplied package DBMS_TTS. You must have been granted the EXECUTE_CATALOG_ROLE role (initially signed to SYS) to execute this procedure.

When you invoke the DBMS_TTS package, you specify the list of tablespaces in the transportable set to be checked for self containment. You can o ptionally specify if constraints must be included. For strict or full containment, you must additionally set the TTS_FULL_CHECK parameter to TRUE.

The strict or full containment check is for cases that require capturing not only refe rences going outside the transportable set, but also those coming into the set. Tablespace Point-in-Time Recovery (TSPITR) is one suc h case where dependent objects must be fully contained or fully outside the transportable set.

For example, it is a violation to perform TSPITR on a tablespace containing a table t but not its index i because the index and data will be inconsistent after the transport. A full containment check ensures that there are no dependencies going outside or coming into the transportable set. See the example for TSPITR in the Oracle Dat abase Backup and Recovery Advanced User's Guide.


Note:

The default for transportable tablespaces is to check for self containment rather than full co ntainment.

The following statement can be used to determi ne whether tablespaces sales_1 and sales_2 are self-contained, with referential integrity constraints taken into consideration (indicated by TRUE).

EXECUTE DBMS_TTS.TRANSPORT_SET_CHECK('sales_1,sal
es_2', TRUE);

After invoking this PL/SQL package, you can see all violations by selecting from the TRANSPORT_SET_VI OLATIONS view. If the set of tablespaces is self-contained, this view is empty. The following example illustrates a c ase where there are two violations: a foreign key constraint, dept_fk, across the tablespace set boundary, and a partiti oned table, jim.sales, that is partially contained in the tablespace set.

SQL> SELECT *
 FROM TRANSPORT_SET_VIOLATIONS;

VIOLATIONS
---------------------------------------------------------------------------
Constraint DE
PT_FK between table JIM.EMP in tablespace SALES_1 and table
JIM.DEPT in tablespace OTHER
Partitioned table JIM.SALES is partially con
tained in the transportable set

These violations must be resolved before sales_1 and sales_2 ar e transportable. As noted in the next step, one choice for bypassing the integrity constraint violation is to not export the integrit y constraints.


See Also:


Step 3: Generate a Transportable Tablespace Set

Any privileged user can per form this step. However, you must have been assigned the EXP_FULL_DATABASE role to perform a transportable tablespace ex port operation.

After ensuring you have a self-contained set of tablespaces that you want to transport, generate a transportab le tablespace set by performing the following actions:

  1. Make all tablespaces in the set you are co pying read-only.

    SQL> ALTER TABLESPACE sales_1 READ ONLY;
    
    Tablespace altered.
    
    SQL> ALTER TABLES
    PACE sales_2 READ ONLY;
    
    Tablespace altered.
    
    
  2. Invoke the Data Pump export utility on the host system and specify which tablespaces are in the transportable set.

    SQL> HOST
    
    $ EXPDP system/password DUMPFIL
    E=expdat.dmp DIRECTORY=dpump_dir 
            TRANSPORT_TABLESPACES = sales_1,sales_2
    
    

    You must always specify TRANSPORT _TABLESPACES, which determines the mode of the export operation. In this example:

    • The DUMPF ILE parameter specifies the name of the structural information export file to be created, expdat.dmp.

    • The DIRECTORY parameter specifies the default directory object that points to the operating system loc ation of the dump file. You must create the DIRECTORY object before invoking Data Pump, and you must grant REWRITE object privilege on the directory to PUBLIC.

    • Triggers and indexes are included in t he export operation by default.

    If you want to perform a transport tablespace operation with a strict containment ch eck, use the TRANSPORT_FULL_CHECK parameter, as shown in the following example:

    EXPDP 
    system/password DUMPFILE=expdat.dmp DIRECTORY = dpump_dir 
          TRANSPORT_TABLESPACES=sales_1,sales_2 TRANSPORT_FULL_CHECK=Y
    
    <
    /pre>
    
    

    In this example, the Data Pump export utility verifies that there are no dependencies between the objects inside the transp ortable set and objects outside the transportable set. If the tablespace set being transported is not self-contained, then the export fails and indicates that the transportable set is not self-contained. You must then return to Step 1 to resolve all violations.


    Notes:

    The Data Pump utility is used to export only data dictionary structural information (metadata) for the tablespaces. No actual data is unloaded, so this ope ration goes relatively quickly even for large tablespace sets.

  3. When finished, exit back to SQL*Plus:

    $ EXIT
    

    See Also:

    Oracle Database Utilities for information about using the Data Pump utility

If sales_1 and sales_2 ar e being transported to a different platform, and the endianness of the platforms is different, and if you want to convert before tran sporting the tablespace set, then convert the datafiles composing the sales_1 and sales_2 tablespaces:

  1. From SQL*Plus, return to the host system:

    SQL> HOST
    
    
  2. The RMAN CONVERT command is used to do the conversion. Connect to RMAN:

    $ RMAN TARGE
    T /
    
    Recovery Manager: Release 10.1.0.0.0 
    
    Copyright (c) 1995, 2003, Oracle Corporation.  All rights reserved.
    
    connected to target
    database: salesdb (DBID=3295731590)
    
    
  3. Convert the datafiles into a temporary location on the source platform. In this example, assume that the temporary location, directory /temp, has already been created. The converted datafiles are assigned names by the system.

    RMAN> CONVERT TABLESPACE sales_1,sales_2 
    2> TO PLATFORM 'Microsof
    t Windows NT'
    3> FORMAT '/temp/%U';
    
    Starting backup at 08-APR-03
    using target database control file instead of recovery catalog
    a
    llocated channel: ORA_DISK_1
    channel ORA_DISK_1: sid=11 devtype=DISK
    channel ORA_DISK_1: starting datafile conversion
    input datafile
    fno=00005 name=/u01/oracle/oradata/salesdb/sales_101.dbf
    converted datafile=/temp/data_D-10_I-3295731590_TS-ADMIN_TBS_FNO-5_05ek24v5
    channel ORA_DISK_1: datafile conversion complete, elapsed time: 00:00:15
    channel ORA_DISK_1: starting datafile conversion
    input dataf
    ile fno=00004 name=/u01/oracle/oradata/salesdb/sales_101.dbf
    converted datafile=/temp/data_D-10_I-3295731590_TS-EXAMPLE_FNO-4_06ek24v
    l
    channel ORA_DISK_1: datafile conversion complete, elapsed time: 00:00:45
    Finished backup at 08-APR-03
    

    See Also:

    Oracle Database Recovery Manager Reference for a description of the RM AN CONVERT command

  4. Exit recove ry manager:

    RMAN> exit
    Recovery Manager complete.
    

Step 4: Tran sport the Tablespace Set

Transport both the datafiles and the export file of the tablespaces to a place acces sible to the target database. You can use any facility for copying flat files (for example, an operating system copy utility, ftp, th e DBMS_FILE_TRANSFER package, or publishing on CDs).



If you are transporting the tablespace set to a platform with endianness that i s different from the source platform, and you have not yet converted the tablespace set, you must do so now. This example assumes tha t you have completed the following steps before the transport:

  1. Set the source tablespaces to be t ransported to be read-only.

  2. Use the export utility to create an export file (in our example, expdat.dmp).

  3. Datafiles that are to be converted on the target platform can be moved to a temporary location on the target platform. However , all datafiles, whether already converted or not, must be moved to a designated location on the target database.

    Now use RMAN to convert the necessary transported datafiles to the endian format of the destination host format and deposit the results in /oraho me/dbs, as shown in this hypothetical example:

    RMAN> CONVERT DATAFILE 
    2> '/hq/finance/work/tru/t
    bs_31.f',
    3> '/hq/finance/work/tru/tbs_32.f',
    4> '/hq/finance/work/tru/tbs_41.f'
    5> TO PLATFORM="Solaris[tm] OE (32-bit)"
    6&
    gt; FROM PLATFORM="HP TRu64 UNIX"
    7> DBFILE_NAME_CONVERT=
    8> "/hq/finance/work/tru/", "/hq/finance/dbs/tru"
    9> PARALLELISM=5
    ;
    
    

    You identify the datafiles by filename, not by tablespace name. Until the datafiles are plugged in, the local instance has no way of knowing the desired tablespace names. The source and destination platforms are optional. RMAN determines the source pla tform by examining the datafile, and the target platform defaults to the platform of the host running the conversion.


Caution:

Exercise caution when using the UNIX dd utility to copy raw-device fil es between databases. The dd utility can be used to copy an entire source raw-device file, or it can be invoked with opt ions that instruct it to copy only a specific range of blocks from the source raw-device file.

It is difficult to ascertain actua l datafile size for a raw-device file because of hidden control information that is stored as part of the datafile. Thus, it is advis able when using the dd utility to specify copying the entire source raw-device file contents.

See Also:

"Copying Files Using the Database Server" for information about using the DBMS_FILE_TRANSFER package to copy the files that are being transported and their metadata

Step 5: Plug In the Tablespace Set


Note:

If you are transporting a tablespace of a different block size than the standard block size of the database receiving the tablespace set, then you must fi rst have a DB_nK_CACHE_SIZE initialization parameter entry in the receiving database parameter file.

For example, if you are transporting a tablespace with an 8K block size into a database with a 4K standard block size, then you must include a DB_8K_CACHE_SIZ E initialization parameter entry in the parameter file. If it is not already included in the parameter file, this parameter ca n be set using the ALTER SYSTEM SET statement.

See Oracle Database Reference for information about specifying values for the DB_< em>nK_CACHE_SIZE initialization parameter.


Any privileged user can perform this step. To plug in a tablespace set, perform the following tasks:

  1. Plug in the tablespaces and integrate the structural information using the Data Pump Import utility, i mpdp:

    IMPDP system/password DUMPFILE=expdat.dmp DIRECTORY=dpump_dir
       TRANSPORT_DATAFILES=
       /
    salesdb/sales_101.dbf,
       /salesdb/sales_201.dbf
       REMAP_SCHEMA=(dcranney:smith) REMAP_SCHEMA=(jfee:williams)
    
    

    In this ex ample we specify the following:

    • The DUMPFILE parameter specifies the exported file containi ng the metadata for the tablespaces to be imported.

    • The DIRECTORY parameter specifies the d irectory object that identifies the location of the dump file.

    • The TRANSPORT_DATAFILES para meter identifies all of the datafiles containing the tablespaces to be imported.

    • The REMAP_SCHEMA< /code> parameter changes the ownership of database objects. If you do not specify REMAP_SCHEMA, all database objects (su ch as tables and indexes) are created in the same user schema as in the source database, and those users must already exist in the ta rget database. If they do not exist, then the import utility returns an error. In this example, objects in the tablespace set owned b y dcranney in the source database will be owned by smith in the target database after the tablespace set is plugged in. Similarly, objects owned by jfee in the source database will be owned by williams in the targe t database. In this case, the target database is not required to have users dcranney and jfee, but must hav e users smith and williams.

    After this statement executes successfully, all tablespaces in the set being copied remain in read-only mode. Check the import logs to ensure that no error has occurred.

    When dealing with a large number of datafiles, specifying the list of datafile names in the statement line can be a laborious process. It can even exce ed the statement line limit. In this situation, you can use an import parameter file. For example, you can invoke the Data Pump impor t utility as follows:

    IMPDP system/password PARFILE='par.f'
    
    

    where the parameter file, par.f contains the following:

    DIRECTORY=dpump_dir
    DUMPFILE=expdat.dmp
    TRANSPORT_DATAFILES="'/db
    /sales_jan','/db/sales_feb'"
    REMAP_SCHEMA=dcranney:smith
    REMAP_SCHEMA=jfee:williams
    

    < font face="arial, helvetica, sans-serif">See Also:

    Oracle Database Utilities for information about using the import utility

  2. If required, put the tablespaces into read/write mode as follows:

    ALTER TABLESPACE sales_1 READ WRITE;
    ALTER TABLESPACE sales_2 READ WRITE;
    

Using Transportable Tablespaces: Scenarios

The following sections describe some uses for transportable tablespaces:

Transporting and Attaching Partitions for Data Warehousing

Typical enterprise data warehouses contain one or more large fact tables. These fact tables can be partitioned by date, making the enterprise data warehouse a historical database. Yo u can build indexes to speed up star queries. Oracle recommends that you build local indexes for such historically partitioned tables to avoid rebuilding global indexes every time you drop the oldest partition from the historical database.

Suppose every month you would like to load one month of data into the data warehouse. There is a large fact table in the data warehouse called sal es, which has the following columns:

CREATE TABLE sales (invoice_no NUMBER,
   sale_year  INT NO
T NULL,
   sale_month INT NOT NULL,
   sale_day   INT NOT NULL)
   PARTITION BY RANGE (sale_year, sale_month, sale_day)
     (partiti
on jan98 VALUES LESS THAN (1998, 2, 1),
      partition feb98 VALUES LESS THAN (1998, 3, 1),
      partition mar98 VALUES LESS THAN (
1998, 4, 1),
      partition apr98 VALUES LESS THAN (1998, 5, 1),
      partition may98 VALUES LESS THAN (1998, 6, 1),
      partitio
n jun98 VALUES LESS THAN (1998, 7, 1));

You create a local nonprefixed index:

CREATE INDEX
sales_index ON sales(invoice_no) LOCAL;

Initially, all partitions are empty, and are in the same default tablespace. Each month, you want to create one partition and attach it to the partitioned sales table.

Suppose it is July 1998, a nd you would like to load the July sales data into the partitioned table. In a staging database, you create a new tablespace, t s_jul. You also create a table, jul_sales, in that tablespace with exactly the same column types as the sal es table. You can create the table jul_sales using the CREATE TABLE ... AS SELECT statement. After creating and populating jul_sales, you can also create an index, jul_sale_in dex, for the table, indexing the same column as the local index in the sales table. After building the index, tra nsport the tablespace ts_jul to the data warehouse.

In the data warehouse, add a partition to the sales table for the July sales data. This also creates another partition for the local nonprefixed index:

ALTER TABLE sales ADD PARTITION jul98 VALUES LESS THAN (1998, 8, 1);

Attach the transported table jul_sales to the table sales by exchanging it with the new partition:

ALTER TABLE sales EXCHANGE PA
RTITION jul98 WITH TABLE jul_sales 
   INCLUDING INDEXES
   WITHOUT VALIDATION;

This statement places the July sales data into the new partition jul98, attaching the new data to the partitioned table. This statement also converts the index < code>jul_sale_index into a partition of the local index for the sales table. This statement should return immedia tely, because it only operates on the structural information and it simply switches database pointers. If you know that the data in t he new partition does not overlap with data in previous partitions, you are advised to specify the WITHOUT VALIDATION cl ause. Otherwise, the statement goes through all the new data in the new partition in an attempt to validate the range of that partiti on.

If all partitions of the sales table came from the same staging database (the staging database is never destr oyed), the exchange statement always succeeds. In general, however, if data in a partitioned table comes from different databases, it is possible that the exchange operation may fail. For example, if the jan98 partition of sales did not com e from the same staging database, the preceding exchange operation can fail, returning the following error:

ORA-19728: data object number conflict between table JUL_SALES and partition JAN98 in table SALES

To resolve this co nflict, move the offending partition by issuing the following statement:

ALTER TABLE sales MOVE PARTITI
ON jan98;

Then retry the exchange operation.

After the exchange succeeds, you can safely drop jul_sales and jul_sale_index (both are now empty). Thus you have successfully loaded the July sales data into your data warehou se.

< /a>

Publishing Structured Data on CDs

Transportable tab lespaces provide a way to publish structured data on CDs. A data provider can load a tablespace with data to be published, generate t he transportable set, and copy the transportable set to a CD. This CD can then be distributed.

When customers receive this CD, they can plug it into an existing database without having to copy the datafiles from the CD to disk storage. For example, suppose on a Windows NT machine D: drive is the CD drive. You can plug in a transportable set with datafile catalog.f and export f ile expdat.dmp as follows:

IMPDP system/password DUMPFILE=expdat.dmp DIRECTORY=dp
ump_dir
   TRANSPORT_DATAFILES='D:\catalog.f'  

You can remove the CD while the database is still up. Subsequent queries to the tablespace return an error indicating that the database cannot open the datafiles on the CD. However, operations to other part s of the database are not affected. Placing the CD back into the drive makes the tablespace readable again.

Removing the CD is the same as removing the datafiles of a read-only tablespace. If you shut down and restart the database, the database indicates that it cannot find the removed datafile and does not open the database (unless you set the initialization parameter READ_ONLY_OPEN _DELAYED to TRUE). When READ_ONLY_OPEN_DELAYED is set to TRUE, the database reads the f ile only when someone queries the plugged-in tablespace. Thus, when plugging in a tablespace on a CD, you should always set the READ_ONLY_OPEN_DELAYED initialization parameter to TRUE, unless the CD is permanently attached to the database.< /p>

Mounting the Same Tablespace Read-Only on Multiple Databases

You can use transportable tablespaces to mount a tablespace read-only on multiple databases. In this way, separate databases ca n share the same data on disk instead of duplicating data on separate disks. The tablespace datafiles must be accessible by all datab ases. To avoid database corruption, the tablespace must remain read-only in all the databases mounting the tablespace.

You can mount the same tablespace read-only on multiple databases in either of the following ways:

  • Plug the tab lespace into each of the databases on which you want to mount the tablespace. Generate a transportable set in a single database. Put the datafiles in the transportable set on a disk accessible to all databases. Import the structural information into each database.

  • Generate the transportable set in one of the databases and plug it into other databases. If you use this approach, it is assumed that the datafiles are already on the shared disk, and they belong to an existing tablespace in one of the da tabases. You can make the tablespace read-only, generate the transportable set, and then plug the tablespace in to other databases wh ile the datafiles remain in the same location on the shared disk.

You can make the disk accessible by multiple compu ters in several ways. You can use either a cluster file system or raw disk. You can also use network file system (NFS), but be aware that if a user queries the shared tablespace while NFS is down, the database will hang until the NFS operation times out.

Late r, you can drop the read-only tablespace in some of the databases. Doing so does not modify the datafiles for the tablespace. Thus, t he drop operation does not corrupt the tablespace. Do not make the tablespace read/write unless only one database is mounting the tab lespace.

Archiving Historical Data Using Transportable Tablespaces

Since a transportable tablespace set is a self-contained set of files that can be plugged into any Oracle Database, you c an archive old/historical data in an enterprise data warehouse using the transportable tablespace procedures described in this chapte r.


See Also:

Oracle Data Warehousing Guide for more details

Using Trans portable Tablespaces to Perform TSPITR

You can use transportable tablespaces to perform tablespace point-in-time recov ery (TSPITR).

Moving Databases Across Platforms Using Transportable Tablespaces

You can use the transportable tablespace feature to migrate a databa se to a different platform by creating a new database on the destination platform and performing a transport of all the user tablespa ces.

You cannot transport the SYSTEM tablespace. Therefore, objects such as sequences, PL/SQL packages, and other objects that depend on the SYSTEM tablespace are not transported. You must either create these objects manually on the destination database, or use Data Pump to transport the objects that are not moved by transportable tablespace.

Viewing Tablespace Information

The following d ata dictionary and dynamic performance views provide useful information about the tablespace s of a database.

View Description
V$TABLESPACE Name and number of all tablespaces from th e control file.
DBA_TABLESPACES, USER_TABLESPACES Descriptions of all (or user accessible) tablespa ces.
DBA_TABLESPACE_GROUPS Displays the tablespace groups and the tablespaces that belong to them.
DBA_SEGMENTS, USER_SEGMENTS Information about segments within all (or user accessible) tablespaces.
DBA_EXTENTS, USER_EXTENTS Information about data extents within all (or user accessible) tablespaces.
DBA_FREE_SPACE, USER_FREE_SPACE< /code> Information about free extents within all (or user accessible) tablespaces.< /td>
V$DATAFILE Information about all datafiles, including tablespace number of owning tablespace.
V$TEMPFILE Information about all tempfiles, including tablespace number of owning tablespace.
DBA_DATA_FILES Shows files (datafiles) belonging to tablespaces.
DBA_TEMP_FILES Shows files (tempfiles) belonging to tempor ary tablespaces.
V$TEMP_EXTENT_MAP< /code> Information for all extents in all locally managed temporary tablespaces.
V$TEMP_EXTENT_POOL For locally managed temporary tablespaces: the state of temporary space cached and used for by each instance.
V$TEMP_SPACE_HEAD ER Shows space used/free for each tempfile.
DBA_USERS Default and temporary tablespaces for all users.
DBA_TS_QUOTAS Lists tablespace quotas for all users.
V$SORT_SEGMENT Information about every sort segment in a given instance. The view is only updated when the tablespac e is of the TEMPORARY type.
V$TEMPSEG_USAGE Describes temporary (sort) segment usage by user for temporary or permanent tablespaces.

The following ar e just a few examples of using some of these views.


See Also:

Oracle Database Refer ence for complete description of these views

Example 1: Listing Tablespaces and Default Storage Parameters

To list the names and defa ult storage parameters of all tablespaces in a database, use the following query on the DBA_TABLESPACES view:

SELECT TABLESPACE_NAME "TABLESPACE",
   INITIAL_EXTENT "INITIAL_EXT",
   NEXT_EXTENT "NEXT_EXT",
   MIN_EXTENTS "
MIN_EXT",
   MAX_EXTENTS "MAX_EXT",
   PCT_INCREASE
   FROM DBA_TABLESPACES;

TABLESPACE  INITIAL_EXT  NEXT_EXT  MIN_EXT   MAX_EXT
 PCT_INCREASE  
----------  -----------  --------  -------   -------    ------------ 
RBS             1048576   1048576        2
   40               0
SYSTEM           106496    106496        1        99               1
TEMP             106496    106496        1
        99               0
TESTTBS           57344     16384        2        10               1
USERS             57344     57344
    1        99               1
Example 2: Listing the Datafiles and Associated Tablespaces of a Database

To list the names, sizes, and assoc iated tablespaces of a database, enter the following query on the DBA_DATA_FILES view:

SEL
ECT  FILE_NAME, BLOCKS, TABLESPACE_NAME
   FROM DBA_DATA_FILES;

FILE_NAME                                      BLOCKS  TABLESPACE_NA
ME
------------                               ----------  -------------------
/U02/ORACLE/IDDB3/DBF/RBS01.DBF                  1536
RBS
/U02/ORACLE/IDDB3/DBF/SYSTEM01.DBF               6586  SYSTEM
/U02/ORACLE/IDDB3/DBF/TEMP01.DBF                 6400  TEMP
/U02/OR
ACLE/IDDB3/DBF/TESTTBS01.DBF              6400  TESTTBS
/U02/ORACLE/IDDB3/DBF/USERS01.DBF                 384  USERS

Example 3: Displaying Statistics for Free Space (Extents) of Each Tablespace

To produce statistics about free extents and coalescing activity for each tables pace in the database, enter the following query:

SELECT TABLESPACE_NAME "TABLESPACE", FILE_ID,
   COUNT
(*)    "PIECES",
   MAX(blocks) "MAXIMUM",
   MIN(blocks) "MINIMUM",
   AVG(blocks) "AVERAGE",
   SUM(blocks) "TOTAL"
   FROM DBA_FRE
E_SPACE
GROUP BY TABLESPACE_NAME, FILE_ID;

TABLESPACE    FILE_ID  PIECES   MAXIMUM    MINIMUM  AVERAGE    TOTAL
----------    ------
-  ------   -------    -------  -------   ------
RBS                 2       1       955        955      955      955
SYSTEM
     1       1       119        119      119      119
TEMP                4       1      6399       6399     6399     6399
TESTTBS
          5       5      6364          3     1278     6390
USERS               3       1       363        363      363      363



PIECES shows the number of free space extents in the tablespace file, MAXIMUM and MINIMUM show the largest and smallest contiguous area of space in database blocks, AVERAGE shows the average size in blocks o f a free space extent, and TOTAL shows the amount of free space in each tablespace file in blocks. This query is useful when you are going to create a new object or you know that a segment is about to extend, and you want to make sure that there is enou gh space in the containing tablespace.