

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 使用连接到 Oracle 数据库 AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle"></a>

您可以使用 AWS SCT 将架构、数据库代码对象和应用程序代码从 Oracle 数据库转换为以下目标：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL 兼容版
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL 兼容版
+ Amazon RDS for Oracle
+ Amazon RDS for MariaDB

当源是 Oracle 数据库时，可以将注释转换为适当的格式，例如在 PostgreSQL 数据库中。 AWS SCT 可以转换对表、视图和列的注释。注释可以包含撇号；转换 SQL 语句时将撇号 AWS SCT 加倍，就像处理字符串文字一样。

有关更多信息，请参阅下列内容。

**Topics**
+ [将 Oracle 用作源的权限](#CHAP_Source.Oracle.Permissions)
+ [连接到作为源的 Oracle](#CHAP_Source.Oracle.Connecting)
+ [使用 PostgreSQL 从 Oracle 迁移到亚马逊 RDS 或亚马逊 Aurora PostgreSQL AWS Schema Conversion Tool](CHAP_Source.Oracle.ToPostgreSQL.md)
+ [使用 Oracle 迁移到 Amazon RDS for MySQL 或 Amazon Aurora MySQL AWS Schema Conversion Tool](CHAP_Source.Oracle.ToMySQL.md)
+ [从 Oracle 数据库迁移到 Amazon RDS for Oracle AWS Schema Conversion Tool](CHAP_Source.Oracle.ToRDSOracle.md)

## 将 Oracle 用作源的权限
<a name="CHAP_Source.Oracle.Permissions"></a>

下面列出了将 Oracle 用作源所需的权限：
+ CONNECT 
+ SELECT\$1CATALOG\$1ROLE 
+ SELECT ANY DICTIONARY 
+ SELECT ON SYS.ARGUMENT\$1

## 连接到作为源的 Oracle
<a name="CHAP_Source.Oracle.Connecting"></a>

使用 AWS Schema Conversion Tool按照以下过程连接到 Oracle 源数据库。

**连接到 Oracle 源数据库**

1. 在中 AWS Schema Conversion Tool，选择**添加来源**。

1. 选择 **Oracle**，然后选择**下一步**。

   此时显示**添加源**对话框。

1. 对于**连接名称**，输入数据库的名称。 AWS SCT 会在左侧面板的树中显示此名称。

1. 使用来自的数据库凭据 AWS Secrets Manager 或手动输入：
   + 要使用 Secrets Manager 中的数据库凭证，请按照以下说明进行操作：

     1. 对于 **AWS 密钥**，请选择密钥的名称。

     1. 选择**填充**可使用 Secrets Manager 中的数据库凭证自动填写数据库连接对话框中的所有值。

     有关使用 Secrets Manager 中的数据库凭证的信息，请参阅 [AWS Secrets Manager 在中配置 AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md)。
   + 要手动输入 Oracle 源数据库连接信息，请按照以下说明进行操作：    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html)

1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。

1. 选择**连接**以连接到源数据库。

# 使用 PostgreSQL 从 Oracle 迁移到亚马逊 RDS 或亚马逊 Aurora PostgreSQL AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToPostgreSQL"></a>

将 Oracle 数据库转换为适用于 PostgreSQL 的 RDS 或 Amazon Aurora PostgreSQL 时，请注意以下几点。

**Topics**
+ [将 PostgreSQL 用作目标数据库的权限](#CHAP_Source.Oracle.ToPostgreSQL.ConfigureTarget)
+ [Oracle 到 PostgreSQL 的转换设置](#CHAP_Source.Oracle.ToPostgreSQL.ConversionSettings)
+ [转换 Oracle 序列](#CHAP_Source.Oracle.ToPostgreSQL.ConvertSequences)
+ [转换 Oracle ROWID](#CHAP_Source.Oracle.ToPostgreSQL.ConvertRowID)
+ [转换 Oracle 动态 SQL](#CHAP_Source.Oracle.ToPostgreSQL.DynamicSQL)
+ [转换 Oracle 分区](#CHAP_Source.Oracle.ToPostgreSQL.PG10Partitioning)

将 Oracle 系统对象转换为 PostgreSQL 时 AWS SCT ，执行如下表所示的转换。


| Oracle 系统对象 | 说明 | 转换的 PostgreSQL 对象 | 
| --- | --- | --- | 
| V\$1VERSION  | 在 Oracle 数据库中显示核心库组件的版本号 | aws\$1oracle\$1ext.v\$1version | 
| V\$1INSTANCE | 显示当前实例状态的视图。 | aws\$1oracle\$1ext.v\$1instance | 

你可以使用 AWS SCT 将 Oracle SQL\$1Plus 文件转换为 psql，psql 是基于终端的 PostgreSQL 前端。有关更多信息，请参阅 [使用转换应用程序 SQL AWS SCT](CHAP_Converting.App.md)。

## 将 PostgreSQL 用作目标数据库的权限
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConfigureTarget"></a>

要使用 PostgreSQL 作为目标 AWS SCT ，需要权限。`CREATE ON DATABASE`请确保为每个目标 PostgreSQL 数据库授予此权限。

要使用转换后的公共同义词，请将数据库的默认搜索路径更改为 `"$user", public_synonyms, public`。

您可以使用以下代码示例创建数据库用户并授予权限。

```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```

在前面的示例中，*user\$1name*使用您的用户名替换。然后，*db\$1name*替换为目标数据库的名称。最后，*your\$1password*替换为安全密码。

要使用适用于 PostgreSQL 的 Amazon RDS 作为目标 AWS SCT ，需要权限。`rds_superuser`

在 PostgreSQL 中，只有架构所有者或 `superuser` 才能删除架构。即使架构的所有者并不拥有架构的某些对象，该所有者也可以删除该架构及其包含的所有对象。

当你使用不同的用户转换不同的架构并将其应用到目标数据库时，当无法删除架构时，你 AWS SCT 可能会收到一条错误消息。要避免出现此错误消息，请使用 `superuser` 角色。

## Oracle 到 PostgreSQL 的转换设置
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConversionSettings"></a>

**要编辑 Oracle 到 PostgreSQL 的转换设置，**请选择** AWS SCT中的设置，然后选择转换设置。**从上面的列表中选择 **Oracle，然后选择 Oracle** **— PostgreSQL**。 AWS SCT 显示了 Oracle 到 PostgreSQL 转换的所有可用设置。

中的 Oracle 到 PostgreSQL 的转换设置包括以下 AWS SCT 各项的选项：
+ 限制转换后的代码中操作项的注释数量。

  对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。

  例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+  AWS SCT 允许在 PostgreSQL 上将 Oracle 实例化视图转换为表或实例化视图。对于**实体化视图转换为**，请选择如何转换源实体化视图。
+ 在源 Oracle 代码中包含带有 PostgreSQL 不支持的参数的 `TO_CHAR`、`TO_DATE` 和 `TO_NUMBER` 函数时使用该代码。默认情况下， AWS SCT 会在转换后的代码中模拟这些参数的用法。

  当源 Oracle 代码仅包含 PostgreSQL 支持的参数时，可以使用原生 PostgreSQL `TO_CHAR`、`TO_DATE` 和 `TO_NUMBER` 函数。在这种情况下，转换后的代码运行更快。要仅包含这些参数，请选择以下值：
  + **函数 TO\$1CHAR() 不使用 Oracle 特定的格式化字符串**
  + **函数 TO\$1DATE() 不使用 Oracle 特定的格式化字符串**
  + **函数 TO\$1NUMBER() 不使用 Oracle 特定的格式化字符串**
+ 要解决源 Oracle 数据库在 `NUMBER` 数据类型的主键列或外键列中仅存储整数值的问题， AWS SCT 可以将这些列转换为 `BIGINT` 数据类型。这种方法可提高转换后的代码的性能。要采用这种方法，请选择**将 NUMBER 主/外键列转换为 BIGINT 列**。请确保源在这些列中不包含浮点值，以避免数据丢失。
+ 跳过源代码中已停用的触发器和约束。为此，请选择**忽略禁用的触发器和约束**。
+ 用于转换 AWS SCT 被称为动态 SQL 的字符串变量。数据库代码可以更改这些字符串变量的值。要确保 AWS SCT 始终转换此字符串变量的最新值，请选择 “**转换在调用例程中创建的动态 SQL 代码**”。
+ 解决 PostgreSQL 版本 10 及更早版本不支持过程的问题。如果你或你的用户不熟悉 PostgreSQL 中的过程的使用，可以将 Oracle 过程转换为 PostgreSQL AWS SCT 函数。为此，请选择**将过程转换为函数**。
+ 查看有关已发生操作项的更多信息。为此，您可以通过选择**添加异常，提高迁移问题块严重性级别**向扩展包中添加特定函数。然后，选择引发用户定义的异常的严重性级别。
+ 使用可能包含自动生成名称的约束的源 Oracle 数据库。如果源代码使用这些名称，请确保选择**使用源的原始名称转换系统生成的约束名称**。如果源代码使用这些约束，但未使用其名称，请清除此选项以提高转换速度。
+ 解决数据库和应用程序在不同的时区运行的问题。默认情况下，在转换后的代码中 AWS SCT 模拟时区。但是，当数据库和应用程序使用相同的时区时，您不需要这种模拟。在这种情况下，选择**客户端时区与服务器端时区相匹配**。
+ 解决源数据库和目标数据库在不同的时区运行的问题。如果是这样，模拟 `SYSDATE` 内置 Oracle 函数的函数会返回与源函数不同的值。要确保源函数和目标函数返回的值相同，请选择**为 SYSDATE 模拟设置默认时区**。
+ 在转换后的代码中使用 orafce 扩展中的函数。为此，在**使用 orafce 实施**中，选择要使用的函数。有关 orace 的更多信息，请参阅 [or](https://github.com/orafce/orafce) ace on。 GitHub

## 转换 Oracle 序列
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConvertSequences"></a>

AWS SCT 将序列从 Oracle 转换为 PostgreSQL。如果您使用序列维护完整性约束，请确保迁移序列的新值不会与现有值重叠。

**使用源数据库中的最后一个值填充转换后的序列**

1. 以 Oracle 为源代码打开您的 AWS SCT 项目。

1. 选择**设置**，然后选择**转换设置**。

1. 从上面的列表中选择 **Oracle**，然后选择 **Oracle – PostgreSQL**。 AWS SCT 显示了 Oracle 到 PostgreSQL 转换的所有可用设置。

1. 选择**使用源端生成的最后一个值填充转换后的序列**。

1. 选择**确定**以保存设置并关闭**转换设置**对话框。

## 转换 Oracle ROWID
<a name="CHAP_Source.Oracle.ToPostgreSQL.ConvertRowID"></a>

 在 Oracle 数据库中，ROWID 伪列包含表行的地址。ROWID 伪列是 Oracle 所独有的，因此在 PostgreSQ AWS SCT L 上将 ROWID 伪列转换为数据列。通过使用此转换，您可以保留 ROWID 信息。

转换 ROWID 伪列时， AWS SCT 可以创建数据类型的数据列。`bigint`如果不存在主键，则将 ROWID 列 AWS SCT 设置为主键。如果存在主键，则使用唯一约束 AWS SCT 设置 ROWID 列。

如果您的源数据库代码包含使用 ROWID 的操作（您无法使用数字数据类型运行这些操作），则 AWS SCT 可以使用该数据类型创建`character varying`数据列。

**为项目的 Oracle ROWID 创建数据列**

1. 以 Oracle 为源代码打开您的 AWS SCT 项目。

1. 选择**设置**，然后选择**转换设置**。

1. 从上面的列表中选择 **Oracle**，然后选择 **Oracle – PostgreSQL**。 AWS SCT 显示了 Oracle 到 PostgreSQL 转换的所有可用设置。

1. 对于**生成行 ID**，执行以下操作之一：
   + 选择**生成为身份**以创建数字数据列。
   + 选择**生成为字符域类型**以创建字符数据列。

1. 选择**确定**以保存设置并关闭**转换设置**对话框。

## 转换 Oracle 动态 SQL
<a name="CHAP_Source.Oracle.ToPostgreSQL.DynamicSQL"></a>

 Oracle 提供了两种实施动态 SQL 的方法：使用 EXECUTE IMMEDIATE 语句或在 DBMS\$1SQL 包中调用过程。如果您的源 Oracle 数据库包含带有动态 SQL 的对象，请使用 AWS SCT 将 Oracle 动态 SQL 语句转换为 PostgreSQL。

**将 Oracle 动态 SQL 转换为 PostgreSQL**

1. 以 Oracle 为源代码打开您的 AWS SCT 项目。

1. 在 Oracle 源树视图中选择使用动态 SQL 的数据库对象。

1. 打开该对象的上下文 (右键单击) 菜单，然后选择 **转换架构**，并同意替换对象（如果存在）。以下屏幕截图显示了使用动态 SQL 的 Oracle 过程下面的已转换过程。  
![\[Dynamic SQL 转换\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/images/dynamicsql1.png)

## 转换 Oracle 分区
<a name="CHAP_Source.Oracle.ToPostgreSQL.PG10Partitioning"></a>

AWS SCT 目前支持以下分区方法：
+ Range
+ 列表
+ 多列范围
+ 哈希
+ 复合（列表-列表、范围-列表、列表-范围、列表-哈希、范围-哈希、哈希-哈希）

# 使用 Oracle 迁移到 Amazon RDS for MySQL 或 Amazon Aurora MySQL AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToMySQL"></a>

要在转换后的 MySQL 代码中模拟 Oracle 数据库函数，请使用 AWS SCT中的 Oracle 到 MySQL 扩展包。有关扩展包的更多信息，请参阅[将扩展包与 AWS Schema Conversion Tool](CHAP_ExtensionPack.md)。

**Topics**
+ [将 MySQL 用作目标数据库的权限](#CHAP_Source.Oracle.ToMySQL.ConfigureTarget)
+ [Oracle 到 MySQL 的转换设置](#CHAP_Source.Oracle.ToMySQL.ConversionSettings)
+ [迁移注意事项](#CHAP_Source.Oracle.ToMySQL.MigrationConsiderations)
+ [将 Oracle 中的 WITH 语句转换为 RDS for MySQL 或 Amazon Aurora MySQL](#CHAP_Source.Oracle.ToMySQL.With)

## 将 MySQL 用作目标数据库的权限
<a name="CHAP_Source.Oracle.ToMySQL.ConfigureTarget"></a>

下面列出了将 MySQL 用作目标所需的权限：
+ CREATE ON \$1.\$1
+ ALTER ON \$1.\$1
+ DROP ON \$1.\$1
+ INDEX ON \$1.\$1
+ REFERENCES ON \$1.\$1
+ SELECT ON \$1.\$1
+ CREATE VIEW ON \$1.\$1
+ SHOW VIEW ON \$1.\$1
+ TRIGGER ON \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ CREATE TEMPORARY TABLES ON \$1.\$1
+ AWS\$1LAMBDA\$1ACCESS
+ 插入，在 AWS\$1ORACLE \$1EXT 上更新。 \$1
+ 在 AWS\$1ORACLE \$1EXT\$1DATA 上插入、更新、删除。 \$1

如果您使用 MySQL 数据库版本 5.7 或更低版本作为目标，请授予 INVOKE LAMBDA \$1.\$1 权限，而不是 \$1ACCESS。 AWS\$1LAMBDA对于 8.0 及更高版本的 MySQL 数据库，请授予 AWS\$1LAMBDA\$1ACCESS 权限。

您可以使用以下代码示例创建数据库用户并授予权限。

```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON *.* TO 'user_name';
GRANT AWS_LAMBDA_ACCESS TO 'user_name';
GRANT INSERT, UPDATE ON AWS_ORACLE_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_ORACLE_EXT_DATA.* TO 'user_name';
```

在前面的示例中，*user\$1name*使用您的用户名替换。然后，*your\$1password*替换为安全密码。

如果使用版本 5.7 或更低版本的 MySQL 数据库作为目标，请使用 `GRANT INVOKE LAMBDA ON *.* TO 'user_name'`，而非 `GRANT AWS_LAMBDA_ACCESS TO 'user_name'`。

要使用 Amazon RDS for MySQL 或 Aurora MySQL 作为目标，请将 `lower_case_table_names` 参数设置为 `1`。此值意味着 MySQL 服务器在处理表、索引、触发器和数据库等对象名称的标识符时不区分大小写。如果目标实例中已开启二进制日志记录，请将 `log_bin_trust_function_creators` 参数设置为 `1`。在这种情况下，您无需使用 `DETERMINISTIC`、`READS SQL DATA` 或 `NO SQL` 特性创建存储函数。要配置这些参数，请创建新的数据库参数组或修改现有数据库参数组。

## Oracle 到 MySQL 的转换设置
<a name="CHAP_Source.Oracle.ToMySQL.ConversionSettings"></a>

要编辑 Oracle 到 MySQL 的转换**设置** AWS SCT，请选择中的设置，然后选择**转换设置**。从上面的列表中选择 **Oracle，然后选择 Or** **acle — MySQL**。 AWS SCT 显示了 Oracle 到 MySQL 转换的所有可用设置。

中的 Oracle 到 MySQL 的转换设置 AWS SCT 包括以下各项的选项：
+ 限制转换后的代码中操作项的注释数量。

  对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。

  例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 为了解决这个问题，你的源 Oracle 数据库可以使用`ROWID`伪列，但是 MySQL 不支持类似的功能。 AWS SCT 可以在转换后的代码中模拟`ROWID`伪列。为此，请为**生成行 ID？**选择**生成为身份** 。

  如果源 Oracle 代码不使用 `ROWID` 伪列，请为**生成行 ID？**选择**不生成**。在这种情况下，转换后的代码运行更快。
+ 在 Oracle 源代码中包含带有 MySQL 不支持的参数的 `TO_CHAR`、`TO_DATE` 和 `TO_NUMBER` 函数时使用该代码。默认情况下， AWS SCT 会在转换后的代码中模拟这些参数的用法。

  当源 Oracle 代码仅包含 PostgreSQL 支持的参数时，您可以使用原生 MySQL `TO_CHAR`、`TO_DATE` 和 `TO_NUMBER` 函数。在这种情况下，转换后的代码运行更快。要仅包含这些参数，请选择以下值：
  + **函数 TO\$1CHAR() 不使用 Oracle 特定的格式化字符串**
  + **函数 TO\$1DATE() 不使用 Oracle 特定的格式化字符串**
  + **函数 TO\$1NUMBER() 不使用 Oracle 特定的格式化字符串**
+ 解决数据库和应用程序在不同的时区运行的问题。默认情况下， AWS SCT 在转换后的代码中模拟时区。但是，当数据库和应用程序使用相同的时区时，您不需要这种模拟。在这种情况下，选择**客户端时区与服务器端时区相匹配**。

## 迁移注意事项
<a name="CHAP_Source.Oracle.ToMySQL.MigrationConsiderations"></a>

将 Oracle 转换为 RDS for MySQL 或 Aurora MySQL 时，要更改语句的运行顺序，您可以使用 `GOTO` 语句和标签。将跳过 `GOTO` 语句后的任何 PL/SQL 语句并从标签位置继续处理。可在过程、批处理或语句块中的任意位置使用 `GOTO` 语句和标签。GOTO 语句也可以嵌套。

MySQL 不使用 `GOTO` 语句。当 AWS SCT 转换包含`GOTO`语句的代码时，它会将该语句转换为使用`BEGIN…END`或`LOOP…END LOOP`语句。

您可以在下表中找到如何 AWS SCT 转换`GOTO`语句的示例。


| Oracle 语句 | MySQL 语句 | 
| --- | --- | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   GOTO label1;<br />   statement2;<br />   ....<br />   label1:<br />   Statement3;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br /> label1:<br /> BEGIN<br />   ....<br />   statement1;<br />   ....<br />   LEAVE label1;<br />   statement2;<br />   ....<br /> END;<br />   Statement3;<br />   ....<br />END<br /></pre>  | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   statement2;<br />   ....<br />   GOTO label1;<br />   statement3;<br />   ....<br />   statement4;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   LOOP<br />    statement2;<br />    ....<br />    ITERATE label1;<br />    LEAVE label1;<br />   END LOOP; <br />    statement3;<br />    ....<br />    statement4;<br />    ....<br />END<br /></pre>  | 
|  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   statement2;<br />   ....<br />   statement3;<br />   ....<br />   statement4;<br />   ....<br />END<br /></pre>  |  <pre>BEGIN<br />   ....<br />   statement1;<br />   ....<br />   label1:<br />   BEGIN<br />    statement2;<br />    ....    <br />    statement3;<br />    ....<br />    statement4;<br />    ....    <br />   END; <br />END<br /></pre>  | 

## 将 Oracle 中的 WITH 语句转换为 RDS for MySQL 或 Amazon Aurora MySQL
<a name="CHAP_Source.Oracle.ToMySQL.With"></a>

您可使用 Oracle 中的 WITH 子句（subquery\$1factoring）将名称（query\$1name）分配到子查询块。然后，您可以通过指定查询名称来引用查询中的子查询块多位置。如果子查询块不包含链接或参数（本地、过程、函数、包），则 AWS SCT 会将该子句转换为视图或临时表。

将子句转换为临时表的好处是，对子查询的重复引用可能更有效。效率之所以更高，是因为可以轻松地从临时表中检索数据，而不是每次引用都需要数据。您可以通过使用额外的视图或临时表模拟。视图名称使用格式 `<procedure_name>$<subselect_alias>`。

您可以在下表中找到示例。


| Oracle 语句 | MySQL 语句 | 
| --- | --- | 
|  <pre>CREATE PROCEDURE <br /> TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01<br />     (p_state IN NUMBER)<br />AS<br />  l_dept_id NUMBER := 1; <br />BEGIN<br />FOR cur IN  <br />           (WITH dept_empl(id, name, surname, <br />              lastname, state, dept_id)<br />              AS<br />                  (<br />                    SELECT id, name, surname,  <br />                     lastname, state, dept_id <br />                      FROM test_ora_pg.dept_employees<br />                     WHERE state = p_state AND <br />                       dept_id = l_dept_id)<br />            SELECT id,state   <br />              FROM dept_empl<br />            ORDER BY id)  LOOP<br />  NULL;<br />END LOOP;<br /></pre>  |  <pre>CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)<br />BEGIN<br />    DECLARE var_l_dept_id DOUBLE DEFAULT 1;<br />    DECLARE var$id VARCHAR (8000);<br />    DECLARE var$state VARCHAR (8000);<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT<br />        ID, STATE<br />        FROM (SELECT<br />            ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID<br />            FROM TEST_ORA_PG.DEPT_EMPLOYEES<br />            WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl<br />        ORDER BY ID;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />        FETCH cur INTO var$id, var$state;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /></pre>  | 
|  <pre>CREATE PROCEDURE <br /> TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01<br />AS    <br />BEGIN<br /><br /> FOR cur IN  (<br />               WITH dept_empl AS<br />                   (<br />                        SELECT id, name, surname, <br />                         lastname, state, dept_id <br />                          FROM test_ora_pg.dept_employees<br />                         WHERE state = 1),<br />                    dept AS <br />                   (SELECT id deptid, parent_id, <br />                      name deptname<br />                      FROM test_ora_pg.department                <br />                   )<br />                SELECT dept_empl.*,dept.*          <br />                 FROM dept_empl, dept<br />                 WHERE dept_empl.dept_id = dept.deptid<br />              ) LOOP<br />              NULL;<br />            END LOOP;<br /></pre>  |  <pre>CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl<br /> `(id, name, surname, lastname, state, dept_id)<br />AS<br />(SELECT id, name, surname, lastname, state, dept_id <br />   FROM test_ora_pg.dept_employees<br />  WHERE state = 1);<br />  <br />CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept<br /> `(deptid, parent_id,deptname)<br />AS<br />(SELECT id deptid, parent_id, name deptname<br />   FROM test_ora_pg.department);  <br /><br /><br />CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()<br />BEGIN<br />    DECLARE var$ID DOUBLE;<br />    DECLARE var$NAME VARCHAR (30);<br />    DECLARE var$SURNAME VARCHAR (30);<br />    DECLARE var$LASTNAME VARCHAR (30);<br />    DECLARE var$STATE DOUBLE;<br />    DECLARE var$DEPT_ID DOUBLE;<br />    DECLARE var$deptid DOUBLE;<br />    DECLARE var$PARENT_ID DOUBLE;<br />    DECLARE var$deptname VARCHAR (200);<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT<br />        dept_empl.*, dept.*<br />        FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl<br />          ` AS dept_empl,<br />             TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept<br />          ` AS dept<br />        WHERE dept_empl.DEPT_ID = dept.DEPTID;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />    FETCH cur INTO var$ID, var$NAME, var$SURNAME, <br />     var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid, <br />     var$PARENT_ID, var$deptname;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /><br />call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()<br /></pre>  | 
|  <pre>CREATE PROCEDURE <br />  TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)<br />AS    <br />   l_dept_id NUMBER := 10;<br />BEGIN<br /> FOR cur IN  (<br />               WITH emp AS              <br />                    (SELECT id, name, surname, <br />                      lastname, state, dept_id <br />                       FROM test_ora_pg.dept_employees<br />                      WHERE dept_id > 10                 <br />                    ),<br />                    active_emp AS<br />                    (<br />                      SELECT id<br />                        FROM emp<br />                       WHERE emp.state = p_state <br />                    )<br />                    <br />                SELECT *          <br />                  FROM active_emp                 <br />              ) LOOP<br />         NULL;<br />  END LOOP;<br />  <br />END;<br /></pre>  |  <pre>CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp<br />    `(id, name, surname, lastname, state, dept_id)<br />AS<br />(SELECT<br />       id, name, surname, lastname, <br />       state, dept_id<br />  FROM TEST_ORA_PG.DEPT_EMPLOYEES<br />  WHERE DEPT_ID > 10);<br /><br /><br />CREATE PROCEDURE <br />   test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)<br />BEGIN<br />    DECLARE var_l_dept_id DOUBLE DEFAULT 10;<br />    DECLARE var$ID DOUBLE;<br />    DECLARE done INT DEFAULT FALSE;<br />    DECLARE cur CURSOR FOR SELECT *<br />                             FROM (SELECT<br />                                      ID<br />                                     FROM <br />                             TEST_ORA_PG.<br />                              `P_WITH_SELECT_VAR_CROSS_01$emp` AS emp<br />                                   WHERE emp.STATE = par_p_state) <br />                                    AS active_emp;<br />    DECLARE CONTINUE HANDLER FOR NOT FOUND<br />        SET done := TRUE;<br />    OPEN cur;<br /><br />    read_label:<br />    LOOP<br />        FETCH cur INTO var$ID;<br /><br />        IF done THEN<br />            LEAVE read_label;<br />        END IF;<br /><br />        BEGIN<br />        END;<br />    END LOOP;<br />    CLOSE cur;<br />END;<br /></pre>  | 

# 从 Oracle 数据库迁移到 Amazon RDS for Oracle AWS Schema Conversion Tool
<a name="CHAP_Source.Oracle.ToRDSOracle"></a>

将 Oracle 架构和代码迁移到 Amazon RDS for Oracle 时要考虑的一些事项：
+ AWS SCT 可以将目录对象添加到对象树中。*目录对象*是逻辑结构，每个结构代表服务器文件系统上的物理目录。可以使用包含包（如 DBMS\$1LOB、UTL\$1FILE、DBMS\$1FILE\$1TRANSFER、DATAPUMP 实用程序等）的目录对象。
+ AWS SCT 支持将 Oracle 表空间转换为 Amazon RDS for Oracle 数据库实例。Oracle 将数据存储在表空间中 (按逻辑) 和与相应表空间关联的数据文件中 (以物理方式)。在 Oracle 中，可以创建包含数据文件名的表空间。Amazon RDS 仅支持数据文件、日志文件和控制文件的 Oracle 托管文件 (OMF)。 AWS SCT 在转换过程中创建所需的数据文件。
+ AWS SCT 可以转换服务器级别的角色和权限。Oracle 数据库引擎采用了基于角色的安全机制。角色是可授予用户或从用户撤消的特权的集合。Amazon RDS 中名为 DBA 的预定义角色一般允许 Oracle 数据库引擎上的所有管理特权。对于使用 Oracle 引擎的 Amazon RDS 数据库实例，DBA 角色没有以下权限：
  + 更改数据库
  + 更改系统
  + 创建任何目录
  + 授予任何权限
  + 授予任何角色
  + 创建外部任务

  您可以向 Amazon RDS for Oracle 用户角色授予所有其他权限，包括高级筛选和列权限。
+ AWS SCT 支持将 Oracle 任务转换为可以在 Amazon RDS for Oracle 上运行的任务。转换存在一些限制，其中包括：
  + 不支持可执行文件作业。
  + 不支持使用 ANYDATA 数据类型作为参数的计划作业。
+ Oracle Real Application Clusters (RAC) One Node 是在 Oracle Database 11g Release 2 中引入的 Oracle Database Enterprise Edition 的选件。Amazon RDS for Oracle 不支持 RAC 功能。为了实现高可用性，可使用 Amazon RDS 多可用区。

  在多可用区部署中，Amazon RDS 会自动在不同可用区中配置和维护一个同步备用副本。主数据库实例可以跨可用区同步复制到备用副本。此功能提供了数据冗余，消除了 I/O 冻结，并最大限度地减少了系统备份期间的延迟峰值。
+ Oracle Spatial 提供了一个 SQL 架构和一些功能，可帮助在 Oracle 数据库中存储、检索、更新和查询空间数据集合。Oracle Locator 提供支持基于 Internet 和无线服务的应用程序与基于合作伙伴的 GIS 解决方案通常所需的功能。Oracle Locator 是 Oracle Spatial 的有限子集。

  要使用 Oracle Spatial 和 Oracle Locator 功能，可以将 SPATIAL 选项或 LOCATOR 选项（互斥）添加到数据库实例的选项组。

  在 Amazon RDS for Oracle 数据库实例上使用 Oracle Spatial 和 Oracle Locator 有一些先决条件：
  + 该实例应使用 Oracle 企业版 12.1.0.2.v6 版或更高版本，或者 11.2.0.4.v10 版或更高版本。
  + 该实例应在 Virtual Private Cloud (VPC) 内。
  + 该实例应该是可支持 Oracle 功能的数据库实例类。例如，db.m1.small、db.t1.micro、db.t2.micro 或 db.t2.small 数据库实例类不支持 Oracle Spatial。有关更多信息，请参阅 [Oracle 的数据库实例类支持](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html#Oracle.Concepts.InstanceClasses)。
  + 实例必须已启用“Auto Minor Version Upgrade (自动次要版本升级)”选项。如果存在 CVSS 评分为 9\$1 的安全漏洞或其他公布的安全漏洞，则 Amazon RDS 会将数据库实例更新为最新的 Oracle PSU。有关更多信息，请参阅 

    [适用于 Oracle 数据库实例的设置](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ModifyInstance.Oracle.html#USER_ModifyInstance.Oracle.Settings)。
  + 如果数据库实例为 11.2.0.4.v10 版或更高版本，则必须安装 XMLDB 选项。有关更多信息，请参阅 

    [Oracle XML 数据库](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.XMLDB.html)。
  + 您应该拥有 Oracle 中的 Oracle Spatial 许可证。有关更多信息，请参阅 Oracle 文档中的 [Oracle Spatial 和图表](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph)。
+ Data Guard 随 Oracle Database Enterprise Edition 提供。为了实现高可用性，可使用 Amazon RDS 多可用区功能。

  在多可用区部署中，Amazon RDS 会自动在不同可用区中配置和维护一个同步备用副本。主数据库实例可以跨可用区同步复制到备用副本。此功能提供了数据冗余，消除了 I/O 冻结，并最大限度地减少了系统备份期间的延迟峰值。
+ AWS SCT 在迁移到适用于 Oracle 的 Amazon RDS 时，支持转换 Oracle DBMS\$1SCHEDULER 对象。 AWS SCT 评估报告指明是否可以转换计划对象。有关将计划对象用于 Amazon RDS 的详细信息，请参阅 [Amazon RDS 文档](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.System.html#Appendix.Oracle.CommonDBATasks.ModifyScheduler)。
+ 对于 Oracle 到 Amazon RDS for Oracle 转换，支持数据库链接。数据库链接是一个数据库中的架构对象，允许您访问另一个数据库上的对象。另一个数据库不需要是 Oracle 数据库。但是，要访问非 Oracle 数据库，您必须使用 Oracle 异构服务。

  创建数据库链接后，可以使用 SQL 语句中的链接来引用其他数据库中的表、视图和 PL/SQL 对象。要使用数据库链接，请在表、视图或 PL/SQL 对象名称后面追加`@dblink`。您可以使用 SELECT 语句查询其他数据库中的表或视图。有关使用 Oracle 数据库链接的更多信息，请参阅 [Oracle 文档](https://docs.oracle.com/cd/B28359_01/server.111/b28310/ds_concepts002.htm#ADMIN12083)。

  有关将数据库链接与 Amazon RDS 一起使用的更多信息，请参阅 [Amazon RDS 文档](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Database.html#Appendix.Oracle.CommonDBATasks.DBLinks)。
+  AWS SCT 评估报告提供了转化的服务器指标。这些有关 Oracle 实例的指标包括：
  + 目标数据库实例的计算和内存容量。
  + 不支持的 Oracle 功能。例如，Amazon RDS 不支持的 Real Application Clusters。
  + 磁盘读写负载
  + 平均总磁盘吞吐量
  + 服务器信息，如服务器名称、操作系统、主机名和字符集。

## 将 Oracle 用作目标的权限
<a name="CHAP_Source.Oracle.ToRDSOracle.ConfigureTarget"></a>

要迁移到 Amazon RDS for Oracle，请创建特权数据库用户。您可以使用以下代码示例：

```
CREATE USER user_name IDENTIFIED BY your_password;

-- System privileges
GRANT DROP ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE TO user_name;
GRANT CREATE ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY ASSEMBLY TO user_name;
GRANT ALTER ANY RULE TO user_name;
GRANT SELECT ANY DICTIONARY TO user_name;
GRANT ALTER ANY DIMENSION TO user_name;
GRANT CREATE ANY DIMENSION TO user_name;
GRANT ALTER ANY TYPE TO user_name;
GRANT DROP ANY TRIGGER TO user_name;
GRANT CREATE ANY VIEW TO user_name;
GRANT ALTER ANY CUBE BUILD PROCESS TO user_name;
GRANT CREATE ANY CREDENTIAL TO user_name;
GRANT DROP ANY CUBE DIMENSION TO user_name;
GRANT DROP ANY ASSEMBLY TO user_name;
GRANT DROP ANY PROCEDURE TO user_name;
GRANT ALTER ANY PROCEDURE TO user_name;
GRANT ALTER ANY SQL TRANSLATION PROFILE TO user_name;
GRANT DROP ANY MEASURE FOLDER TO user_name;
GRANT CREATE ANY MEASURE FOLDER TO user_name;
GRANT DROP ANY CUBE TO user_name;
GRANT DROP ANY MINING MODEL TO user_name;
GRANT CREATE ANY MINING MODEL TO user_name;
GRANT DROP ANY EDITION TO user_name;
GRANT CREATE ANY EVALUATION CONTEXT TO user_name;
GRANT DROP ANY DIMENSION TO user_name;
GRANT ALTER ANY INDEXTYPE TO user_name;
GRANT DROP ANY TYPE TO user_name;
GRANT CREATE ANY PROCEDURE TO user_name;
GRANT CREATE ANY SQL TRANSLATION PROFILE TO user_name;
GRANT CREATE ANY CUBE TO user_name;
GRANT COMMENT ANY MINING MODEL TO user_name;
GRANT ALTER ANY MINING MODEL TO user_name;
GRANT DROP ANY SQL PROFILE TO user_name;
GRANT CREATE ANY JOB TO user_name;
GRANT DROP ANY EVALUATION CONTEXT TO user_name;
GRANT ALTER ANY EVALUATION CONTEXT TO user_name;
GRANT CREATE ANY INDEXTYPE TO user_name;
GRANT CREATE ANY OPERATOR TO user_name;
GRANT CREATE ANY TRIGGER TO user_name;
GRANT DROP ANY ROLE TO user_name;
GRANT DROP ANY SEQUENCE TO user_name;
GRANT DROP ANY CLUSTER TO user_name;
GRANT DROP ANY SQL TRANSLATION PROFILE TO user_name;
GRANT ALTER ANY ASSEMBLY TO user_name;
GRANT CREATE ANY RULE SET TO user_name;
GRANT ALTER ANY OUTLINE TO user_name;
GRANT UNDER ANY TYPE TO user_name;
GRANT CREATE ANY TYPE TO user_name;
GRANT DROP ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY ROLE TO user_name;
GRANT DROP ANY VIEW TO user_name;
GRANT ALTER ANY INDEX TO user_name;
GRANT COMMENT ANY TABLE TO user_name;
GRANT CREATE ANY TABLE TO user_name;
GRANT CREATE USER TO user_name;
GRANT DROP ANY RULE SET TO user_name;
GRANT CREATE ANY CONTEXT TO user_name;
GRANT DROP ANY INDEXTYPE TO user_name;
GRANT ALTER ANY OPERATOR TO user_name;
GRANT CREATE ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY SEQUENCE TO user_name;
GRANT DROP ANY SYNONYM TO user_name;
GRANT CREATE ANY SYNONYM TO user_name;
GRANT DROP USER TO user_name;
GRANT ALTER ANY MEASURE FOLDER TO user_name;
GRANT ALTER ANY EDITION TO user_name;
GRANT DROP ANY RULE TO user_name;
GRANT CREATE ANY RULE TO user_name;
GRANT ALTER ANY RULE SET TO user_name;
GRANT CREATE ANY OUTLINE TO user_name;
GRANT UNDER ANY TABLE TO user_name;
GRANT UNDER ANY VIEW TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
GRANT ALTER ANY CLUSTER TO user_name;
GRANT CREATE ANY CLUSTER TO user_name;
GRANT ALTER ANY TABLE TO user_name;
GRANT CREATE ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY EDITION TO user_name;
GRANT CREATE ANY SQL PROFILE TO user_name;
GRANT ALTER ANY SQL PROFILE TO user_name;
GRANT DROP ANY OUTLINE TO user_name;
GRANT DROP ANY CONTEXT TO user_name;
GRANT DROP ANY OPERATOR TO user_name;
GRANT DROP ANY LIBRARY TO user_name;
GRANT ALTER ANY LIBRARY TO user_name;
GRANT CREATE ANY LIBRARY TO user_name;
GRANT ALTER ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY TRIGGER TO user_name;
GRANT CREATE ANY SEQUENCE TO user_name;
GRANT DROP ANY INDEX TO user_name;
GRANT CREATE ANY INDEX TO user_name;
GRANT DROP ANY TABLE TO user_name;
GRANT SELECT_CATALOG_ROLE TO user_name;
GRANT SELECT ANY SEQUENCE TO user_name;

-- Database Links
GRANT CREATE DATABASE LINK TO user_name;
GRANT CREATE PUBLIC DATABASE LINK TO user_name;
GRANT DROP PUBLIC DATABASE LINK TO user_name;


-- Server Level Objects (directory)
GRANT CREATE ANY DIRECTORY TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
-- (for RDS only)
GRANT EXECUTE ON RDSADMIN.RDSADMIN_UTIL TO user_name;

-- Server Level Objects (tablespace)
GRANT CREATE TABLESPACE TO user_name;
GRANT DROP TABLESPACE TO user_name;

-- Server Level Objects (user roles)
/* (grant source privileges with admin option or convert roles/privs as DBA) */

-- Queues
grant execute on DBMS_AQADM to user_name;
grant aq_administrator_role to user_name;

-- for Materialized View Logs creation
GRANT SELECT ANY TABLE TO user_name;

-- Roles
GRANT RESOURCE TO user_name;
GRANT CONNECT TO user_name;
```

在前面的示例中，*user\$1name*使用您的用户名替换。然后，*your\$1password*替换为安全密码。

## 将 Oracle 转换为 Amazon RDS for Oracle 的限制
<a name="CHAP_Source.Oracle.ToRDSOracle.Limitations"></a>

将 Oracle 架构和代码迁移到 Amazon RDS for Oracle 时应考虑的一些限制：
+  Amazon RDS 中名为 DBA 的预定义角色一般允许 Oracle 数据库引擎上的所有管理特权。对于使用 Oracle 引擎的 Amazon RDS 数据库实例，DBA 角色没有以下权限：
  + 更改数据库
  + 更改系统
  + 创建任何目录
  + 授予任何权限
  + 授予任何角色
  + 创建外部任务

  可以向 Oracle RDS 用户角色授予所有其他特权。
+ Amazon RDS for Oracle 支持传统审核、使用 DBMS\$1FGA 包的精细审核以及 Oracle 的统一审核。
+ Amazon RDS for Oracle 不支持更改数据捕获 (CDC)。要在数据库迁移期间和迁移之后执行更改数据捕获，请使用 AWS Database Migration Service。