# 将数据导入到 Amazon RDS 上的 Oracle
将数据导入 Amazon RDS for Oracle 数据库实例的方式取决于以下各项：
+ 您拥有的数据量
+ 数据库中的数据库对象的数量
+ 数据库中的各种数据库对象
例如，您可以根据需要使用以下工具：
+ Oracle SQL Developer – 导入一个简单的、大小为 20MB 的数据库。
+ Oracle Data Pump – 导入复杂的数据库，或大小为数百 MB 甚至 TB 级的数据库。例如，您可以将表空间从本地数据库传输到 RDS for Oracle 数据库实例。您可以使用 Amazon S3 或 Amazon EFS 来传输数据文件和元数据。有关更多信息，请参阅 [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)、[Amazon EFS 集成](oracle-efs-integration.md) 和 [Amazon S3 集成](oracle-s3-integration.md)。
+ AWS Database Migration Service（AWS DMS）– 无需停机即可迁移数据库。有关 AWS DMS 的更多信息，请参阅 [AWS Database Migration Service 是什么](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)和博文 [Migrating Oracle databases with near-zero downtime using AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/)。
**重要**
在使用前述的迁移技术之前，我们建议您对数据库进行备份。要导入数据，您可以通过创建快照来备份您的 RDS for Oracle 数据库实例。稍后，您可以还原快照。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
对于许多数据库引擎，将继续进行持续复制，直到您已准备好切换到目标数据库。您可以使用 AWS DMS 从同一数据库引擎或其他引擎迁移到 RDS for Oracle。如果您从其他数据库引擎进行迁移，可以使用 AWS Schema Conversion Tool 迁移 AWS DMS 未迁移的架构对象。
**Topics**
+ [使用 Oracle SQL Developer 导入](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)
+ [使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)
+ [使用 Oracle Export/Import 进行导入](Oracle.Procedural.Importing.ExportImport.md)
+ [使用 Oracle SQL\$1Loader 进行导入](Oracle.Procedural.Importing.SQLLoader.md)
+ [使用 Oracle 实体化视图进行迁移](Oracle.Procedural.Importing.Materialized.md)
# 使用 Oracle SQL Developer 导入
Oracle SQL Developer 是 Oracle 发布的一种免费的图形化 Java 工具。SQL Developer 为用户提供了选项，可在两个 Oracle 数据库之间迁移数据，或将数据从其他数据库（如 MySQL）迁移到 Oracle 数据库。此工具最适合用于迁移小型数据库。
您可以将此工具安装到台式计算机 (Windows、Linux 或 Mac) 或服务器上。安装 SQL Developer 后，您可以使用该工具连接至源数据库和目标数据库。可使用“工具”菜单上的**数据库复制**命令将数据复制到 RDS for Oracle 数据库实例。
要下载 SQL Developer，请转到 [ http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer)。
建议您在开始迁移数据前先阅读 Oracle SQL Developer 产品文档。Oracle 还提供关于如何从其他数据库 (包括 MySQL 和 SQL Server) 中迁移数据的文档。有关更多信息，请参阅 Oracle 文档中的 [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration)。
# 使用 Oracle 可传输表空间进行迁移
您可以使用 Oracle 可传输表空间功能，将一组表空间从本地 Oracle 数据库复制到 RDS for Oracle 数据库实例。在物理层，您可以使用 Amazon EFS 或 Amazon S3 将源数据文件和元数据文件传输到目标数据库实例。可传输表空间功能使用 `rdsadmin.rdsadmin_transport_util` 软件包。有关此软件包的语法和语义，请参阅[传输表空间](rdsadmin_transport_util.md)。
有关阐述如何传输表空间的博客文章，请参阅 [Migrate Oracle Databases to AWS using transportable tablespace](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/)，以及 [Amazon RDS for Oracle Transportable Tablespaces using RMAN](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/)。
**Topics**
+ [Oracle 可传输表空间概述](#oracle-migrating-tts.overview)
+ [第 1 阶段：设置源主机](#oracle-migrating-tts.setup-phase)
+ [第 2 阶段：准备完整的表空间备份](#oracle-migrating-tts.initial-br-phase)
+ [第 3 阶段：制作和传输增量备份](#oracle-migrating-tts.roll-forward-phase)
+ [阶段 4：传输表空间](#oracle-migrating-tts.final-br-phase)
+ [第 5 阶段：验证传输的表空间](#oracle-migrating-tts.validate)
+ [第 6 阶段：清理剩余文件](#oracle-migrating-tts.cleanup)
## Oracle 可传输表空间概述
可传输的表空间集由正在传输的表空间集的数据文件和包含表空间元数据的导出转储文件组成。在诸如可传输表空间之类的物理迁移解决方案中，您可以传输物理文件：数据文件、配置文件和 Data Pump 转储文件。
**Topics**
+ [可传输表空间的优缺点](#oracle-migrating-tts.overview.benefits)
+ [可传输表空间的限制](#oracle-migrating-tts.limitations)
+ [可传输表空间的先决条件](#oracle-migrating-tts.requirements)
### 可传输表空间的优缺点
当您需要以最少的停机时间将一个或多个大型表空间迁移到 RDS 时，建议您使用可传输的表空间。与逻辑迁移相比，可传输的表空间具有以下优势：
+ 停机时间低于大多数其他 Oracle 迁移解决方案。
+ 由于可传输表空间功能仅复制物理文件，因此，它避免了在逻辑迁移中可能发生的数据完整性错误和逻辑损坏。
+ 不需要额外的许可证。
+ 您可以跨不同的平台和字节顺序类型迁移一组表空间，例如，从 Oracle Solaris 平台迁移到 Linux。但是，不支持在 Windows 服务器之间传输表空间。
**注意**
Linux 经过充分测试并得到支持。并非所有 UNIX 版本都经过测试。
如果您使用可传输的表空间，则可以使用 Amazon S3 或 Amazon EFS 传输数据：
+ 使用 EFS 时，您的备份在导入期间将保留在 EFS 文件系统中。之后，您可以删除这些文件。在此技术中，您无需为数据库实例预调配 EBS 存储。出于这个原因，我们建议使用 Amazon EFS 而不是 S3。有关更多信息，请参阅 [Amazon EFS 集成](oracle-efs-integration.md)。
+ 使用 S3 时，您可以将 RMAN 备份下载到附加到数据库实例的 EBS 存储。在导入期间，文件将保留在您的 EBS 存储中。导入后，您可以释放此空间，该空间仍保持分配给您的数据库实例。
可传输表空间的主要缺点是您需要相对较高级的 Oracle 数据库知识。有关更多信息，请参见《Oracle 数据库管理员指南》**中的[在数据库之间传输表空间](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB)。
### 可传输表空间的限制
当您在 RDS for Oracle 中使用可传输表空间时，将适用 Oracle 数据库对此功能的限制。有关更多信息，请参见《Oracle 数据库管理员指南》**中的[可传输表空间的限制]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787)和[传输数据的一般限制](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173)。请注意 RDS for Oracle 中可传输表空间的以下其他限制：
+ 源数据库或目标数据库都不能使用标准版 2（SE2）。仅支持企业版。
+ 您不能使用 Oracle Database 11g 数据库作为源。RMAN 跨平台可传输表空间功能依赖于 RMAN 传输机制，而 Oracle Database 11g 不支持该机制。
+ 您无法使用可传输的表空间从 RDS for Oracle 数据库实例迁移数据。您只能使用可传输的表空间将数据迁移到 RDS for Oracle 数据库实例。
+ 不支持 Windows 操作系统。
+ 您无法将表空间传输到较低版本级别的数据库中。目标数据库的版本级别必须与源数据库相同或更高。例如，您无法将表空间从 Oracle Database 21c 传输到 Oracle Database 19c。
+ 您无法传输诸如 `SYSTEM` 和 `SYSAUX` 之类的管理表空间。
+ 您无法传输非数据对象，例如 PL/SQL 软件包、Java 类、视图、触发器、序列、用户、角色和临时表。要传输非数据对象，请手动创建它们或使用 Data Pump 元数据导出和导入。有关更多信息，请参阅 [My Oracle Support Note 1454872.1](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html)。
+ 您无法传输已加密或使用加密列的表空间。
+ 如果您使用 Amazon S3 传输文件，则支持的最大文件大小为 5TiB。
+ 如果源数据库使用诸如 Spatial 等 Oracle 选项，则除非在目标数据库上配置了相同的选项，否则无法传输表空间。
+ 在 Oracle 副本配置中，您无法将表空间传输到 RDS for Oracle 数据库实例。解决方法是，您可以删除所有副本，传输表空间，然后重新创建副本。
### 可传输表空间的先决条件
开始之前，完成以下任务：
+ 查看 My Oracle Support 的以下文档中描述的可传输表空间的要求：
+ [使用跨平台增量备份减少可传输表空间停机时间（文档 ID 2471245.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1)
+ [可传输表空间（TTS）局限性和限制：详细信息、参考和适用的版本（文档 ID 1454872.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1)
+ [可传输表空间（TTS）的主要注意事项 -- 常见疑问和问题（文档 ID 1166564.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1)
+ 计划字节顺序转换。如果您指定源平台 ID，则 RDS for Oracle 会自动转换字节顺序。要了解如何查找平台 ID，请参阅 [Data Guard 对同一 Data Guard 配置中异构主备用服务器和物理备用服务器的支持（文档 ID 413484.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)。
+ 确保在目标数据库实例上启用了可传输表空间功能。只有在运行以下查询时没有出现 `ORA-20304` 错误的情况下，才会启用该功能：
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
如果未启用可传输表空间功能，请重启您的数据库实例。有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
+ 确保源和目标数据库中的时区文件相同。
+ 确保源数据库和目标数据库上的数据库字符集满足以下任一要求：
+ 字符集是相同的。
+ 字符集是兼容的。有关兼容性要求的列表，请参阅 Oracle 数据库文档中的 [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173)。
+ 如果您计划使用 Amazon S3 传输文件，请执行以下操作：
+ 确保 Amazon S3 桶可用于文件传输，并且 Amazon S3 桶与数据库实例处于相同的 AWS 区域中。有关说明，请参阅 *Amazon Simple Storage Service 入门指南* 中的[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html)。
+ 按照[为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md)中的说明为 Amazon RDS 集成准备 Amazon S3 桶。
+ 如果您计划使用 Amazon EFS 传输文件，请确保已按照[Amazon EFS 集成](oracle-efs-integration.md)中的说明配置 EFS。
+ 我们强烈建议您在目标数据库实例中开启自动备份。由于[元数据导入步骤](#oracle-migrating-tts.transport.import-dmp)可能会失败，因此，必须能够将数据库实例还原到其导入前的状态，从而避免需要再次备份、传输和导入表空间。
## 第 1 阶段：设置源主机
在此步骤中，您将复制 My Oracle Support 提供的传输表空间脚本，并设置必要的配置文件。在以下步骤中，*源主机*正在运行包含要传输到*目标实例*的表空间的数据库。
**设置您的源主机**
1. 以 Oracle 主目录的所有者身份登录到您的源主机。
1. 确保 `ORACLE_HOME` 和 `ORACLE_SID` 环境变量指向您的源数据库。
1. 以管理员身份登录数据库，并验证时区版本、数据库字符集和国家/地区字符集是否与目标数据库中相同。
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. 按照 [Oracle 支持说明 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) 中所述，设置可传输表空间实用程序。
安装包括在源主机上编辑 `xtt.properties` 文件。以下示例 `xtt.properties` 文件指定 `/dsk1/backups` 目录中三个表空间的备份。这些是您打算传输到目标数据库实例的表空间。它还指定源平台 ID 以自动转换字节顺序。
**注意**
有关有效的平台 ID，请参阅 [Data Guard 对同一 Data Guard 配置中异构主备用服务器和物理备用服务器的支持（文档 ID 413484.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)。
```
#linux system
platformid=13
#list of tablespaces to transport
tablespaces=TBS1,TBS2,TBS3
#location where backup will be generated
src_scratch_location=/dsk1/backups
#RMAN command for performing backup
usermantransport=1
```
## 第 2 阶段：准备完整的表空间备份
在此阶段中，您将首次备份表空间，将备份传输到目标主机，然后使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 将其还原。此阶段完成后，初始表空间备份将驻留在您的目标数据库实例上，并且可以使用增量备份进行更新。
**Topics**
+ [步骤 1：备份源主机上的表空间](#oracle-migrating-tts.backup-full)
+ [步骤 2：将备份文件传输到您的目标数据库实例](#oracle-migrating-tts.transfer-full)
+ [步骤 3：在目标数据库实例上导入表空间](#oracle-migrating-tts.initial-tts-import)
### 步骤 1：备份源主机上的表空间
在此步骤中，您将使用 `xttdriver.pl` 脚本对表空间进行完整备份。`xttdriver.pl` 的输出存储在 `TMPDIR` 环境变量中。
**备份您的表空间**
1. 如果您的表空间处于只读模式，请以具有 `ALTER TABLESPACE` 权限的用户身份登录到源数据库，并将表空间置于读/写模式。否则，请跳到下一步。
以下示例将 `tbs1`、`tbs2` 和 `tbs3` 置于读/写模式。
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. 使用 `xttdriver.pl` 脚本备份您的表空间。或者，您可以指定 `--debug` 以在调试模式下运行脚本。
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### 步骤 2：将备份文件传输到您的目标数据库实例
在此步骤中，将备份和配置文件从临时位置复制到目标数据库实例。请选择以下选项之一：
+ 如果源主机和目标主机共享 Amazon EFS 文件系统，请使用操作系统实用程序（例如 `cp`）将您的备份文件和 `res.txt` 文件从临时位置复制到共享目录。然后跳至 [步骤 3：在目标数据库实例上导入表空间](#oracle-migrating-tts.initial-tts-import)。
+ 如果您需要将备份暂存到 Amazon S3 桶，请完成以下步骤。
![\[使用 Amazon S3 或 Amazon EFS 传输文件。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### 步骤 2.2：将备份上传到 Amazon S3 桶
将您的备份和 `res.txt` 文件从临时目录上传到您的 Amazon S3 桶。有关更多信息，请参阅《Amazon Simple Storage Service 开发人员指南》**中的[上传对象](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)。
#### 步骤 2.3：将备份从 Amazon S3 桶下载到目标数据库实例
在此步骤中，您将使用过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份下载到您的 RDS for Oracle 数据库实例。
**从您的 Amazon S3 桶下载备份**
1. 启动 SQL\$1Plus 或 Oracle SQL Developer，并登录到 RDS for Oracle 数据库实例。
1. 使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份从 Amazon S3 桶下载到您的目标数据库实例。以下示例将所有文件从名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶下载到 `DATA_PUMP_DIR` 目录中。
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'res.txt');
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例](oracle-s3-integration.using.md#oracle-s3-integration.using.download)。
### 步骤 3：在目标数据库实例上导入表空间
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 将表空间还原到目标数据库实例。此过程会自动将数据文件转换为正确的字节顺序格式。
如果您从 Linux 以外的平台导入，请在调用 `p_platform_id` 时使用参数 `import_xtts_tablespaces` 指定源平台。确保您指定的平台 ID 与 [步骤 2：在源主机上导出表空间元数据](#oracle-migrating-tts.transport.export) 中 `xtt.properties` 文件中指定的平台 ID 匹配。
**在目标数据库实例上导入表空间**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标 RDS for Oracle 数据库实例。
1. 运行过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`，同时指定要导入的表空间和包含备份的目录。
以下示例从 *DATA\$1PUMP\$1DIR* 目录中导入表空间 *TBS1*、*TBS2* 和 *TBS3*。源平台是基于 AIX 的系统（64 位），其平台 ID 为 `6`。您可以通过查询 `V$TRANSPORTABLE_PLATFORM` 查找平台 ID。
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
1. （可选）通过查询表 `rdsadmin.rds_xtts_operation_info` 来监控进度。`xtts_operation_state` 列显示值 `EXECUTING`、`COMPLETED` 或 `FAILED`。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**注意**
对于长时间运行的操作，也可以查询 `V$SESSION_LONGOPS`、`V$RMAN_STATUS` 和 `V$RMAN_OUTPUT`。
1. 使用上一步中的任务 ID 查看已完成的导入的日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
在继续下一步之前，请确保导入成功。
## 第 3 阶段：制作和传输增量备份
在此阶段，您需要在源数据库处于活动状态时定期制作和传输增量备份。此技术减小了最终表空间备份的大小。如果您进行多个增量备份，则必须先在最后一个增量备份之后复制 `res.txt` 文件，然后才能将其应用到目标实例。
步骤与[第 2 阶段：准备完整的表空间备份](#oracle-migrating-tts.initial-br-phase)中的步骤相同，不同之处为导入步骤是可选的。
## 阶段 4：传输表空间
在此阶段，您将备份只读表空间并导出 Data Pump 元数据，将这些文件传输到目标主机，然后导入表空间和元数据。
**Topics**
+ [步骤 1：备份只读表空间](#oracle-migrating-tts.final-backup)
+ [步骤 2：在源主机上导出表空间元数据](#oracle-migrating-tts.transport.export)
+ [步骤 3：（仅限 Amazon S3）将备份和导出文件传输到您的目标数据库实例](#oracle-migrating-tts.transport)
+ [步骤 4：在目标数据库实例上导入表空间](#oracle-migrating-tts.restore-full)
+ [步骤 5：在目标数据库实例上导入表空间元数据](#oracle-migrating-tts.transport.import-dmp)
### 步骤 1：备份只读表空间
此步骤与[步骤 1：备份源主机上的表空间](#oracle-migrating-tts.backup-full)相同，但有一个关键区别：在最后一次备份表空间之前，您将表空间置于只读模式。
以下示例将 `tbs1`、`tbs2`、和 `tbs3` 置于只读模式。
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### 步骤 2：在源主机上导出表空间元数据
通过在源主机上运行 `expdb` 实用程序来导出表空间元数据。以下示例将表空间 *TBS1*、*TBS2* 和 *TBS3* 导出到目录 *DATA\$1PUMP\$1DIR* 中的转储文件 *xttdump.dmp*。
```
expdp username/pwd \
dumpfile=xttdump.dmp \
directory=DATA_PUMP_DIR \
statistics=NONE \
transport_tablespaces=TBS1,TBS2,TBS3 \
transport_full_check=y \
logfile=tts_export.log
```
如果 *DATA\$1PUMP\$1DIR* 是 Amazon EFS 中的共享目录，请跳至[步骤 4：在目标数据库实例上导入表空间](#oracle-migrating-tts.restore-full)。
### 步骤 3：（仅限 Amazon S3）将备份和导出文件传输到您的目标数据库实例
如果您使用 Amazon S3 暂存表空间备份和 Data Pump 导出文件，请完成以下步骤。
#### 步骤 3.1：将备份和转储文件从源主机上传到您的 Amazon S3 桶
将您的备份和转储文件从源主机上传到 Amazon S3 桶。有关更多信息，请参阅《Amazon Simple Storage Service 开发人员指南》**中的[上传对象](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)。
#### 步骤 3.2：将备份和转储文件从 Amazon S3 桶下载到目标数据库实例
在此步骤中，您将使用过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份和转储文件下载到您的 RDS for Oracle 数据库实例。按照 [步骤 2.3：将备份从 Amazon S3 桶下载到目标数据库实例](#oracle-migrating-tts.download-full) 中的步骤操作。
### 步骤 4：在目标数据库实例上导入表空间
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 还原表空间。有关此过程的语法和语义，请参阅[将传输的表空间导入到您的数据库实例](rdsadmin_transport_util_import_xtts_tablespaces.md)
**重要**
完成最终表空间导入后，下一步是[导入 Oracle Data Pump 元数据](#oracle-migrating-tts.transport.export)。如果导入失败，请务必将数据库实例恢复到失败前的状态。因此，建议您按照[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)中的说明创建数据库实例的数据库快照。快照将包含所有导入的表空间，因此，如果导入失败，则无需重复备份和导入过程。
如果您的目标数据库实例已开启自动备份，并且 Amazon RDS 在您导入元数据之前未检测到已启动有效的快照，则 RDS 会尝试创建快照。根据您的实例活动，此快照可能会成功，也可能不成功。如果未检测到有效的快照或无法启动快照，则元数据导入将退出并显示错误。
**在目标数据库实例上导入表空间**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标 RDS for Oracle 数据库实例。
1. 运行过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`，同时指定要导入的表空间和包含备份的目录。
以下示例从 *DATA\$1PUMP\$1DIR* 目录中导入表空间 *TBS1*、*TBS2* 和 *TBS3*。
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. （可选）通过查询表 `rdsadmin.rds_xtts_operation_info` 来监控进度。`xtts_operation_state` 列显示值 `EXECUTING`、`COMPLETED` 或 `FAILED`。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**注意**
对于长时间运行的操作，也可以查询 `V$SESSION_LONGOPS`、`V$RMAN_STATUS` 和 `V$RMAN_OUTPUT`。
1. 使用上一步中的任务 ID 查看已完成的导入的日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
在继续下一步之前，请确保导入成功。
1. 按照[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)中的说明制作手动数据库快照。
### 步骤 5：在目标数据库实例上导入表空间元数据
在此步骤中，使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` 将可传输的表空间元数据导入您的 RDS for Oracle 数据库实例。有关此过程的语法和语义，请参阅[将可传输的表空间元数据导入到数据库实例中](rdsadmin_transport_util_import_xtts_metadata.md)。在操作期间，导入的状态显示在表 `rdsadmin.rds_xtts_operation_info` 中。
**重要**
在导入元数据之前，我们强烈建议您确认在导入表空间后已成功创建数据库快照。如果导入步骤失败，请还原数据库实例，解决导入错误，然后再次尝试导入。
**将 Data Pump 元数据导入您的 RDS for Oracle 数据库实例**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标数据库实例。
1. 在传输的表空间中创建拥有模式的用户（如果这些用户尚不存在）。
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. 导入元数据，同时指定转储文件的名称及其目录位置。
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. （可选）查询可传输的表空间历史记录表以查看元数据导入的状态。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
操作完成后，您的表空间将处于只读模式。
1. （可选）查看日志文件。
以下示例列出了 BDUMP 目录的内容，然后查询导入日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'BDUMP'));
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-import_xtts_metadata-2023-05-22.01-52-35.560858000.log'));
```
## 第 5 阶段：验证传输的表空间
在此可选步骤中，使用过程 `rdsadmin.rdsadmin_rman_util.validate_tablespace` 验证传输的表空间，然后将表空间置于读/写模式。
**验证传输的数据**
1. 启动 SQL\$1Plus 或 SQL Developer，并以主用户身份登录到目标数据库实例。
1. 使用过程 `rdsadmin.rdsadmin_rman_util.validate_tablespace` 验证表空间。
```
SET SERVEROUTPUT ON
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS1',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS2',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS3',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
END;
/
```
1. 将表空间置于读/写模式。
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## 第 6 阶段：清理剩余文件
在此可选步骤中，您将删除所有不需要的文件。使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程列出表空间导入后孤立的数据文件，然后使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程删除它们。有关这些过程的语法和语义，请参阅[列出表空间导入后的孤立文件](rdsadmin_transport_util_list_xtts_orphan_files.md)和[表空间导入后的孤立数据文件](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)。
**清理剩余文件**
1. 按如下方式删除 *DATA\$1PUMP\$1DIR* 中的旧备份：
1. 通过运行 `rdsadmin.rdsadmin_file_util.listdir` 列出备份文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. 通过调用 `UTL_FILE.FREMOVE` 逐一删除备份。
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. 如果您导入了表空间，但没有为这些表空间导入元数据，则可以按如下方式删除孤立的数据文件：
1. 列出需要删除的孤立数据文件。以下示例运行过程 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`。
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
1. 通过运行过程 `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` 删除孤立文件。
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
清理操作会在 `BDUMP` 目录中生成一个使用名称格式 `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` 的日志文件。
1. 读取上一步中生成的日志文件。以下示例读取日志 `rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log`。
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
1. 如果您导入了表空间并为这些表空间导入了元数据，但遇到了兼容性错误或其他 Oracle Data Pump 问题，请按如下方式清理部分传输的数据文件：
1. 通过查询 `DBA_TABLESPACES` 列出包含部分传输的数据文件的表空间。
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. 删除表空间和部分传输的数据文件。
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# 使用 Oracle Data Pump 导入
Oracle Data Pump 是一个实用程序，可让您将 Oracle 数据导出到转储文件并将其导入到另一个 Oracle 数据库。长期来看，它最终会取代 Oracle Export/Import 实用程序。Oracle Data Pump 是将大量数据从 Oracle 数据库迁移到 Amazon RDS 数据库实例的建议方法。
本节中的示例展示了将数据导入 Oracle 数据库的一种方法，但 Oracle Data Pump 支持其他方法。有关更多信息，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A)。
本节中的示例使用 `DBMS_DATAPUMP` 包。您可以使用 Oracle Data Pump 命令行实用程序 `impdp` 和 `expdp` 完成相同的任务。您可以在远程主机上安装这些实用程序以作为 Oracle 客户端安装的一部分，包括 Oracle 即时客户端。有关更多信息，请参阅[如何使用 Oracle Instant Client 为我的 Amazon RDS for Oracle 数据库实例运行 Data Pump 导入或导出？](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/)
**Topics**
+ [Oracle Data Pump 概述](#Oracle.Procedural.Importing.DataPump.Overview)
+ [使用 Oracle Data Pump 和 Amazon S3 存储桶导入数据](#Oracle.Procedural.Importing.DataPump.S3)
+ [使用 Oracle Data Pump 和数据库链接导入数据](#Oracle.Procedural.Importing.DataPump.DBLink)
## Oracle Data Pump 概述
Oracle Data Pump 由以下组件组成：
+ 命令行客户端 `expdp` 和 `impdp`
+ `DBMS_DATAPUMP` PL/SQL 程序包
+ `DBMS_METADATA` PL/SQL 程序包
您可以将 Oracle Data Pump 用于以下场景：
+ 将数据从 Oracle 数据库（可以是本地或在 Amazon EC2 实例上）导入到 RDS for Oracle 数据库实例。
+ 将数据从 RDS for Oracle 数据库实例导入到 Oracle 数据库（可以是本地或在 Amazon EC2 实例上）。
+ 在 RDS for Oracle 数据库实例之间导入数据，例如将数据从 EC2-Classic 迁移到 VPC。
要下载 Oracle Data Pump 实用工具，请参阅 Oracle Technology Network 网站上的 [Oracle 数据库软件下载](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html)。有关在 Oracle Database 的版本之间进行迁移时的兼容性注意事项，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68)。
### Oracle Data Pump 工作流
通常，您在以下阶段使用 Oracle Data Pump：
1. 将数据导出到源数据库上的转储文件。
1. 将转储文件上载到目标 RDS for Oracle 数据库实例。您可以使用 Amazon S3 桶或使用两个数据库之间的数据库链接进行传输。
1. 将数据从转储文件中导入到 RDS for Oracle 数据库实例。
### Oracle Data Pump 最佳实践
当您使用 Oracle Data Pump 将数据导入到 RDS for Oracle 实例时，我们建议使用以下最佳实践：
+ 在 `schema` 或 `table` 模式中执行导入，以便导入特定架构和对象。
+ 将您导入的架构限制为您的应用程序所需的架构。
+ 请勿在 `full` 模式下导入，也不要导入系统维护的组件的架构。
因为 RDS for Oracle 不允许 `SYS` 或 `SYSDBA` 管理用户进行访问，所以，这些操作可能会损坏 Oracle 数据词典并影响数据库的稳定性。
+ 加载大量数据时，请执行以下操作：
1. 将转储文件转移到目标 RDS for Oracle 数据库实例。
1. 为您的数据库实例拍摄快照。
1. 测试导入以验证导入是否成功。
如果数据库组件失效，则您可以删除数据库实例并通过数据库快照重新创建它。还原的数据库实例包括当您拍摄数据库快照时暂存在数据库实例上的任何转储文件。
+ 请勿导入使用 Oracle Data Pump 导出参数 `TRANSPORT_TABLESPACES`、`TRANSPORTABLE`、或 `TRANSPORT_FULL_CHECK` 创建的转储文件。RDS for Oracle 数据库实例不支持导入这些转储文件。
+ 不要导入包含 Oracle 计划程序对象的转储文件 `SYS`、`SYSTEM`、`RDSADMIN`、`RDSSEC` 和 `RDS_DATAGUARD`，以及属于以下类别的文件：
+ 作业
+ 计划
+ Schedules
+ 链
+ 规则
+ 评估背景
+ 规则集
RDS for Oracle 数据库实例不支持导入这些转储文件。
+ 要排除不受支持的 Oracle 计划程序对象，请在 Data Pump 导出期间使用其他指令。如果您使用 `DBMS_DATAPUMP`，则可以在 `METADATA_FILTER` 之前添加额外的 `DBMS_METADATA.START_JOB`：
```
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
```
如果使用 `expdp`，请创建包含以下示例中所示的 `exclude` 指令的参数文件。然后，将 `PARFILE=parameter_file` 与您的 `expdp` 命令一起使用。
```
exclude=procobj:"IN
(SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)"
```
## 使用 Oracle Data Pump 和 Amazon S3 存储桶导入数据
以下导入过程使用 Oracle Data Pump 和 Amazon S3 存储桶。步骤如下所示：
1. 使用 Oracle [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) 程序包导出源数据库上的数据。
1. 将转储文件置于 Amazon S3 桶中。
1. 将转储文件从 Amazon S3 桶下载到目标 RDS for Oracle 数据库实例上的 `DATA_PUMP_DIR` 目录。
1. 使用 `DBMS_DATAPUMP` 程序包，将数据从复制的转储文件导入到 RDS for Oracle 数据库实例。
**Topics**
+ [使用 Oracle Data Pump 和 Amazon S3 桶导入数据的要求](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [步骤 1：在 RDS for Oracle 目标数据库实例上向数据库用户授予权限](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [步骤 2：使用 DBMS\$1DATAPUMP 将数据导出到转储文件中](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [步骤 3：将转储文件上传到 Amazon S3 存储桶。](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [步骤 4：将转储文件从 Amazon S3 桶下载到目标数据库实例](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [步骤 5：使用 DBMS\$1DATAPUMP 将转储文件导入到目标数据库实例](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [步骤 6：清除](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### 使用 Oracle Data Pump 和 Amazon S3 桶导入数据的要求
此过程有以下要求：
+ 确保 Amazon S3 桶可用于文件传输，并且 Amazon S3 桶与数据库实例处于相同的 AWS 区域中。有关说明，请参阅 *Amazon Simple Storage Service 入门指南* 中的[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html)。
+ 您上传到 Amazon S3 存储桶的对象不得超过 5 TB。有关在 Amazon S3 中使用对象的更多信息，请参阅 [Amazon Simple Storage Service 用户指南](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html)。
**注意**
如果要转储超过 5 TB 的文件，则可以使用并行选项来运行 Oracle Data Pump 导出。此操作会将数据分散到多个转储文件中，以便不会超过单个文件的 5 TB 限制。
+ 您必须按照 [为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md) 中的说明为 Amazon RDS 集成准备 Amazon S3 存储桶。
+ 您必须确保有足够的存储空间来存储源实例和目标数据库实例上的转储文件。
**注意**
此过程将转储文件导入到 `DATA_PUMP_DIR` 目录（所有 Oracle 数据库实例上的预配置目录）中。此目录位于您的数据文件所在的存储卷上。当您导入转储文件时，现有 Oracle 文件使用更多空间。因此，您应该确保您的数据库实例可适应这个额外的空间使用。导入的转储文件不会自动从 `DATA_PUMP_DIR` 目录中删除或清除。要删除导入的转储文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
### 步骤 1：在 RDS for Oracle 目标数据库实例上向数据库用户授予权限
在此步骤中，您将创建您计划向其中导入数据的架构，并向用户授予必要的权限。
**在 RDS for Oracle 目标实例上创建用户并授予必要的权限**
1. 使用 SQL\$1Plus 或 Oracle SQL Developer，作为主用户登录到将向其中导入数据的 RDS for Oracle 数据库实例。有关连接到数据库实例的信息，请参阅[连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 在导入数据之前，创建所需的表空间。有关更多信息，请参阅 [在 RDS for Oracle 中创建表空间并调整其大小](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)。
1. 如果要向其中导入数据的用户账户不存在，请创建用户账户并授予必需的权限和角色。如果您打算将数据导入到多个用户架构，请创建各个用户账户并向其授予所需的权限和角色。
例如，以下 SQL 语句创建新的用户并授予所需权限和角色，以将数据导入到此用户拥有的架构中。将 `schema_1` 替换为此步骤中和下列步骤中架构的名称。
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
前面的语句向新用户授予 `CREATE SESSION` 权限和 `RESOURCE` 角色。根据导入的数据库对象，您可能需要其他权限和角色。
### 步骤 2：使用 DBMS\$1DATAPUMP 将数据导出到转储文件中
要创建转储文件，请使用 `DBMS_DATAPUMP` 程序包。
**将 Oracle 数据导出到转储文件**
1. 使用 SQL Plus 或 Oracle SQL Developer，以管理用户身份连接到源 RDS for Oracle 数据库实例。如果源数据库是 RDS for Oracle 数据库实例，请使用 Amazon RDS 主用户身份进行连接。
1. 通过调用 `DBMS_DATAPUMP` 过程导出数据。
以下脚本将 `SCHEMA_1` 架构导出到 `DATA_PUMP_DIR` 目录中名为 `sample.dmp` 的转储文件中。将 `SCHEMA_1` 替换为要导出的架构的名称。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT',
job_mode => 'SCHEMA',
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_exp.log',
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
Data Pump 异步启动任务。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。
1. （可选）通过调用 `rdsadmin.rds_file_util.read_text_file` 过程查看导出日志的内容。有关更多信息，请参阅 [读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
### 步骤 3：将转储文件上传到 Amazon S3 存储桶。
使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` 将转储文件复制到 Amazon S3 存储桶中。以下示例将 `DATA_PUMP_DIR` 目录中的所有文件上传到名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶中。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 RDS for Oracle 数据库实例上传到 Amazon S3 存储桶](oracle-s3-integration.using.md#oracle-s3-integration.using.upload)。
### 步骤 4：将转储文件从 Amazon S3 桶下载到目标数据库实例
使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 执行此步骤。将文件下载到目录时，如果目录中已存在同名文件，则过程 `download_from_s3` 将跳过下载。要从下载目录中删除文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
**下载转储文件**
1. 启动 SQL\$1Plus 或 Oracle Developer 并以主用户身份登录 Amazon RDS 目标 Oracle 数据库实例
1. 使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 下载转储文件。
以下示例将所有文件从名为 `amzn-s3-demo-bucket` 的 Amazon S3 桶下载到 `DATA_PUMP_DIR` 目录中。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例](oracle-s3-integration.using.md#oracle-s3-integration.using.download)。
### 步骤 5：使用 DBMS\$1DATAPUMP 将转储文件导入到目标数据库实例
使用 `DBMS_DATAPUMP` 将架构导入到 RDS for Oracle 数据库实例。可能需要额外的选项（例如 `METADATA_REMAP`）。
**将数据导入到目标数据库实例**
1. 启动 SQL\$1Plus 或 SQL Developer 并以主用户身份登录 RDS for Oracle 数据库实例。
1. 通过调用 `DBMS_DATAPUMP` 过程导入数据。
下面的示例将 *SCHEMA\$11* 数据从 `sample_copied.dmp` 导入到目标数据库实例。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导入日志的内容。有关更多信息，请参阅 [读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
1. 通过列出目标数据库实例上的架构表来验证数据导入。
例如，以下查询将返回 `SCHEMA_1` 的表数量。
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### 步骤 6：清除
导入数据后，可以删除不想保留的文件。
**删除不需要的文件**
1. 启动 SQL\$1Plus 或 SQL Developer 并以主用户身份登录 RDS for Oracle 数据库实例。
1. 使用以下命令列出 `DATA_PUMP_DIR` 中的文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. 要删除 `DATA_PUMP_DIR` 中不再需要的文件，请使用以下命令。
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
例如，以下命令删除名为 `sample_copied.dmp` 的文件
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## 使用 Oracle Data Pump 和数据库链接导入数据
以下导入过程使用 Oracle Data Pump 和 Oracle [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html) 包。步骤如下所示：
1. 连接到源 Oracle 数据库，此数据库可以是本地数据库、Amazon EC2 实例 或 RDS for Oracle 数据库实例。
1. 使用 [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) 程序包导出数据。
1. 使用 `DBMS_FILE_TRANSFER.PUT_FILE` 将转储文件从 Oracle 数据库复制到通过数据库链接连接到的目标 RDS for Oracle 数据库实例上的 `DATA_PUMP_DIR` 目录中。
1. 使用 ` DBMS_DATAPUMP` 程序包，将数据从复制的转储文件导入到 RDS for Oracle 数据库实例。
使用 Oracle 数据转储和 `DBMS_FILE_TRANSFER` 包的导入过程具有以下步骤。
**Topics**
+ [使用 Oracle Data Pump 和数据库链接导入数据的要求](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [步骤 1：在 RDS for Oracle 目标数据库实例上向用户授予权限](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [步骤 2：向用户授予源数据库权限](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [步骤 3：使用 DBMS\$1DATAPUMP 创建转储文件](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [步骤 4：创建目标数据库实例的数据库链接](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [步骤 5：使用 DBMS\$1FILE\$1TRANSFER 将导出的转储文件复制到目标数据库实例](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [步骤 6：使用 DBMS\$1DATAPUMP 将数据文件导入到目标数据库实例](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [步骤 7：清除](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### 使用 Oracle Data Pump 和数据库链接导入数据的要求
此过程有以下要求：
+ 您必须对 `DBMS_FILE_TRANSFER` 和 `DBMS_DATAPUMP` 包具有执行权限。
+ 您必须对源数据库实例上的 `DATA_PUMP_DIR` 目录具有写入权限。
+ 您必须确保有足够的存储空间来存储源实例和目标数据库实例上的转储文件。
**注意**
此过程将转储文件导入到 `DATA_PUMP_DIR` 目录（所有 Oracle 数据库实例上的预配置目录）中。此目录位于您的数据文件所在的存储卷上。当您导入转储文件时，现有 Oracle 文件使用更多空间。因此，您应该确保您的数据库实例可适应这个额外的空间使用。导入的转储文件不会自动从 `DATA_PUMP_DIR` 目录中删除或清除。要删除导入的转储文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
### 步骤 1：在 RDS for Oracle 目标数据库实例上向用户授予权限
要向用户授予对 RDS for Oracle 目标数据库实例的权限，请执行以下步骤：
1. 使用 SQL Plus 或 Oracle SQL Developer 连接到要向其中导入数据的 RDS for Oracle 数据库实例。以 Amazon RDS 主用户的身份连接。有关连接到数据库实例的信息，请参阅[连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 在导入数据之前，创建所需的表空间。有关更多信息，请参阅“[在 RDS for Oracle 中创建表空间并调整其大小](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)”。
1. 如果要导入数据的用户账户不存在，请创建用户账户并授予必需的权限和角色。如果您打算将数据导入到多个用户架构，请创建各个用户账户并向其授予所需的权限和角色。
例如，以下命令创建名为 *schema\$11* 的新用户，并向此用户授予所需权限和角色，以将数据导入到用户架构中。
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
前一个示例为新用户授予 `CREATE SESSION` 权限和 `RESOURCE` 角色。根据导入的数据库对象，可能需要其他权限和角色。
**注意**
将 `schema_1` 替换为此步骤中和下列步骤中架构的名称。
### 步骤 2：向用户授予源数据库权限
使用 SQL\$1Plus 或 Oracle SQL Developer 连接到包含要导入的数据的 RDS for Oracle 数据库实例。如有必要，可创建用户账户并授予必要权限。
**注意**
如果源数据库是 Amazon RDS 实例，则可以跳过此步骤。使用您的 Amazon RDS 主用户账户来执行导出。
以下命令创建新用户并授予必要权限。
```
CREATE USER export_user IDENTIFIED BY my-password;
GRANT CREATE SESSION, CREATE TABLE, CREATE DATABASE LINK TO export_user;
ALTER USER export_user QUOTA 100M ON users;
GRANT READ, WRITE ON DIRECTORY data_pump_dir TO export_user;
GRANT SELECT_CATALOG_ROLE TO export_user;
GRANT EXECUTE ON DBMS_DATAPUMP TO export_user;
GRANT EXECUTE ON DBMS_FILE_TRANSFER TO export_user;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
### 步骤 3：使用 DBMS\$1DATAPUMP 创建转储文件
要创建转储文件，请执行以下操作：
1. 使用 SQL\$1Plus 或 Oracle SQL Developer，以管理用户或在步骤 2 中创建的用户身份连接到源 Oracle 实例。如果源数据库是 Amazon RDS for Oracle 数据库实例，请使用 Amazon RDS 主用户身份连接。
1. 使用 Oracle Data Pump 实用程序创建转储文件。
以下脚本在 `DATA_PUMP_DIR` 目录中创建一个名为 *sample.dmp* 的转储文件。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT' ,
job_mode => 'SCHEMA' ,
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample_exp.log' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl ,
'SCHEMA_EXPR' ,
'IN (''SCHEMA_1'')'
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导出日志的内容。有关更多信息，请参阅“[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)”。
### 步骤 4：创建目标数据库实例的数据库链接
在源数据库实例和目标数据库实例之间创建数据库链接。您的本地 Oracle 实例必须具有至数据库实例的网络连接，然后才能创建数据库链接以及传输导出转储文件。
执行此步骤，使用与上一步中相同的用户账户连接。
如果您将在同一 VPC 或对等 VPC 中的两个数据库实例之间创建数据库链接，则这两个数据库实例之间应具有有效路由。每个数据库实例的安全组必须允许另一个数据库实例的传入和传出。安全组入站和出站规则可引用同一 VPC 或对等 VPC 中的安全组。有关更多信息，请参阅“[在 VPC 中调整用于数据库实例的数据库链接](Appendix.Oracle.CommonDBATasks.DBLinks.md)”。
以下命令创建名为 `to_rds` 的数据库链接，连接到位于目标数据库实例中的 Amazon RDS 主用户。
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### 步骤 5：使用 DBMS\$1FILE\$1TRANSFER 将导出的转储文件复制到目标数据库实例
使用 `DBMS_FILE_TRANSFER` 将转储文件从源数据库实例复制到目标数据库实例。以下脚本将名为 sample.dmp 的转储文件从源实例复制到名为 *to\$1rds* 的目标数据库链接（已在上一步中创建）。
```
BEGIN
DBMS_FILE_TRANSFER.PUT_FILE(
source_directory_object => 'DATA_PUMP_DIR',
source_file_name => 'sample.dmp',
destination_directory_object => 'DATA_PUMP_DIR',
destination_file_name => 'sample_copied.dmp',
destination_database => 'to_rds' );
END;
/
```
### 步骤 6：使用 DBMS\$1DATAPUMP 将数据文件导入到目标数据库实例
在数据库实例中使用 Oracle Data Pump 导入架构。可能需要额外选项（例如，METADATA\$1REMAP）。
使用 Amazon RDS 主用户账户连接到数据库实例来执行导入。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导入日志的内容。有关更多信息，请参阅“[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)”。
您可以通过查看数据库实例上用户的表来验证数据导入。例如，以下查询将返回 `schema_1` 的表数量。
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### 步骤 7：清除
导入数据后，可以删除不想保留的文件。您可以使用以下命令列出 `DATA_PUMP_DIR` 中的文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
要删除 `DATA_PUMP_DIR` 中不再需要的文件，请使用以下命令。
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
例如，以下命令删除名为 `"sample_copied.dmp"` 的文件
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# 使用 Oracle Export/Import 进行导入
在以下情况下，您可以考虑使用 Oracle Export/Import 实用程序进行迁移：
+ 您的数据量很小。
+ 不需要二进制浮点数和双精度等数据类型。
导入过程会创建必要的模式对象。因此，无需事先运行脚本来创建对象。
安装 Oracle 导出和导入实用程序的最简单方法是安装 Oracle Instant Client。要下载该软件，请前往 [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html)。有关文档，请参阅《Oracle 数据库实用程序》**手册中的[适用于 SQL\$1Loader、导出和导入的 Instant Client](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965)。
**导出表，然后导入它们**
1. 使用 `exp` 命令将表从源数据库中导出。
以下命令导出名为 `tab1`、`tab2` 以及 `tab3` 的表。转储文件为 `exp_file.dmp`。
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
导出会创建一个二进制转储文件，其中包含指定表的架构和数据。
1. 使用 `imp` 命令将架构和数据导入目标数据库。
以下命令从转储文件 `exp_file.dmp` 中导入表 `tab1`、`tab2` 和 `tab3`。
```
imp cust_dba@targetdb FROMUSER=cust_schema TOUSER=cust_schema \
TABLES=(tab1,tab2,tab3) FILE=exp_file.dmp LOG=imp_file.log
```
“导出”和“导入”具有其他可能更适合您的要求的变体。有关完整详细信息，请参阅 Oracle Database 文档。
# 使用 Oracle SQL\$1Loader 进行导入
您可以考虑将 Oracle SQL\$1Loader 用于对象数量有限的大型数据库。由于从源数据库导出并加载到目标数据库的过程特定于架构，因此，下面的示例创建示例模式对象，从源导出，然后将数据加载到目标数据库。
安装 Oracle SQL\$1Loader 的最简单方法是安装 Oracle Instant Client。要下载该软件，请前往 [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html)。有关文档，请参阅《Oracle 数据库实用程序》**手册中的[适用于 SQL\$1Loader、导出和导入的 Instant Client](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965)。
**使用 Oracle SQL\$1Loader 导入数据**
1. 使用以下 SQL 语句创建示例源表。
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. 在目标 RDS for Oracle 数据库实例上，创建用于加载数据的目标表。子句 `WHERE 1=2` 可确保复制 `ALL_OBJECTS` 的结构，但不复制任何行。
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. 将数据从源数据库导出到文本文件。以下示例使用 SQL\$1Plus。对于数据，您可能需要生成用于执行数据库中所有对象导出操作的脚本。
```
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY/MM/DD HH24:MI:SS'
SET LINESIZE 800 HEADING OFF FEEDBACK OFF ARRAY 5000 PAGESIZE 0
SPOOL customer_0.out
SET MARKUP HTML PREFORMAT ON
SET COLSEP ','
SELECT id, owner, object_name, created
FROM customer_0;
SPOOL OFF
```
1. 创建一个控制文件来描述数据。您可能需要编写脚本来执行此步骤。
```
cat << EOF > sqlldr_1.ctl
load data
infile customer_0.out
into table customer_1
APPEND
fields terminated by "," optionally enclosed by '"'
(
id POSITION(01:10) INTEGER EXTERNAL,
owner POSITION(12:41) CHAR,
object_name POSITION(43:72) CHAR,
created POSITION(74:92) date "YYYY/MM/DD HH24:MI:SS"
)
```
如果需要，将上述代码生成的文件复制到某一暂存区域，如 Amazon EC2 实例。
1. 通过适用于目标数据库的用户名和密码，使用 SQL\$1Loader 导入数据。
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# 使用 Oracle 实体化视图进行迁移
要高效率地迁移大型数据集，您可以使用 Oracle 实体化视图复制功能。通过复制，您可以使目标表与源表保持同步。这样，如果需要，您可以稍后切换到 Amazon RDS。
在可以使用实体化视图进行迁移之前，请确保满足以下要求：
+ 配置从目标数据库到源数据库的访问权限。在以下示例中，在源数据库上启用了访问规则，以允许 RDS for Oracle 目标数据库通过 SQL\$1Net 与源数据库连接。
+ 创建从 RDS for Oracle 数据库实例到源数据库的数据库链接。
**使用实体化视图迁移数据**
1. 在源实例和 RDS for Oracle 目标实例上，创建可以使用同一密码进行身份验证的用户账户。下面的示例创建了一个名为 `dblink_user` 的用户。
```
CREATE USER dblink_user IDENTIFIED BY my-password
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp;
GRANT CREATE SESSION TO dblink_user;
GRANT SELECT ANY TABLE TO dblink_user;
GRANT SELECT ANY DICTIONARY TO dblink_user;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 使用新创建的用户创建从 RDS for Oracle 目标实例到源实例的数据库链接。
```
CREATE DATABASE LINK remote_site
CONNECT TO dblink_user IDENTIFIED BY my-password
USING '(description=(address=(protocol=tcp) (host=my-host)
(port=my-listener-port)) (connect_data=(sid=my-source-db-sid)))';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 测试链接：
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. 使用主键和源实例上的具体化视图日志创建示例表。
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
ALTER TABLE customer_0 ADD CONSTRAINT pk_customer_0 PRIMARY KEY (id) USING INDEX;
CREATE MATERIALIZED VIEW LOG ON customer_0;
```
1. 在目标 RDS for Oracle 数据库实例上，创建实体化视图。
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. 在目标 RDS for Oracle 实例上，刷新实体化视图。
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. 删除实体化视图并包括 `PRESERVE TABLE` 子句，以便保留实体化视图容器表及其内容。
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
保留的表拥有与已删除具体化视图相同的名称。