`。
您可以在下表中找到示例。
| Oracle 语句 | MySQL 语句 |
| --- | --- |
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01
(p_state IN NUMBER)
AS
l_dept_id NUMBER := 1;
BEGIN
FOR cur IN
(WITH dept_empl(id, name, surname,
lastname, state, dept_id)
AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = p_state AND
dept_id = l_dept_id)
SELECT id,state
FROM dept_empl
ORDER BY id) LOOP
NULL;
END LOOP;
| CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 1;
DECLARE var$id VARCHAR (8000);
DECLARE var$state VARCHAR (8000);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
ID, STATE
FROM (SELECT
ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl
ORDER BY ID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$id, var$state;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01
AS
BEGIN
FOR cur IN (
WITH dept_empl AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1),
dept AS
(SELECT id deptid, parent_id,
name deptname
FROM test_ora_pg.department
)
SELECT dept_empl.*,dept.*
FROM dept_empl, dept
WHERE dept_empl.dept_id = dept.deptid
) LOOP
NULL;
END LOOP;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT id, name, surname, lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1);
CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
`(deptid, parent_id,deptname)
AS
(SELECT id deptid, parent_id, name deptname
FROM test_ora_pg.department);
CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
BEGIN
DECLARE var$ID DOUBLE;
DECLARE var$NAME VARCHAR (30);
DECLARE var$SURNAME VARCHAR (30);
DECLARE var$LASTNAME VARCHAR (30);
DECLARE var$STATE DOUBLE;
DECLARE var$DEPT_ID DOUBLE;
DECLARE var$deptid DOUBLE;
DECLARE var$PARENT_ID DOUBLE;
DECLARE var$deptname VARCHAR (200);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
dept_empl.*, dept.*
FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
` AS dept_empl,
TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
` AS dept
WHERE dept_empl.DEPT_ID = dept.DEPTID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID, var$NAME, var$SURNAME,
var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid,
var$PARENT_ID, var$deptname;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)
AS
l_dept_id NUMBER := 10;
BEGIN
FOR cur IN (
WITH emp AS
(SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE dept_id > 10
),
active_emp AS
(
SELECT id
FROM emp
WHERE emp.state = p_state
)
SELECT *
FROM active_emp
) LOOP
NULL;
END LOOP;
END;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT
id, name, surname, lastname,
state, dept_id
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE DEPT_ID > 10);
CREATE PROCEDURE
test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 10;
DECLARE var$ID DOUBLE;
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT *
FROM (SELECT
ID
FROM
TEST_ORA_PG.
`P_WITH_SELECT_VAR_CROSS_01$emp` AS emp
WHERE emp.STATE = par_p_state)
AS active_emp;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
# 从 Oracle 数据库迁移到 Amazon RDS for Oracle AWS Schema Conversion Tool
将 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 用作目标的权限
要迁移到 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 的限制
将 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。
# 使用连接到 PostgreSQL 数据库 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、数据库代码对象和应用程序代码从 PostgreSQL 转换为以下目标：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL 兼容版
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL 兼容版
有关详细信息，请参阅以下章节：
**Topics**
+ [将 PostgreSQL 用作源数据库的权限](#CHAP_Source.PostgreSQL.Permissions)
+ [连接到作为源的 PostgreSQL](#CHAP_Source.PostgreSQL.Connecting)
+ [将 MySQL 用作目标数据库的权限](#CHAP_Source.PostgreSQL.ConfigureMySQL)
## 将 PostgreSQL 用作源数据库的权限
下面列出了将 PostgreSQL 用作源所需的权限：
+ 连接数据库 **
+ 架构上的用法 **
+ 在架构中的所有表上选择 **
+ 在架构中的所有序列上选择 **
## 连接到作为源的 PostgreSQL
使用 AWS Schema Conversion Tool按照以下过程连接到 PostgreSQL 源数据库。
**连接到 PostgreSQL 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **PostgreSQL**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 PostgreSQL 源数据库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.PostgreSQL.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## 将 MySQL 用作目标数据库的权限
从 PostgreSQL 迁移时，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
+ 插入，在 AWS\$1POSTGRESQL \$1EXT 上更新。 \$1
+ 在 AWS\$1POSTGRESQL \$1EXT\$1DATA 上插入、更新、删除。 \$1
+ 在 AWS\$1POSTGRESQL \$1EXT\$1DATA 上创建临时表。 \$1
您可以使用以下代码示例创建数据库用户并授予权限。
```
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 INSERT, UPDATE ON AWS_POSTGRESQL_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
```
在前面的示例中，*user\$1name*使用您的用户名替换。然后，*your\$1password*替换为安全密码。
要使用 Amazon RDS for MySQL 或 Aurora MySQL 作为目标，请将 `lower_case_table_names` 参数设置为 `1`。此值意味着 MySQL 服务器在处理表、索引、触发器和数据库等对象名称的标识符时不区分大小写。如果目标实例中已开启二进制日志记录，请将 `log_bin_trust_function_creators` 参数设置为 `1`。在这种情况下，您无需使用 `DETERMINISTIC`、`READS SQL DATA` 或 `NO SQL` 特性创建存储函数。要配置这些参数，请创建新的数据库参数组或修改现有数据库参数组。
# 使用连接到 SAP 数据库 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、数据库代码对象和应用程序代码从 SAP (Sybase) Adaptive Server Enterprise (ASE) 转换为以下目标：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL 兼容版
+ Amazon RDS for MariaDB
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL 兼容版
有关详细信息，请参阅以下章节：
**Topics**
+ [将 SAP ASE 用作源数据库的权限](#CHAP_Source.SAP.Permissions)
+ [连接到作为源的 SAP ASE (Sybase)](#CHAP_Source.SAP.Connecting)
+ [将 MySQL 用作目标数据库的权限](#CHAP_Source.SAP.ConfigureMySQL)
+ [SAP ASE 到 MySQL 的转换设置](#CHAP_Source.SAP.MySQLConversionSettings)
+ [将 PostgreSQL 用作目标数据库的权限](#CHAP_Source.SAP.ConfigurePostgreSQL)
+ [SAP ASE 到 PostgreSQL 的转换设置](#CHAP_Source.SAP.PostgreSQLConversionSettings)
## 将 SAP ASE 用作源数据库的权限
要将 SAP ASE 数据库作为源，您需要创建数据库用户并授予权限。为此，请执行以下步骤：
**创建和配置数据库用户**
1. 连接到源数据库。
1. 使用以下命令创建数据库用户。提供新用户密码。
```
USE master
CREATE LOGIN min_privs WITH PASSWORD
sp_adduser min_privs
grant select on dbo.spt_values to min_privs
grant select on asehostname to min_privs
```
1. 为要迁移的每个数据库授予以下权限。
```
USE
sp_adduser min_privs
grant select on dbo.sysusers to min_privs
grant select on dbo.sysobjects to min_privs
grant select on dbo.sysindexes to min_privs
grant select on dbo.syscolumns to min_privs
grant select on dbo.sysreferences to min_privs
grant select on dbo.syscomments to min_privs
grant select on dbo.syspartitions to min_privs
grant select on dbo.syspartitionkeys to min_privs
grant select on dbo.sysconstraints to min_privs
grant select on dbo.systypes to min_privs
grant select on dbo.sysqueryplans to min_privs
```
## 连接到作为源的 SAP ASE (Sybase)
使用 AWS Schema Conversion Tool按照以下过程连接到 SAP ASE 源数据库。
**连接到 SAP ASE 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **SAP ASE**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 SAP ASE 源数据库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.SAP.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## 将 MySQL 用作目标数据库的权限
下面列出了将 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
+ 插入，在 AWS\$1SAPASE \$1EXT 上更新。 \$1
+ 在 AWS\$1SAPASE \$1EXT 上创建临时表。 \$1
您可以使用以下代码示例创建数据库用户并授予权限。
```
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 INSERT, UPDATE ON AWS_SAPASE_EXT.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SAPASE_EXT.* TO 'user_name';
```
在前面的示例中，*user\$1name*使用您的用户名替换。然后，*your\$1password*替换为安全密码。
要使用 Amazon RDS for MySQL 或 Aurora MySQL 作为目标，请将 `lower_case_table_names` 参数设置为 `1`。此值意味着 MySQL 服务器在处理表、索引、触发器和数据库等对象名称的标识符时不区分大小写。如果目标实例中已开启二进制日志记录，请将 `log_bin_trust_function_creators` 参数设置为 `1`。在这种情况下，您无需使用 `DETERMINISTIC`、`READS SQL DATA` 或 `NO SQL` 特性创建存储函数。要配置这些参数，请创建新的数据库参数组或修改现有数据库参数组。
## SAP ASE 到 MySQL 的转换设置
要编辑 SAP ASE 到 MySQL 的转换设置，请选择**设置**，然后选择**转换设置**。从上面的列表中选择 **SAP ASE**，然后选择 **SAP ASE – MySQL** 或 **SAP ASE – Amazon Aurora（兼容 MySQL）**。 AWS SCT 显示 SAP ASE 到 PostgreSQL 转换的所有可用设置。
中的 SAP ASE 到 MySQL 的转换设置 AWS SCT 包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 在转换后的代码中使用源数据库对象的确切名称。
默认情况下， AWS SCT 将数据库对象、变量和参数的名称转换为小写。要保持这些名称的原始大小写，请选择**源数据库对象名称区分大小写**。如果源 SAP ASE 数据库服务器中使用区分大小写的对象名称，请选择此选项。
## 将 PostgreSQL 用作目标数据库的权限
要使用 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 中，只有架构所有者或 `superuser` 才能删除架构。即使架构的所有者并不拥有架构的某些对象，该所有者也可以删除该架构及其包含的所有对象。
当你使用不同的用户转换不同的架构并将其应用到目标数据库时，当无法删除架构时，你 AWS SCT 可能会收到一条错误消息。要避免出现此错误消息，请使用 `superuser` 角色。
## SAP ASE 到 PostgreSQL 的转换设置
要编辑 SAP ASE 到 PostgreSQL 的转换设置，请选择**设置**，然后选择**转换设置**。从上面的列表中选择 **SAP ASE**，然后选择 **SAP ASE – PostgreSQL** 或 **SAP ASE – Amazon Aurora（兼容 PostgreSQL）**。 AWS SCT 显示 SAP ASE 到 PostgreSQL 转换的所有可用设置。
中的 SAP ASE 到 PostgreSQL AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 定义要在转换后的代码中用于架构名称的模板。对于**架构名称生成模板**，选择以下选项之一：
+ ****：使用 SAP ASE 数据库名称作为 PostgreSQL 中的架构名称。
+ ****：使用 SAP ASE 架构名称作为 PostgreSQL 中的架构名称。
+ **\$1**：使用 SAP ASE 数据库名称和架构名称的组合作为 PostgreSQL 中的架构名称。
+ 在转换后的代码中使用源数据库对象的确切名称。
默认情况下， AWS SCT 将数据库对象、变量和参数的名称转换为小写。要保持这些名称的原始大小写，请选择**源数据库对象名称区分大小写**。如果源 SAP ASE 数据库服务器中使用区分大小写的对象名称，请选择此选项。
对于区分大小写的操作， AWS SCT 可以避免将数据库对象名称转换为小写。为此，请选择**避免将区分大小写的操作转换为小写**。
+ 允许在 SAP ASE 的不同表中使用同名索引。
在 PostgreSQL 中，架构中使用的所有索引名称都必须是唯一的。要确保为所有索引 AWS SCT 生成唯一的名称，请选择 “**为索引生成唯一名称**”。
# 将 Microsoft SQL 服务器与 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、数据库代码对象和应用程序代码从 SQL Server 转换为以下目标：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL 兼容版
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL 兼容版
+ Amazon RDS for SQL Server
+ Amazon RDS for MariaDB
**注意**
AWS SCT 不支持使用适用于 SQL 服务器的 Amazon RDS 作为来源。
您可以使用创建评估报告，用于 AWS SCT 将架构、数据库代码对象和应用程序代码从 SQL Server 迁移到 Babelfish for Aurora PostgreSQL，如下所述。
**Topics**
+ [将 Microsoft SQL Server 用作源的权限](#CHAP_Source.SQLServer.Permissions)
+ [当将 Microsoft SQL Server 用作源时使用 Windows 身份验证](#CHAP_Source.SQLServer.Permissions.WinAuth)
+ [连接到作为源的 SQL Server](#CHAP_Source.SQLServer.Connecting)
+ [将 SQL Server 转换为 MySQL](CHAP_Source.SQLServer.ToMySQL.md)
+ [使用从 SQL Server 迁移到 PostgreSQL AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToPostgreSQL.md)
+ [从 SQL Server 迁移到适用于 SQL Server 的 Amazon RDS AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToRDSSQLServer.md)
## 将 Microsoft SQL Server 用作源的权限
下面列出了将 Microsoft SQL Server 用作源所需的权限：
+ VIEW DEFINITION
+ VIEW DATABASE STATE
该`VIEW DEFINITION`权限允许具有公共访问权限的用户查看对象定义。 AWS SCT 使用`VIEW DATABASE STATE`权限检查 SQL Server 企业版的功能。
对要转换其架构的每个数据库重复以上授权。
此外，授予针对 `master` 数据库的以下权限：
+ VIEW SERVER STATE
+ VIEW ANY DEFINITION
AWS SCT 使用`VIEW SERVER STATE`权限收集服务器设置和配置。确保授予 `VIEW ANY DEFINITION` 权限以便查看端点。
要读取有关 Microsoft Analysis Services 的信息，请在 `master` 数据库上运行以下命令。
```
EXEC master..sp_addsrvrolemember @loginame = N'', @rolename = N'sysadmin'
```
在上述示例中，将 `` 占位符替换为您之前授予权限的用户名。
要阅读有关 SQL Server Agent 的信息，请将用户添加到 `SQLAgentUser` 角色中。在 `msdb` 数据库上运行以下命令。
```
EXEC sp_addrolemember , ;
```
在上述示例中，将 `` 占位符替换为 SQL Server Agent 角色的名称。然后将 `` 占位符替换为您之前授予权限的用户名。有关更多信息，请参阅 *Amazon RDS SQLAgent 用户指南中的向用户*[角色添加](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.Agent.html#SQLServerAgent.AddUser)用户。
要检测日志传输，请授予针对 `msdb` 数据库的 `SELECT on dbo.log_shipping_primary_databases` 权限。
要使用 DDL 复制的通知方法，请授予针对源数据库的 `RECEIVE ON .` 权限。在本例中，将 `` 占位符替换为数据库的架构名称。然后，将 `` 占位符替换为队列表的名称。
## 当将 Microsoft SQL Server 用作源时使用 Windows 身份验证
如果您的应用程序在基于 Windows 的 Intranet 上运行，您可能可以使用 Windows 身份验证进行数据库访问。Windows 身份验证使用在操作系统线程上建立的当前 Windows 身份来访问 SQL Server 数据库。然后，您可以将 Windows 身份映射到 SQL Server 数据库和权限。要使用 Windows 身份验证连接到 SQL Server，您必须指定您的应用程序正在使用的 Windows 身份。您还必须向 Windows 身份授予访问 SQL Server 数据库的权限。
SQL Server 有两种访问模式：Windows 身份验证模式和混合模式。Windows 身份验证模式启用 Windows 身份验证，禁用 SQL Server 身份验证。混合模式启用 Windows 身份验证和 SQL Server 身份验证。Windows 身份验证是始终可用的，无法禁用。有关 Windows 身份验证的更多信息，请参阅 Microsoft Windows 文档。
在 TEST\$1DB 中创建用户的可能示例如下所示。
```
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
```
### 将 Windows 身份验证与 JDBC 连接配合使用
在非 Windows 操作系统上使用 JDBC 驱动程序时，驱动程序不支持 Windows 身份验证。当从非 Windows 操作系统连接到 SQL Server 时，不会自动指定 Windows 身份验证凭证，例如用户名和密码。在这种情况下，应用程序必须改而使用 SQL Server 身份验证。
在 JDBC 连接字符串中，必须指定参数 `integratedSecurity` ，才能使用 Windows 身份验证进行连接。JDBC 驱动程序通过 `integratedSecurity` 连接字符串参数在 Windows 操作系统上支持集成 Windows 身份验证。
使用集成身份验证
1. 安装 JDBC 驱动程序。
1. 将 `sqljdbc_auth.dll` 文件复制到装有 JDBC 驱动程序的计算机上的 Windows 系统路径上的目录中。
`sqljdbc_auth.dll` 文件安装在以下位置：
<*安装目录*>\$1sqljdbc\$1<*版本*>\$1<*语言*>\$1auth\$1
当您尝试使用 Windows 身份验证建立与 SQL Server 数据库的连接时，您可能会收到以下错误：此驱动程序未针对集成身份验证进行配置。通过执行以下操作可以解决此问题：
+ 声明两个指向 JDBC 的安装路径的变量：
`variable name: SQLJDBC_HOME; variable value: D:\lib\JDBC4.1\enu`（sqljdbc4.jar 所在的位置）；
`variable name: SQLJDBC_AUTH_HOME; variable value: D\lib\JDBC4.1\enu\auth\x86`（如果您运行的是 32 位操作系统）或 `D\lib\JDBC4.1\enu\auth\x64`（如果您运行的是 64 位操作系统）。这是 `sqljdbc_auth.dll` 所在的位置。
+ 复制`sqljdbc_auth.dll`到您 JDK/JRE 正在运行的文件夹。您可以复制到 lib 文件夹、bin 文件夹等。例如，您可以复制到以下文件夹。
```
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
```
+ 确保 JDBC 库文件夹中只有 SQLJDBC4 .jar 文件。从该文件夹中删除所有其他 sqljdbc\$1.jar 文件（或将这些文件复制到其他文件夹）。如果要在程序中添加驱动程序，请确保仅添加 SQLJDBC4 .jar 作为要使用的驱动程序。
+ 在您的应用程序所在的文件夹中复制 sqljdbc\$1auth.dll 文件。
**注意**
如果您运行的是 32 位 Java 虚拟机 (JVM)，请使用 x86 文件夹中的 sqljdbc\$1auth.dll 文件，即使操作系统是 x64 版本也是如此。如果您是在 x64 处理器上运行 64 位 JVM ，请使用 x64 文件夹中的 sqljdbc\$1auth.dll 文件。
当您连接到 SQL Server 数据库时，您可以为**身份验证**选项选择 **Windows 身份验证**或 **SQL Server 身份验证**。
## 连接到作为源的 SQL Server
使用 AWS Schema Conversion Tool按照以下过程连接到 Microsoft SQL Server 源数据库。
**连接到 Microsoft SQL Server 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Microsoft SQL Server**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Microsoft SQL Server 源数据库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
# 将 SQL Server 转换为 MySQL
要在转换后的 MySQL 代码中模拟 Microsoft SQL Server 数据库函数，请使用 AWS SCT中的 SQL Server 到 MySQL 扩展包。有关扩展包的更多信息，请参阅[将扩展包与 AWS Schema Conversion Tool](CHAP_ExtensionPack.md)。
**Topics**
+ [将 MySQL 用作目标数据库的权限](#CHAP_Source.SQLServer.ToMySQL.ConfigureTarget)
+ [SQL Server 到 MySQL 的转换设置](#CHAP_Source.SQLServer.ToMySQL.ConversionSettings)
+ [迁移注意事项](#CHAP_Source.SQLServer.ToMySQL.MigrationConsiderations)
## 将 MySQL 用作目标数据库的权限
下面列出了将 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
+ 插入，在 AWS\$1SQLSERVER \$1EXT 上更新。 \$1
+ 在 AWS\$1SQLSERVER \$1EXT\$1DATA 上插入、更新、删除。 \$1
+ 在 AWS\$1SQLSERVER \$1EXT\$1DATA 上创建临时表。 \$1
您可以使用以下代码示例创建数据库用户并授予权限。
```
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 INSERT, UPDATE ON AWS_SQLSERVER_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
```
在前面的示例中，*user\$1name*使用您的用户名替换。然后，*your\$1password*替换为安全密码。
如果将 MySQL 数据库版本 5.7 或更低版本作为目标，请运行以下命令。8.0 及更高版本的 MySQL 数据库不建议使用此命令。
```
GRANT SELECT ON mysql.proc 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` 特性创建存储函数。要配置这些参数，请创建新的数据库参数组或修改现有数据库参数组。
## SQL Server 到 MySQL 的转换设置
要编辑 SQL Server 到 MySQL 的转换**设置，请在中 AWS SCT 选择 “设置”**，然后选择 “**转换设置”**。从上方的列表中选择 **SQL Server**，然后选择 **SQL Server – MySQL**。 AWS SCT 显示 SQL Server 到 MySQL 转换的所有可用设置。
中的 SQL Server 到 MySQL 的转换设置 AWS SCT 包括以下各项的选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 允许您的源 SQL Server 数据库将的输出存储`EXEC`在表中。 AWS SCT 创建临时表和模拟此功能的附加过程。要使用此模拟，请选择**创建额外的例程处理开放数据集**。
## 迁移注意事项
将 SQL Server 架构迁移到 MySQL 时的注意事项：
+ MySQL 不支持 `MERGE` 语句。但是， AWS SCT 可以在转换过程中使用子`MERGE`句和语句来模拟该`UPDATE FROM and DELETE FROM`语`INSERT ON DUPLICATE KEY`句。
对于使用 `INSERT ON DUPLICATE KEY` 的正确模拟，请确保目标 MySQL 数据库上存在唯一约束或主键。
+ 可以使用一个 `GOTO` 语句和一个标签更改语句的运行顺序。将跳过接在 `GOTO` 语句后的任何 Transact-SQL 语句并且处理将在标签处继续。可在过程、批处理或语句块中的任意位置使用 `GOTO` 语句和标签。您也可以嵌套 `GOTO` 语句。
MySQL 不使用 `GOTO` 语句。当 AWS SCT 转换包含`GOTO`语句的代码时，它会将该语句转换为使用`BEGIN…END`或`LOOP…END LOOP`语句。您可以在下表中找到如何 AWS SCT 转换`GOTO`语句的示例。
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL 不支持多语句表值函数。 AWS SCT 通过创建临时表并重写语句以使用这些临时表，在转换过程中模拟表值函数。
# 使用从 SQL Server 迁移到 PostgreSQL AWS Schema Conversion Tool
您可以在 AWS SCT中使用 SQL Server 到 PostgreSQL 的扩展包。此扩展包在转换后的 PostgreSQL 代码中模拟 SQL Server 数据库函数。使用 SQL Server 到 PostgreSQL 扩展包模拟 SQL Server Agent 和 SQL Server 数据库邮件。有关扩展包的更多信息，请参阅[将扩展包与 AWS Schema Conversion Tool](CHAP_ExtensionPack.md)。
**Topics**
+ [将 PostgreSQL 用作目标数据库的权限](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [SQL Server 到 PostgreSQL 的转换设置](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [将 SQL Server 分区转换为 PostgreSQL 版本 10 分区](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [迁移注意事项](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [在 PostgreSQL 中使用 AWS SCT 扩展包模拟 SQL Server 代理](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [在 PostgreSQL 中使用 AWS SCT 扩展包模拟 SQL Server 数据库邮件](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## 将 PostgreSQL 用作目标数据库的权限
要使用 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 中，只有架构所有者或 `superuser` 才能删除架构。即使架构的所有者并不拥有架构的某些对象，该所有者也可以删除该架构及其包含的所有对象。
当你使用不同的用户转换不同的架构并将其应用到目标数据库时，当无法删除架构时，你 AWS SCT 可能会收到一条错误消息。要避免出现此错误消息，请使用 `superuser` 角色。
## SQL Server 到 PostgreSQL 的转换设置
要编辑 SQL Server 到 PostgreSQL 的转换设置，请选择**设置**，然后选择**转换设置**。从上方的列表中选择 **SQL Server**，然后选择 **SQL Server – PostgreSQL**。 AWS SCT 显示 SQL Server 到 PostgreSQL 转换的所有可用设置。
中的 SQL Server 到 PostgreSQL 的转换设置包括以下 AWS SCT 各项的选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 允许在 SQL Server 的不同表中使用同名索引。
在 PostgreSQL 中，架构中使用的所有索引名称都必须是唯一的。要确保为所有索引 AWS SCT 生成唯一的名称，请选择 “**为索引生成唯一名称**”。
+ 将 SQL Server 过程转换为 PostgreSQL 函数。
PostgreSQL 版本 10 及更早版本不支持过程。对于不熟悉 PostgreSQL 中使用过程的客户 AWS SCT ，可以将过程转换为函数。为此，请选择**将过程转换为函数**。
+ 在表中模拟 `EXEC` 的输出。
源 SQL Server 数据库可以将 `EXEC` 的输出存储在表中。 AWS SCT 创建临时表和模拟此功能的附加过程。要使用此模拟，请选择**创建额外的例程处理开放数据集**。
+ 定义要在转换后的代码中用于架构名称的模板。对于**架构名称生成模板**，选择以下选项之一：
+ ****：使用 SQL Server 数据库名称作为 PostgreSQL 中的架构名称。
+ ****：使用 SQL Server 架构名称作为 PostgreSQL 中的架构名称。
+ **\$1**：使用 SQL Server 数据库名称和架构名称的组合作为 PostgreSQL 中的架构名称。
+ 保持源对象名称的字母大小写。
要避免将对象名称转换为小写，请选择**避免将区分大小写的操作转换为小写**。仅当您在目标数据库中启用区分大小写选项时，此选项才适用。
+ 保留源数据库中的参数名称。
要在转换后的代码中为参数名称添加双引号，请选择**保留原始参数名称**。
## 将 SQL Server 分区转换为 PostgreSQL 版本 10 分区
将 Microsoft SQL Server 数据库转换为 Amazon Aurora PostgreSQL 兼容版本 (Aurora PostgreSQL) 或适用于 PostgreSQL 的 Amazon Relational Database Service (Amazon RDS for PostgreSQL) 时，请注意以下几点：
在 SQL Server 中，使用分区函数创建分区。从 SQL Server 分区表转换为 PostgreSQL 版本 10 分区表时，请注意一些潜在问题：
+ SQL Server 允许使用无 NOT NULL 约束的列为表分区。在此情况下，所有 NULL 值都将转到最左边的分区。PostgreSQL 不支持 RANGE 分区采用 NULL 值。
+ SQL Server 允许为分区表创建主键和唯一键。对于 PostgreSQL，直接为每个分区创建主键或唯一键。因此，迁移到 PostgreSQL 时，必须从父表中删除 PRIMARY 或 UNIQUE KEY 约束。生成的键名称采用格式 `_`。
+ SQL Server 允许创建进出分区表的外键约束。PostgreSQL 不支持引用分区表的外键。此外，PostgreSQL 不支持从一个分区表到另一个表的外键引用。
+ SQL Server 允许为分区表创建索引。对于 PostgreSQL，应直接为每个分区创建一个索引。因此，迁移到 PostgreSQL 时，索引必须从其父表中删除。生成的索引名称采用格式 `_`。
+ PostgreSQL 不支持分区索引。
## 迁移注意事项
将 SQL Server 架构迁移到 PostgreSQL 时要考虑的一些事项：
+ 在 PostgreSQL 中，架构中所有对象 (包括索引) 的名称必须是唯一的。索引名称在基表的架构中必须是唯一的。在 SQL Server 中，索引名称可与其他表的相同。
为了确保索引名称的唯一性，如果您的索引名称不是唯一的，则 AWS SCT 可以选择生成唯一的索引名称。为此，请选择项目属性中的 **Generate unique index names (生成唯一索引名称)**。默认情况下，此选项处于启用状态。如果此选项处于启用状态，将使用格式 IX\$1table\$1name\$1index\$1name 创建唯一索引名称。如果此选项处于禁用状态，则不会更改索引名称。
+ 一个 GOTO 语句和一个标签可用于更改语句的运行顺序。将跳过接在 GOTO 语句后的任何 Transact-SQL 语句并且处理将在标签处继续。GOTO 语句和标签可在过程、批处理或语句块中的任意位置使用。GOTO 语句也可以嵌套。
PostgreSQL 不使用 GOTO 语句。当 AWS SCT 转换包含 GOTO 语句的代码时，它会将该语句转换为使用 BEGIN... END 或 LOOP... END LOOP 语句。您可以在下表中找到如何 AWS SCT 转换 GOTO 语句的示例。
**SQL Server GOTO 语句和已转换的 PostgreSQL 语句**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL 不支持合并语句。 AWS SCT 通过以下方式模拟 MERGE 语句的行为：
+ 通过 INSERT ON CONFLICT 结构。
+ 通过使用 UPDATE FROM DML 语句，例如没有 WHEN NOT MATCHED 子句的 MERGE。
+ 通过使用 CURSOR（如带有 DELETE 子句的 MERGE）或复杂的 MERGE ON 条件语句。
+ AWS SCT 当目标为 Amazon RDS 时，可以将数据库触发器添加到对象树中。
+ AWS SCT 当目标为 Amazon RDS 时，可以在对象树中添加服务器级触发器。
+ SQL Server 会自动创建和管理 `deleted` 和 `inserted` 表。您可以使用这些临时的、驻留在内存中的表来测试某些数据修改的效果以及为 DML 触发器操作设置条件。 AWS SCT 可以在 DML 触发器语句中转换这些表的用法。
+ AWS SCT 当目标为 Amazon RDS 时，可以将链接服务器添加到对象树中。
+ 在从 Microsoft SQL Server 迁移到 PostgreSQL 时，内置的 SUSER\$1SNAME 函数进行如下转换：
+ SUSER\$1SNAME – 返回与安全标识号 (SID) 关联的登录名。
+ SUSER\$1SNAME() – 不受支持。
+ SUSER\$1SNAME() CURRENT\$1USER – 返回当前执行上下文的用户名。
+ SUSER\$1SNAME(NULL) – 返回 NULL。
+ 支持转换表值函数。表值函数返回一个表，并且可在查询中代替表。
+ PATINDEX 在所有有效的文本和字符数据类型上返回指定表达式中模式的第一个匹配项的起始位置。如果找不到该模式，则返回零。从 SQL Server 转换为适用于 PostgreSQL 的亚马逊 RDS 时 AWS SCT ，将使用 PATINDEX 的应用程序代码替换为 aws\$1sqlserver\$1ext.patindex (,)。
+ 在 SQL Server 中，用户定义的表类型是表示表结构的定义的类型。可以使用用户定义的表类型来声明存储过程或函数的表值参数。也可以使用用户定义的表类型来声明要在批处理中或存储过程或函数主体中使用的表变量。 AWS SCT 通过创建临时表在 PostgreSQL 中模拟了这种类型。
从 SQL Server 转换为 PostgreSQL 时 AWS SCT ，会将 SQL Server 系统对象转换为 PostgreSQL 中可识别的对象。下表显示了如何转换系统对象。
| MS SQL Server 使用案例 | PostgreSQL 替代项 |
| --- | --- |
| SYS.SCHEMAS | AWS\$1SQLSERVER\$1EXT.SYS\$1SCHEMAS |
| SYS.TABLES | AWS\$1SQLSERVER\$1EXT.SYS\$1TABLES |
| SYS.VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1Views |
| SYS.ALL\$1VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1VIEWS |
| SYS.TYPES | AWS\$1SQLSERVER\$1EXT.SYS\$1TYPE |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1COLUMN |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1COLUMNS |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1K |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSFOREIGNK |
| SYS.FOREIGN\$1KEY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEY\$1CO |
| SYS.KEY\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.SYS\$1KEY\$1KEY\$1 |
| SYS.IDENTITY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1IDTITY\$1COLUMNS |
| SYS.PROCEDURES | AWS\$1SQLSERVER\$1EXT.SYS\$1程序 |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1indexes |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXS |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJEC |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1OBJECT |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJECTS |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULES |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1数据库 |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SC |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1扩展信息\$1架构\$1视图 |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1 |
| INFORMATION\$1SCHEMA.COLUMNS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1 |
| INFORMATION\$1SCHEMA.CHECK\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CHECK |
| INFORMATION\$1SCHEMA.REFERENTIAL\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1referencial\$1 |
| INFORMATION\$1SCHEMA.TABLE\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLE\$1 |
| INFORMATION\$1SCHEMA.KEY\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION \$1SCHEMA\$1KEY\$1COLUMN\$1 |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1TABLE\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1TABLE\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.ROUTINES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1例程 |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSPROCESS |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYSTEM\$1OBJECTS |
# 在 PostgreSQL 中使用 AWS SCT 扩展包模拟 SQL Server 代理
SQL Server Agent 是运行 SQL Server 作业的 Microsoft Windows 服务。SQL Server Agent 可以根据计划、为响应特定事件或者按需运行作业。有关 SQL Server Agent 的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15)。
PostgreSQL 没有 SQL Server Agent 的等效服务。要模拟 SQL Server 代理功能，请 AWS SCT 创建一个扩展包。此扩展包使用 AWS Lambda 和 Amazon CloudWatch。 AWS Lambda 实现用于管理计划和运行作业的接口。亚马逊 CloudWatch 维护计划规则。
AWS Lambda 而且 Amazon CloudWatch 使用 JSON 参数进行交互。此 JSON 参数具有以下结构。
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
在前面的示例中，*`mode`* 是任务的类型，`list of parameters` 是一组取决于任务类型的参数。此外，`procedure name` 是任务完成后运行的过程的名称。
AWS SCT 使用一个 Lambda 函数来控制和运行作业。该 CloudWatch 规则开始运行作业，并提供启动作业所需的必要信息。当 CloudWatch 规则触发时，它会使用规则中的参数启动 Lambda 函数。
要创建调用过程的简单作业，请使用以下格式。
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
要创建多个步骤作业，请使用以下格式。
```
{
"mode": "run_job",
"parameters": {
"job_name": "Job1",
"enabled": "true",
"start_step_id": 1,
"notify_level_email": [0|1|2|3],
"notify_email": email,
"delete_level": [0|1|2|3],
"job_callback": "ProcCallBackJob(job_name, code, message)",
"step_callback": "ProcCallBackStep(job_name, step_id, code, message)"
},
"steps": [
{
"id":1,
"cmd": "ProcStep1",
"cmdexec_success_code": 0,
"on_success_action": [|2|3|4],
"on_success_step_id": 1,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
{
"id":2,
"cmd": "ProcStep2",
"cmdexec_success_code": 0,
"on_success_action": [1|2|3|4],
"on_success_step_id": 0,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
...
]
}
```
为了模拟 PostgreSQL 中的 SQL Server 代理行为， AWS SCT 扩展包还创建了以下表格和过程。
## 在 PostgreSQL 中模拟 SQL Server Agent 的表
为了模拟 SQL Server Agent，扩展包使用以下表：
**sysjobs**
存储有关作业的信息。
**sysjobsteps**
存储有关作业步骤的信息。
**sysschedules**
存储有关作业计划的信息。
**sysjobschedules**
存储各个作业的计划信息。
**sysjobhistory**
存储有关计划作业运行的信息。
## 在 PostgreSQL 中模拟 SQL Server Agent 的过程
要模拟 SQL Server Agent，扩展包使用以下过程：
**sp\$1add\$1job**
添加新作业。
**sp\$1add\$1jobstep**
向作业添加步骤。
**sp\$1add\$1schedule**
在 Amazon 中创建新的计划规则 CloudWatch。您可以将此计划用于任意数量的作业。
**sp\$1attach\$1schedule**
设置所选作业的计划。
**sp\$1add\$1jobschedule**
在 Amazon CloudWatch 中为任务创建计划规则并为该规则设定目标。
**sp\$1update\$1job**
更新先前创建的作业的属性。
**sp\$1update\$1jobstep**
更新作业中步骤的属性。
**sp\$1update\$1schedule**
更新 Amazon 中计划规则的属性 CloudWatch。
**sp\$1update\$1jobschedule**
更新指定作业计划的属性。
**sp\$1delete\$1job**
删除作业。
**sp\$1delete\$1jobstep**
从作业中删除一个作业步骤。
**sp\$1delete\$1schedule**
删除计划。
**sp\$1delete\$1jobschedule**
从 Amazon 中删除指定任务的计划规则 CloudWatch。
**sp\$1detach\$1schedule**
移除计划和作业之间的关联。
**get\$1jobs、update\$1job**
与之交互的内部程序 AWS Elastic Beanstalk。
**sp\$1verify\$1job\$1date、sp\$1verify\$1job\$1time、sp\$1verify\$1job、sp\$1verify\$1jobstep、sp\$1verify\$1schedule、sp\$1verify\$1job\$1identifiers、sp\$1verify\$1schedule\$1identifiers**
检查设置的内部过程。
## 在 PostgreSQL 中模拟 SQL Server Agent 的过程的语法
扩展包中的 `aws_sqlserver_ext.sp_add_job` 过程模拟 `msdb.dbo.sp_add_job` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-job-transact-sql?view=sql-server-ver15)。
```
par_job_name varchar,
par_enabled smallint = 1,
par_description varchar = NULL::character varying,
par_start_step_id integer = 1,
par_category_name varchar = NULL::character varying,
par_category_id integer = NULL::integer,
par_owner_login_name varchar = NULL::character varying,
par_notify_level_eventlog integer = 2,
par_notify_level_email integer = 0,
par_notify_level_netsend integer = 0,
par_notify_level_page integer = 0,
par_notify_email_operator_name varchar = NULL::character varying,
par_notify_netsend_operator_name varchar = NULL::character varying,
par_notify_page_operator_name varchar = NULL::character varying,
par_delete_level integer = 0,
inout par_job_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_add_jobstep` 过程模拟 `msdb.dbo.sp_add_jobstep` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobstep-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
par_step_name varchar = NULL::character varying,
par_subsystem varchar = 'TSQL'::bpchar,
par_command text = NULL::text,
par_additional_parameters text = NULL::text,
par_cmdexec_success_code integer = 0,
par_on_success_action smallint = 1,
par_on_success_step_id integer = 0,
par_on_fail_action smallint = 2,
par_on_fail_step_id integer = 0,
par_server varchar = NULL::character varying,
par_database_name varchar = NULL::character varying,
par_database_user_name varchar = NULL::character varying,
par_retry_attempts integer = 0,
par_retry_interval integer = 0,
par_os_run_priority integer = 0,
par_output_file_name varchar = NULL::character varying,
par_flags integer = 0,
par_proxy_id integer = NULL::integer,
par_proxy_name varchar = NULL::character varying,
inout par_step_uid char = NULL::bpchar,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_add_schedule` 过程模拟 `msdb.dbo.sp_add_schedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-schedule-transact-sql?view=sql-server-ver15)。
```
par_schedule_name varchar,
par_enabled smallint = 1,
par_freq_type integer = 0,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
par_owner_login_name varchar = NULL::character varying,
*inout par_schedule_uid char = NULL::bpchar,*
inout par_schedule_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_attach_schedule` 过程模拟 `msdb.dbo.sp_attach_schedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-attach-schedule-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_automatic_post smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_add_jobschedule` 过程模拟 `msdb.dbo.sp_add_jobschedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobschedule-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_enabled smallint = 1,
par_freq_type integer = 1,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
inout par_schedule_id integer = NULL::integer,
par_automatic_post smallint = 1,
inout par_schedule_uid char = NULL::bpchar,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_delete_job` 过程模拟 `msdb.dbo.sp_delete_job` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-job-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_originating_server varchar = NULL::character varying,
par_delete_history smallint = 1,
par_delete_unused_schedule smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_delete_jobstep` 过程模拟 `msdb.dbo.sp_delete_jobstep` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobsteplog-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_delete_jobschedule` 过程模拟 `msdb.dbo.sp_delete_jobschedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobschedule-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_keep_schedule integer = 0,
par_automatic_post smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_delete_schedule` 过程模拟 `msdb.dbo.sp_delete_schedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-schedule-transact-sql?view=sql-server-ver15)。
```
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_force_delete smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_detach_schedule` 过程模拟 `msdb.dbo.sp_detach_schedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-detach-schedule-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_delete_unused_schedule smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_update_job` 过程模拟 `msdb.dbo.sp_update_job` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-job-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_description varchar = NULL::character varying
par_start_step_id integer = NULL::integer
par_category_name varchar = NULL::character varying
par_owner_login_name varchar = NULL::character varying
par_notify_level_eventlog integer = NULL::integer
par_notify_level_email integer = NULL::integer
par_notify_level_netsend integer = NULL::integer
par_notify_level_page integer = NULL::integer
par_notify_email_operator_name varchar = NULL::character varying
par_notify_netsend_operator_name varchar = NULL::character varying
par_notify_page_operator_name varchar = NULL::character varying
par_delete_level integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_update_jobschedule` 过程模拟 `msdb.dbo.sp_update_jobschedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobschedule-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_update_jobstep` 过程模拟 `msdb.dbo.sp_update_jobstep` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobstep-transact-sql?view=sql-server-ver15)。
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_step_id integer = NULL::integer
par_step_name varchar = NULL::character varying
par_subsystem varchar = NULL::character varying
par_command text = NULL::text
par_additional_parameters text = NULL::text
par_cmdexec_success_code integer = NULL::integer
par_on_success_action smallint = NULL::smallint
par_on_success_step_id integer = NULL::integer
par_on_fail_action smallint = NULL::smallint
par_on_fail_step_id integer = NULL::integer
par_server varchar = NULL::character varying
par_database_name varchar = NULL::character varying
par_database_user_name varchar = NULL::character varying
par_retry_attempts integer = NULL::integer
par_retry_interval integer = NULL::integer
par_os_run_priority integer = NULL::integer
par_output_file_name varchar = NULL::character varying
par_flags integer = NULL::integer
par_proxy_id integer = NULL::integer
par_proxy_name varchar = NULL::character varying
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sp_update_schedule` 过程模拟 `msdb.dbo.sp_update_schedule` 过程。有关源 SQL Server Agent 过程的详细信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-schedule-transact-sql?view=sql-server-ver15)。
```
par_schedule_id integer = NULL::integer
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_owner_login_name varchar = NULL::character varying
par_automatic_post smallint = 1
out returncode integer
```
## 使用在 PostgreSQL 中模拟 SQL Server Agent 的过程的示例
要添加新作业，请使用如下所示的 `aws_sqlserver_ext.sp_add_job` 过程。
```
SELECT * FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_job',
par_enabled := 1::smallint,
par_start_step_id := 1::integer,
par_category_name := '[Uncategorized (Local)]',
par_owner_login_name := 'sa');
```
要添加新的作业步骤，请使用如下所示的 `aws_sqlserver_ext.sp_add_jobstep` 过程。
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_job',
par_step_id := 1::smallint,
par_step_name := 'test_job_step1',
par_subsystem := 'TSQL',
par_command := 'EXECUTE [dbo].[PROC_TEST_JOB_STEP1];',
par_server := NULL,
par_database_name := 'GOLD_TEST_SS');
```
要添加简单的计划，请使用如下所示的 `aws_sqlserver_ext.sp_add_schedule` 过程。
```
SELECT * FROM aws_sqlserver_ext.sp_add_schedule(
par_schedule_name := 'RunOnce',
par_freq_type := 1,
par_active_start_time := 233000);
```
要为作业设置计划，请使用如下所示的 `aws_sqlserver_ext.sp_attach_schedule` 过程。
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
要为作业创建计划，请使用如下所示的 `aws_sqlserver_ext.sp_add_jobschedule` 过程。
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_job2',
par_name := 'test_schedule2',
par_enabled := 1::smallint,
par_freq_type := 4,
par_freq_interval := 1,
par_freq_subday_type := 4,
par_freq_subday_interval := 1,
par_freq_relative_interval := 0,
par_freq_recurrence_factor := 0,
par_active_start_date := 20100801,
par_active_end_date := 99991231,
par_active_start_time := 0,
par_active_end_time := 0);
```
## 在 PostgreSQL 中模拟 SQL Server Agent 的使用案例示例
如果您的源数据库代码使用 SQL Server 代理来运行作业，则可以使用 SQL Server 到 PostgreSQL 扩展包 AWS SCT 将此代码转换为 PostgreSQL。扩展包使用 AWS Lambda 函数来模拟 SQL Server 代理的行为。
您可以创建新 AWS Lambda 函数或注册现有函数。
**创建新 AWS Lambda 函数**
1. 在目标数据库树中 AWS SCT，打开上下文（右键单击）菜单，选择 “**应用扩展包**”，然后选择 P **ostgreSQL**。
扩展包向导随即出现。
1. 在 **SQL Server Agent 模拟服务**选项卡上，执行以下操作：
+ 选择**创建 AWS Lambda 函数**。
+ 在**数据库登录名**中，输入目标数据库用户名。
+ 在**数据库密码**中，输入您在上一步中输入的用户名的密码。
+ 对于 **Python 库文件夹**，请输入 Python 库文件夹的路径。
+ 选择 “**创建 AWS Lambda 函数**”，然后选择 “**下一步**”。
**注册之前部署的 AWS Lambda 函数**
+ 在目标数据库上运行以下脚本。
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
在上述示例中，*`ARN`* 是已部署 AWS Lambda 函数的 Amazon 资源名称（ARN）。
以下示例创建了一个由一个步骤组成的简单任务。此任务每五分钟运行一次先前创建的 `job_example` 函数。此函数将记录插入 `job_example_table` 表中。
**创建这个简单的任务**
1. 使用 `aws_sqlserver_ext.sp_add_job` 函数创建作业，如下所示。
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. 使用 `aws_sqlserver_ext.sp_add_jobstep` 函数创建任务步骤，如下所示。
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_simple_job',
par_step_name := 'test_simple_job_step1',
par_command := 'PERFORM job_simple_example;');
```
作业步骤指定函数的用途。
1. 使用 `aws_sqlserver_ext.sp_add_jobschedule` 函数为作业创建计划程序，如下所示。
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_simple_job',
par_name := 'test_schedule',
par_freq_type := 4, /* Daily */
par_freq_interval := 1, /* frequency_interval is unused */
par_freq_subday_type := 4, /* Minutes */
par_freq_subday_interval := 5 /* 5 minutes */);
```
作业步骤指定函数的用途。
要删除此作业，请使用如下所示的 `aws_sqlserver_ext.sp_delete_job` 函数。
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# 在 PostgreSQL 中使用 AWS SCT 扩展包模拟 SQL Server 数据库邮件
您可以使用 SQL Server 数据库邮件将从 SQL Server 数据库引擎或 Azure SQL 托管实例向用户发送电子邮件。这些电子邮件消息可以包含查询结果，也可以包含来自网络上任何资源的文件。有关 SQL Server 数据库邮件的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15)。
PostgreSQL 没有与 SQL Server 数据库邮件等效的内容。要模拟 SQL Server 数据库邮件功能， AWS SCT 会创建一个扩展包。此扩展包使用 AWS Lambda 亚马逊简单电子邮件服务 (Amazon SES) Service。 AWS Lambda 为用户提供了一个与 Amazon SES 电子邮件发送服务进行交互的接口。要设置此交互，请添加 Lambda 函数的 Amazon 资源名称（ARN）。
对于新的电子邮件账户，请使用以下命令。
```
do
$$
begin
PERFORM sysmail_add_account_sp (
par_account_name :='your_account_name',
par_email_address := 'your_account_email',
par_display_name := 'your_account_display_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
要将 Lambda 函数的 ARN 添加到现有电子邮件账户，请使用以下命令。
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
在上述示例中，*`ARN`* 是 Lambda 函数的 ARN。
为了在 PostgreSQL 中模拟 SQL Server 数据库邮件行为， AWS SCT 扩展包使用了以下表、视图和过程。
## 在 PostgreSQL 中模拟 SQL Server 数据库邮件的表
为了模拟 SQL Server 数据库邮件，扩展包使用以下表：
**sysmail\$1account**
存储有关电子邮件账户的信息。
**sysmail\$1profile**
存储有关用户配置文件的信息。
**sysmail\$1server**
存储有关电子邮件服务器的信息。
**sysmail\$1mailitems**
存储电子邮件消息列表。
**sysmail\$1attachments**
每个电子邮件附件包含一行。
**sysmail\$1log**
存储有关发送电子邮件消息的服务信息。
**sysmail\$1profileaccount**
存储有关用户配置文件和电子邮件账户的信息。
## 在 PostgreSQL 中模拟 SQL Server 数据库邮件的视图
要模拟 SQL Server 数据库邮件，请在 PostgreSQL 数据库中 AWS SCT 创建以下视图以确保兼容性。扩展包不使用这些视图，但转换后的代码可以查询它们。
**sysmail\$1allitems**
包括所有电子邮件的列表。
**sysmail\$1faileditems**
包括无法发送的电子邮件列表。
**sysmail\$1sentitems**
包括已发送电子邮件的列表。
**sysmail\$1unsentitems**
包括尚未发送的电子邮件列表。
**sysmail\$1mailattachments**
包括附件列表。
## 在 PostgreSQL 中模拟 SQL Server 数据库邮件的过程
要模拟 SQL Server 数据库邮件，扩展包使用以下过程：
**sp\$1send\$1dbmail**
向指定的收件人发送电子邮件。
**sysmail\$1add\$1profile\$1sp**
创建新的用户配置文件
**sysmail\$1add\$1account\$1sp**
创建用于存储简单邮件传输协议 (SMTP) 凭证等信息的新电子邮件账户。
**sysmail\$1add\$1profileaccount\$1sp**
将电子邮件账户添加到指定的用户配置文件中。
**sysmail\$1update\$1profile\$1sp**
更改用户配置文件的属性，例如描述、名称等。
**sysmail\$1update\$1account\$1sp**
更改现有电子邮件账户中的信息。
**sysmail\$1update\$1profileaccount\$1sp**
更新指定用户配置文件中的电子邮件账户信息。
**sysmail\$1delete\$1profileaccount\$1sp**
从指定的用户配置文件中删除电子邮件账户。
**sysmail\$1delete\$1account\$1sp**
删除电子邮件账户。
**sysmail\$1delete\$1profile\$1sp**
删除用户配置文件
**sysmail\$1delete\$1mailitems\$1sp**
从内部表格中删除电子邮件。
**sysmail\$1help\$1profile\$1sp**
显示有关用户配置文件的信息。
**sysmail\$1help\$1account\$1sp**
显示有关电子邮件账户的信息。
**sysmail\$1help\$1profileaccount\$1sp**
显示有关与用户配置文件关联的电子邮件账户的信息。
**sysmail\$1dbmail\$1json**
为 AWS Lambda 函数生成 JSON 请求的内部过程。
**sysmail\$1verify\$1profile\$1sp、sysmail\$1verify\$1account\$1sp、sysmail\$1verify\$1addressparams\$1sp**
检查设置的内部过程。
**sp\$1get\$1dbmail、sp\$1set\$1dbmail、sysmail\$1dbmail\$1xml**
已弃用的内部过程。
## 在 PostgreSQL 中模拟 SQL Server 数据库邮件的过程的语法
扩展包中的 `aws_sqlserver_ext.sp_send_dbmail` 过程模拟 `msdb.dbo.sp_send_dbmail` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql?view=sql-server-ver15)。
```
par_profile_name varchar = NULL::character varying,
par_recipients text = NULL::text,
par_copy_recipients text = NULL::text,
par_blind_copy_recipients text = NULL::text,
par_subject varchar = NULL::character varying,
par_body text = NULL::text,
par_body_format varchar = NULL::character varying,
par_importance varchar = 'NORMAL'::character varying,
par_sensitivity varchar = 'NORMAL'::character varying,
par_file_attachments text = NULL::text,
par_query text = NULL::text,
par_execute_query_database varchar = NULL::character varying,
par_attach_query_result_as_file smallint = 0,
par_query_attachment_filename varchar = NULL::character varying,
par_query_result_header smallint = 1,
par_query_result_width integer = 256,
par_query_result_separator VARCHAR = ' '::character varying,
par_exclude_query_output smallint = 0,
par_append_query_error smallint = 0,
par_query_no_truncate smallint = 0,
par_query_result_no_padding smallint = 0,
out par_mailitem_id integer,
par_from_address text = NULL::text,
par_reply_to text = NULL::text,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_delete_mailitems_sp` 过程模拟 `msdb.dbo.sysmail_delete_mailitems_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-mailitems-sp-transact-sql?view=sql-server-ver15)。
```
par_sent_before timestamp = NULL::timestamp without time zone,
par_sent_status varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_add_profile_sp` 过程模拟 `msdb.dbo.sysmail_add_profile_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_name varchar,
par_description varchar = NULL::character varying,
out par_profile_id integer,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_add_account_sp` 过程模拟 `msdb.dbo.sysmail_add_account_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql?view=sql-server-ver15)。
```
par_account_name varchar
par_email_address varchar
par_display_name varchar = NULL::character varying
par_replyto_address varchar = NULL::character varying
par_description varchar = NULL::character varying
par_mailserver_name varchar = NULL::character varying
par_mailserver_type varchar = 'SMTP'::bpchar
par_port integer = 25
par_username varchar = NULL::character varying
par_password varchar = NULL::character varying
par_use_default_credentials smallint = 0
par_enable_ssl smallint = 0
out par_account_id integer
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_add_profileaccount_sp` 过程模拟 `msdb.dbo.sysmail_add_profileaccount_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_help_profile_sp` 过程模拟 `msdb.dbo.sysmail_help_profile_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profile-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_update_profile_sp` 过程模拟 `msdb.dbo.sysmail_update_profile_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profile-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_description varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_delete_profile_sp` 过程模拟 `msdb.dbo.sysmail_delete_profile_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profile-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_force_delete smallint = 1,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_help_account_sp` 过程模拟 `msdb.dbo.sysmail_help_account_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-account-sp-transact-sql?view=sql-server-ver15)。
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_update_account_sp` 过程模拟 `msdb.dbo.sysmail_update_account_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-account-sp-transact-sql?view=sql-server-ver15)。
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_email_address varchar = NULL::character varying,
par_display_name varchar = NULL::character varying,
par_replyto_address varchar = NULL::character varying,
par_description varchar = NULL::character varying,
par_mailserver_name varchar = NULL::character varying,
par_mailserver_type varchar = NULL::character varying,
par_port integer = NULL::integer,
par_username varchar = NULL::character varying,
par_password varchar = NULL::character varying,
par_use_default_credentials smallint = NULL::smallint,
par_enable_ssl smallint = NULL::smallint,
par_timeout integer = NULL::integer,
par_no_credential_change smallint = NULL::smallint,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_delete_account_sp` 过程模拟 `msdb.dbo.sysmail_delete_account_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-account-sp-transact-sql?view=sql-server-ver15)。
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_help_profileaccount_sp` 过程模拟 `msdb.dbo.sysmail_help_profileaccount_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profileaccount-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_update_profileaccount_sp` 过程模拟 `msdb.dbo.sysmail_update_profileaccount_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profileaccount-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
扩展包中的 `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` 过程模拟 `msdb.dbo.sysmail_delete_profileaccount_sp` 过程。有关源 SQL Server 数据库邮件过程的更多信息，请参阅 [Microsoft 技术文档](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profileaccount-sp-transact-sql?view=sql-server-ver15)。
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
## 使用在 PostgreSQL 中模拟 SQL Server 数据库邮件的过程的示例
要发送电子邮件，请使用如下所示的 `aws_sqlserver_ext.sp_send_dbmail` 过程。
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
以下示例演示如何通过查询结果发送电子邮件。
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Account with id = 1',
par_query := 'SELECT COUNT(*)FROM Account WHERE id = 1'
);
```
以下代码示例展示如何通过 HTML 代码发送电子邮件。
```
DECLARE var_tableHTML TEXT;
SET var_tableHTML := CONCAT(
'Work Order Report
',
'',
'| Work Order ID | Product ID | ',
'Name | Order Qty | Due Date | ',
'Expected Revenue |
|---|
',
'
'
);
PERFORM sp_send_dbmail (
par_recipients := 'hello@rusgl.info',
par_subject := 'Work Order List',
par_body := var_tableHTML,
par_body_format := 'HTML'
);
```
要删除电子邮件，请使用如下所示的 `aws_sqlserver_ext.sysmail_delete_mailitems_sp` 过程。
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
下面的示例说明如何删除最旧的电子邮件。
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
以下示例将说明如何删除所有无法发送的电子邮件。
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
要创建新的用户配置文件，请使用如下所示的 `aws_sqlserver_ext.sysmail_add_profile_sp` 过程。
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
以下示例说明如何创建新的配置文件并将唯一配置文件标识符保存在变量中。
```
DECLARE var_profileId INT;
SELECT par_profile_id
FROM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := ' Profile used for administrative mail.')
INTO var_profileId;
SELECT var_profileId;
```
要创建新的电子邮件账户，请使用如下所示的 `aws_sqlserver_ext.sysmail_add_account_sp` 过程。
```
PERFORM sysmail_add_account_sp (
par_account_name :='Audit Account',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_description := 'Account for administrative e-mail.',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'arn:aws:lambda:us-west-2:555555555555:function:pg_v3'
);
```
要将电子邮件账户添加到用户配置文件中，请按以下 `aws_sqlserver_ext.sysmail_add_profileaccount_sp` 过程操作。
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## 在 PostgreSQL 中模拟 SQL Server 数据库邮件的使用案例示例
如果您的源数据库代码使用 SQL Server 数据库邮件发送电子邮件，则可以使用 AWS SCT 扩展包将此代码转换为 PostgreSQL。
**从 PostgreSQL 数据库发送一封电子邮件**
1. 创建和配置您的 AWS Lambda 函数。
1. 应用 AWS SCT 扩展包。
1. 使用如下所示的 `sysmail_add_profile_sp` 函数创建用户配置文件。
1. 使用如下所示的 `sysmail_add_account_sp` 函数创建电子邮件账户。
1. 使用如下所示的 `sysmail_add_profileaccount_sp` 函数，将此电子邮件账户添加到用户配置文件中。
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_settings_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sysmail_add_profile_sp(
par_profile_name := 'Administrator',
par_description := 'administrative mail'
);
PERFORM aws_sqlserver_ext.sysmail_add_account_sp(
par_account_name := 'Audit Account',
par_description := 'Account for administrative e-mail.',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'your_ARN'
);
PERFORM aws_sqlserver_ext.sysmail_add_profileaccount_sp(
par_profile_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
END;
$BODY$
LANGUAGE plpgsql;
```
1. 使用如下所示的 `sp_send_dbmail` 函数发送电子邮件。
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_send_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sp_send_dbmail(
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_body := 'The stored procedure finished',
par_subject := 'Automated Success Message'
);
END;
$BODY$
LANGUAGE plpgsql;
```
要查看有关所有用户配置文件的信息，请按以下 `sysmail_help_profile_sp` 过程操作。
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
以下示例显示有关特定用户配置文件的信息。
```
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_name := 'Administrator');
```
要查看有关所有电子邮件账户的信息，请使用如下所示的 `sysmail_help_account_sp` 过程。
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
以下示例显示有关特定电子邮件账户的信息。
```
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_name := 'Audit Account');
```
要查看与用户配置文件关联的所有电子邮件账户的信息，请按以下 `sysmail_help_profileaccount_sp` 过程操作。
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
以下示例按标识符、配置文件名称或账户名筛选记录。
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1, par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_name := 'Administrator');
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_account_name := 'Audit Account');
```
要更改用户配置文件名称或描述，请按以下 `sysmail_update_profile_sp` 过程操作。
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
要更改电子邮件账户设置，请使用如下所示的 `ysmail_update_account_sp` 过程。
```
select from aws_sqlserver_ext.sysmail_update_account_sp (
par_account_name := 'Audit Account',
par_mailserver_name := 'arn:aws:lambda:region:XXXXXXXXXXXX:function:func_test',
par_mailserver_type := 'AWSLAMBDA'
);
```
# 从 SQL Server 迁移到适用于 SQL Server 的 Amazon RDS AWS Schema Conversion Tool
将 SQL Server 架构和代码迁移到 Amazon RDS for SQL Server 时要考虑的一些事项：
+ AWS SCT 可以将 SQL Server 代理转换为在 Amazon RDS for SQL Server 数据库实例上提供计划、警报和作业。转换后，可以将 Amazon RDS for SQL Server 数据库实例与 SQL Server Reporting Services (SSRS)、SQL Server Analysis Services (SSAS) 和 SQL Server Integration Services (SSIS) 结合使用。
+ Amazon RDS 当前不支持 SQL Server Service Broker 或其他需要您运行 CREATE ENDPOINT 命令的 T-SQL 终端节点。
+ Amazon RDS 对链接的服务器具有有限的支持。转换使用链接服务器的 SQL Server 应用程序代码时， AWS SCT 会转换应用程序代码。但是，请确保先查看使用链接服务器的对象的行为，然后再运行转换的代码。
+ 使用“始终打开”。
+ AWS SCT 评估报告提供了转化的服务器指标。这些有关 SQL Server 实例的指标包括：
+ 使用了数据镜像。
+ 配置了 SQL Server 日志传输。
+ 使用了故障转移群集。
+ 配置了数据库邮件。
+ 使用了全文搜索服务。Amazon RDS for SQL Server 具有有限的全文搜索，并且不支持语义搜索。
+ 安装了 Data Quality Service (DQS)。Amazon RDS 不支持 DQS，因此我们建议您在 Amazon EC2 实例上安装 SQL Server。
## 将 RDS for SQL Server 作为目标的权限
要迁移到 RDS for SQL Server，请创建一个数据库用户，然后为每个数据库授予所需的权限。您可以使用以下代码示例：
```
CREATE LOGIN user_name WITH PASSWORD 'your_password';
USE db_name
CREATE USER user_name FOR LOGIN user_name
GRANT VIEW DEFINITION TO user_name
GRANT VIEW DATABASE STATE TO user_name
GRANT CREATE SCHEMA TO user_name;
GRANT CREATE TABLE TO user_name;
GRANT CREATE VIEW TO user_name;
GRANT CREATE TYPE TO user_name;
GRANT CREATE DEFAULT TO user_name;
GRANT CREATE FUNCTION TO user_name;
GRANT CREATE PROCEDURE TO user_name;
GRANT CREATE ASSEMBLY TO user_name;
GRANT CREATE AGGREGATE TO user_name;
GRANT CREATE FULLTEXT CATALOG TO user_name;
GRANT CREATE SYNONYM TO user_name;
GRANT CREATE XML SCHEMA COLLECTION TO user_name;
```
在前面的示例中，*user\$1name*使用您的用户名替换。然后，*db\$1name*替换为目标数据库的名称。最后，*your\$1password*替换为安全密码。
# 的数据仓库来源 AWS Schema Conversion Tool
AWS SCT 可以将以下源数据仓库的架构转换为支持的目标。有关权限、连接以及 AWS SCT 可以转换用于目标数据库或数据仓库的内容的信息，请参阅以下内容中的详细信息。
**Topics**
+ [将 Amazon Redshift 与 AWS Schema Conversion Tool](CHAP_Source.Redshift.md)
+ [将 Azure Synapse 分析与 AWS Schema Conversion Tool](CHAP_Source.AzureSynapse.md)
+ [BigQuery 使用以下方式连接谷歌 AWS Schema Conversion Tool](CHAP_Source.BigQuery.md)
+ [将 Greenplum 数据库与 AWS Schema Conversion Tool](CHAP_Source.Greenplum.md)
+ [通过以下方式连接 Netezza AWS Schema Conversion Tool](CHAP_Source.Netezza.md)
+ [将 Oracle 数据仓库与 AWS SCT](CHAP_Source.OracleDW.md)
+ [使用以下命令连接到 Snowflake 数据仓库 AWS Schema Conversion Tool](CHAP_Source.Snowflake.md)
+ [使用连接到 SQL Server 数据仓库 AWS Schema Conversion Tool](CHAP_Source.SQLServerDW.md)
+ [使用连接到 Teradata 数据仓库 AWS Schema Conversion Tool](CHAP_Source.Teradata.md)
+ [将连接 AWS Schema Conversion Tool 到 Vertica 数据库](CHAP_Source.Vertica.md)
# 将 Amazon Redshift 与 AWS Schema Conversion Tool
您可以使用 AWS SCT 来优化您的亚马逊 Redshift 集群。 AWS SCT 为您提供有关为 Amazon Redshift 集群选择分配和排序密钥的建议。您可以将 Amazon Redshift 优化项目视为一个源和目标指向不同的 Amazon Redshift 集群的 AWS SCT 项目。
## 将 Amazon Redshift 用作源数据库的权限
下面列出了将 Amazon Redshift 用作源所需的权限：
+ 架构上的用法 **
+ 在架构中的所有表上选择 **
+ SELECT ON PG\$1CATALOG.PG\$1STATISTIC
+ SELECT ON SVV\$1TABLE\$1INFO
+ SELECT ON TABLE STV\$1BLOCKLIST
+ SELECT ON TABLE STV\$1TBL\$1PERM
+ SELECT ON SYS\$1SERVERLESS\$1USAGE
+ SELECT ON PG\$1DATABASE\$1INFO
+ SELECT ON PG\$1STATISTIC
在前面的示例中，将**占位符替换为源架构的名称。
有关将 Amazon Redshift 作为目标所需的权限，请参阅 [将 Amazon Redshift 作为目标的权限](CHAP_Converting.DW.md#CHAP_Converting.DW.ConfigureTarget)。
## 连接到作为源的 Amazon Redshift
使用 AWS Schema Conversion Tool按照以下过程连接到 Amazon Redshift 源数据库。
**连接到 Amazon Redshift 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Amazon Redshift**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要输入 Amazon Redshift 源数据库的连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Redshift.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## Amazon Redshift 优化设置
要编辑 Amazon Redshift 优化设置，请在中选择 **“设置”** AWS SCT，然后选择 “**转化**设置”。从上方的列表中选择 **Amazon Redshift**，然后选择 **Amazon Redshift – Amazon Redshift**。 AWS SCT 显示 Amazon Redshift 优化的所有可用设置。
中的 Amazon Redshift 优化设置 AWS SCT 包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使表的数量超过您的 Amazon Redshift 集群可以存储的表数量也是如此。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果您在应用转换后的代码时达到了表的 Amazon Redshift 集群配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 选择迁移策略。
AWS 建议使用不同的集群作为优化项目的源和目标。在 Amazon Redshift 优化过程开始之前，需要创建源 Amazon Redshift 集群的副本。您可以将源数据包含到此副本中，也可以创建一个空集群。
对于**迁移策略**，请选择**迁移到副本**以将源集群中的数据包含在目标集群中。
对于**迁移策略**，请选择**迁移到干净的画面**以查看优化建议。接受这些建议后，请将源数据迁移到目标集群。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择了**使用压缩编码**选项时，才能选择此选项。
+ 使用自动表优化。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅用于自动表格优化，请在左侧窗格中选择**优化策略**。然后选择**使用 Amazon Redshift 自动调整表格**，并在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**偏斜阈值**中，输入列偏斜值的百分比（0–100）。 AWS SCT 从分配键的候选列表中排除偏斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1-100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
# 将 Azure Synapse 分析与 AWS Schema Conversion Tool
你可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Azure Synapse Analytics 转换为 Amazon Redshift。
## 作为源数据库的 Azure Synapse Analytics 的权限
使用 Azure Synapse Analytics 数据仓库作为源需要以下权限：
+ VIEW DEFINITION
+ VIEW DATABASE STATE
对要转换架构的每个数据库应用这种权限。
## 连接到作为源的 Azure Synapse Analytics
通过以下过程使用 AWS Schema Conversion Tool连接到 Azure Synapse Analytics 数据仓库。
**连接到作为源的 Azure Synapse Analytics 数据仓库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Azure Synapse Analytics**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Azure Synapse Analytics 数据仓库的连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.AzureSynapse.html)
1. 选择**测试连接**以验证 AWS SCT 是否可以连接到源数据库。
1. 选择**连接**以连接到源数据库。
## Azure Synapse Analytics 到 Amazon Redshift 的转换设置
**要编辑 Azure Synapse Analytics 到 Amazon Redshift 的转换设置，请在 AWS SCT中**选择 “**设置”，然后选择 “转换设置”。**从上方的列表中选择 **Azure Synapse，然后选择 Azure Synaps** e — A **mazon Redsh** ift。 AWS SCT 显示 Azure Synapse Analytics 到 Amazon Redshift 转换的所有可用设置。
Azure Synapse Analytics 到 Amazon Redshift AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Azure Synapse Analytics 到 Amazon Redshift 转换优化设置
**要将 Azure Synapse Analytics 编辑为 Amazon Redshift 转化优化设置，请在 AWS SCT中**选择 “**设置”，然后选择 “转换设置”。**从上方的列表中选择 **Azure Synapse**，然后选择 **Azure Synapse – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Azure Synapse Analytics 到 Amazon Redshift 转换的转换优化设置。
Azure Synapse Analytics 到 Amazon Redshift AWS SCT 的转化优化设置包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# BigQuery 使用以下方式连接谷歌 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Amazon Redshift 转换为 Amazon Reds BigQuery hift。
## BigQuery 作为来源的权限
要在中使用 BigQuery 数据仓库作为源 AWS SCT，请创建一个服务帐号。在 Google Cloud 中，应用程序使用服务账户进行授权的 API 调用。服务账户与用户账户不同。有关更多信息，请参阅《Google Cloud 身份和访问权限管理》文档中的[服务账号](https://cloud.google.com/iam/docs/service-accounts)。
请确保向您的服务账号授予以下角色：
+ `BigQuery Admin`
+ `Storage Admin`
该`BigQuery Admin`角色提供管理项目内所有资源的权限。 AWS SCT 使用此角色在迁移项目中加载您的 BigQuery 元数据。
`Storage Admin` 角色授予对数据对象和存储桶的完全控制权。你可以在下面找到这个角色`Cloud Storage`。 AWS SCT 使用此角色从中提取您的数据， BigQuery 然后将其加载到 Amazon Redshift 中。
**创建服务账号密钥文件**
1. 登录 Google Cloud 管理控制台，网址为 [https://console.cloud.google.com/](https://console.cloud.google.com/)。
1. 在 [BigQuery API](https://console.cloud.google.com/apis/library/bigquery.googleapis.com) 页面上，选择**启用**。如果您看到 **API 已启用**，请跳过此步骤。
1. 在[服务账号](https://console.cloud.google.com/iam-admin/serviceaccounts)页面上，选择项目，然后选择**创建服务账号**。
1. 在**服务账户详细信息**页面上，在**服务账户名称**中输入描述性值。选择**创建并继续**。将打开**授予此服务账号对项目的访问权限**页面。
1. **在 “选择角色**” 中，选择 **BigQuery**，然后选择 “**BigQuery 管理员**”。
1. 选择**添加其他角色**。在**选择角色**中，选择**云存储**，然后选择**存储管理员**。
1. 选择**继续**，然后选择**完成**。
1. 在[服务账号](https://console.cloud.google.com/iam-admin/serviceaccounts)页面上，选择您创建的服务账号。
1. 选择**密钥**，然后为**添加密钥**选择**创建新密钥**。
1. 选择 **JSON**，然后选择**创建**。选择用于保存私有密钥的文件夹，或者在浏览器中选择用于下载的默认文件夹。
要从数据仓库中提取 BigQuery 数据，请 AWS SCT 使用 Google Cloud Storage 存储桶文件夹。在开始数据迁移之前创建此存储桶。在**创建本地任务**对话框中输入 Google Cloud Storage 存储桶文件夹的路径。有关更多信息，请参阅 [创建、运行和监控 AWS SCT 任务](agents.md#agents.Tasks)。
## BigQuery 作为源连接到
使用以下步骤通过连接到您的源 BigQuery 项目 AWS Schema Conversion Tool。
**连接到 BigQuery 源数据仓库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **BigQuery**，然后选择 “**下一步**”。
此时显示**添加源**对话框。
1. 在 “**连接名称**” 中，输入 BigQuery 项目的名称。 AWS SCT 在左侧面板的树中显示此名称。
1. 在**密钥路径**中，输入服务账号密钥文件的路径。有关创建此文件的更多信息，请参阅 [BigQuery 作为来源的权限](#CHAP_Source.BigQuery.Permissions)。
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源 BigQuery 项目。
1. 选择 **Conn** ect 以连接到您的源 BigQuery 项目。
## BigQuery 用作来源的限制 AWS SCT
BigQuery 用作的来源时，以下限制适用 AWS SCT：
+ AWS SCT 不支持在分析函数中转换子查询。
+ 您不能使用 AWS SCT 来转换 BigQuery `SELECT AS STRUCT`和`SELECT AS VALUE`语句。
+ AWS SCT 不支持以下类型的函数的转换：
+ 近似聚合
+ Bit
+ 调试
+ 联合查询
+ 地理位置
+ 哈希
+ 数学
+ 净值
+ 统计聚合
+ UUID
+ AWS SCT 为字符串函数的转换提供了有限的支持。
+ AWS SCT 不支持`UNNEST`运算符的转换。
+ 无法在 AWS SCT中转换相关的联接操作。
+ AWS SCT 不支持`QUALIFY`、`WINDOW``LIMIT`、和`OFFSET`子句的转换。
+ 不能使用 AWS SCT 来转换递归公用表表达式。
+ AWS SCT 不支持转换子`INSERT`句内带有子查询的语`VALUES`句。
+ AWS SCT 不支持嵌套字段和重复记录的`UPDATE`语句转换。
+ 您不能使用 AWS SCT 来转换`STRUCT`和`ARRAY`数据类型。
## BigQuery 到亚马逊 Redshift 转换设置
要编辑 BigQuery 到 Amazon Redshift 转换设置，请在中选择 **“设置”** AWS SCT，然后选择 “**转换**设置”。从上方的列表中选择**谷歌 BigQuery，然后选择谷歌 BigQuery ** **— Amazon Redshift**。 AWS SCT 显示转换 BigQuery 至 Amazon Redshift 的所有可用设置。
BigQuery 在 Amazon Redshift 转换设置中 AWS SCT 包含以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## BigQuery 到亚马逊 Redshift 转化优化设置
要编辑 BigQuery 到 Amazon Redshift 转化优化设置，请在中选择 **“设置”** AWS SCT，然后选择 “**转化**设置”。从上方的列表中选择**谷歌 BigQuery，然后选择谷歌 BigQuery ** **— Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示转为 BigQuery 亚马逊 Redshift 的转化优化设置。
BigQuery 在 Amazon Redshift 转化优化设置中 AWS SCT 包含以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 将 Greenplum 数据库与 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Greenplum 数据库转换为 Amazon Redshift。
## 将 Greenplum 数据库用作源的权限
下面列出了将 Greenplum 数据库用作源所需的权限：
+ 连接数据库 **
+ 架构上的用法 **
+ 选择开启 *.*
+ 按顺序选择 *.*
在上述示例中，替换以下占位符：
+ 将 *database\$1name* 替换为源数据库的名称。
+ 将 *schema\$1name* 替换为源架构的名称。
+ *table\$1name*替换为源表的名称。
+ *sequence\$1name*替换为序列名称的名称。
## 连接到作为源的 Greenplum 数据库
使用以下步骤通过连接到您的 Greenplum 源数据库。 AWS SCT
**连接到 Greenplum 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **SAP ASE**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Greenplum 源数据库凭证，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Greenplum.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## Greenplum 到 Amazon Redshift 的转换设置
要编辑 Greenplum 到 Amazon Redshift 的转换设置，**请在 AWS SCT中选择** “设置”，然后**选择 “**转换设置”。从上方的列表中选择 Greenp **lum，然后选择 Green** plum **— Amazon Redshift**。 AWS SCT 显示 Greenplum 到 Amazon Redshift 转换的所有可用设置。
中的 Greenplum 到 Amazon Redshift AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Greenplum 到 Amazon Redshift 的转换优化设置
要编辑 Greenplum 到 Amazon Redshift 的转化优化设置，**请在 AWS SCT中选择** “设置”，然后**选择 “**转换设置”。从上方的列表中选择 **Greenplum**，然后选择 **Greenplum – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Greenplum 到 Amazon Redshift 转换的转化优化设置。
Greenplum 到 Amazon Redshift AWS SCT 的转化优化设置包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 通过以下方式连接 Netezza AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Netezza 转换为 Amazon Redshift。
## 将 Netezza 用作源的权限
下面列出了将 Netezza 用作源所需的权限：
+ SELECT ON SYSTEM.DEFINITION\$1SCHEMA.SYSTEM VIEW
+ SELECT ON SYSTEM.DEFINITION\$1SCHEMA.SYSTEM TABLE
+ SELECT ON SYSTEM.DEFINITION\$1SCHEMA.MANAGEMENT TABLE
+ 列在 **
+ 列在 **
+ 在.all ** .table 上列出
+ 在 ** .all.external 表上列出
+ 在 .all ** .view 上列出
+ **.all.materialized 视图上的列表
+ 在.all ** .proceduce 上
+ 列出.all ** .sequence
+ .all ** .function 上列出
+ 在.all ** .aggregate 上
在上述示例中，替换以下占位符：
+ 将 *database\$1name* 替换为源数据库的名称。
+ 将 *schema\$1name* 替换为源架构的名称。
AWS SCT 需要访问以下系统表和视图。您可以授予对这些对象的访问权限，而不必授予对上述列表中的 `system.definition_schema.system view` 和 `system.definition_schema.system tables` 的访问权限。
+ select on system.definition\$1schema.\$1t\$1aggregate
+ select on system.definition\$1schema.\$1t\$1class
+ select on system.definition\$1schema.\$1t\$1constraint
+ select on system.definition\$1schema.\$1t\$1const\$1relattr
+ select on system.definition\$1schema.\$1t\$1database
+ select on system.definition\$1schema.\$1t\$1grpobj\$1priv
+ select on system.definition\$1schema.\$1t\$1grpusr
+ select on system.definition\$1schema.\$1t\$1hist\$1config
+ select on system.definition\$1schema.\$1t\$1object
+ select on system.definition\$1schema.\$1t\$1object\$1classes
+ select on system.definition\$1schema.\$1t\$1proc
+ select on system.definition\$1schema.\$1t\$1type
+ select on system.definition\$1schema.\$1t\$1user
+ select on system.definition\$1schema.\$1t\$1usrobj\$1priv
+ select on system.definition\$1schema.\$1vt\$1sequence
+ select on system.definition\$1schema.\$1v\$1aggregate
+ select on system.definition\$1schema.\$1v\$1constraint\$1depends
+ select on system.definition\$1schema.\$1v\$1database
+ select on system.definition\$1schema.\$1v\$1datatype
+ select on system.definition\$1schema.\$1v\$1dslice
+ select on system.definition\$1schema.\$1v\$1function
+ select on system.definition\$1schema.\$1v\$1group
+ select on system.definition\$1schema.\$1v\$1obj\$1relation
+ select on system.definition\$1schema.\$1v\$1obj\$1relation\$1xdb
+ select on system.definition\$1schema.\$1v\$1procedure
+ select on system.definition\$1schema.\$1v\$1relation\$1column
+ select on system.definition\$1schema.\$1v\$1relation\$1keydata
+ select on system.definition\$1schema.\$1v\$1relobjclasses
+ select on system.definition\$1schema.\$1v\$1schema\$1xdb
+ select on system.definition\$1schema.\$1v\$1sequence
+ select on system.definition\$1schema.\$1v\$1synonym
+ select on system.definition\$1schema.\$1v\$1system\$1info
+ select on system.definition\$1schema.\$1v\$1sys\$1constraint
+ select on system.definition\$1schema.\$1v\$1sys\$1object\$1dslice\$1info
+ select on system.definition\$1schema.\$1v\$1sys\$1user
+ select on system.definition\$1schema.\$1v\$1table
+ select on system.definition\$1schema.\$1v\$1table\$1constraint
+ select on system.definition\$1schema.\$1v\$1table\$1dist\$1map
+ select on system.definition\$1schema.\$1v\$1table\$1organize\$1column
+ select on system.definition\$1schema.\$1v\$1table\$1storage\$1stat
+ select on system.definition\$1schema.\$1v\$1user
+ select on system.definition\$1schema.\$1v\$1view
+ select on system.information\$1schema.\$1v\$1relation\$1column
+ select on system.information\$1schema.\$1v\$1table
+ select on \$1hist\$1column\$1access\$1\$1
## 连接到作为源的 Netezza
使用 AWS Schema Conversion Tool按照以下过程连接到 Netezza 源数据库。
**连接到 Netezza 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Netezza**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Netezza 源数据库的连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Netezza.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## 配置持续的数据复制
转换您的 Netezza 数据库架构并将其应用于 Amazon Redshift 数据库后，您可以使用数据提取代理迁移数据 AWS SCT 。代理会提取数据并将其上载到 Amazon S3 存储桶。然后，您可以使用将数据从亚马逊 S3 复制 AWS SCT 到 Amazon Redshift。
如果源数据库中的数据在迁移过程中发生了变化，则可以使用 AWS SCT 数据提取代理捕获正在进行的更改。然后，您可以在完成初始数据迁移后将这些正在进行的更改复制到目标数据库中。此过程称为持续的数据复制或*更改数据捕获*（CDC）。
**为从 Netezza 迁移到 Amazon Redshift 配置持续的数据复制**
1. 在源数据库中，创建一个历史数据库。您可在 Netezza 命令行界面（CLI）中使用以下代码示例。
```
nzhistcreatedb -d history_database_name -t query -v 1 -u load_user -o histdb_owner -p your_password
```
在前面的示例中，*history\$1database\$1name*替换为历史数据库的名称。接下来，*load\$1user*替换为您定义的用于将历史数据加载到数据库的用户名。然后，*histdb\$1owner*替换为您定义为历史数据库所有者的用户名。请确保您已经创建了此用户并授予了 `CREATE DATABASE` 权限。最后，*your\$1password*替换为安全密码。
1. 配置历史日志记录。为此，请使用以下代码示例。
```
CREATE HISTORY CONFIGURATION history_configuration_name HISTTYPE QUERY
DATABASE history_database_name USER load_user PASSWORD your_password COLLECT PLAN, COLUMN
LOADINTERVAL 1 LOADMINTHRESHOLD 0 LOADMAXTHRESHOLD 0 STORAGELIMIT 25
LOADRETRY 2 VERSION 1;
```
在前面的示例中，将*history\$1configuration\$1name*和*history\$1database\$1name*替换为历史配置和历史数据库的名称。接下来，*load\$1user*替换为您定义的用于将历史数据加载到数据库的用户名。然后，*your\$1password*替换为安全密码。
1. 授予历史数据库中所有表的读取权限。您可以使用以下代码示例授予 `SELECT` 权限。
```
GRANT SELECT ON history_database_name.ALL.TABLE TO your_user;
```
在前面的示例中，*history\$1database\$1name*替换为历史数据库的名称。接下来，*your\$1user*替换为使用您的 Netezza 数据库的最低权限的用户名。您可以在中使用该数据库用户的凭据 AWS SCT。
1. 收集源架构中每个表的统计数据，以获取有关列基数的信息。您可使用以下命令在历史数据库中生成统计数据。
```
GENERATE STATISTICS on "schema_name"."table_name";
```
在前面的示例中，将*schema\$1name*和*table\$1name*替换为数据库架构和表的名称。
1. 通过运行以下查询，确保您已完成先决条件：
```
SELECT COUNT(*) FROM history_database_name.history_schema_name."$hist_column_access_N";
```
在前面的示例中，将*history\$1database\$1name*和*history\$1schema\$1name*替换为历史数据库和架构的名称。接下来，*N*用历史数据库的版本号替换。有关历史数据库版本的更多信息，请参阅 [IBM Netezza 文档](https://www.ibm.com/docs/en/netezza?topic=history-database-versions)。
1. 安装数据提取代理。有关更多信息，请参阅 [安装提取代理](agents.md#agents.Installing)。
确保 `settings.properties` 文件中所有提取器实例的 `{working.folder}` 参数都指向同一个文件夹。在这种情况下，提取器可以协调 CDC 会话并为所有子任务使用单个事务点。
1. 注册您的数据提取代理。有关更多信息，请参阅 [在中注册提取剂 AWS Schema Conversion Tool](agents.md#agents.Using)。
1. 创建 CDC 任务。有关更多信息，请参阅 [创建、运行和监控 AWS SCT 任务](agents.md#agents.Tasks)。
1. 在 AWS SCT中打开您的项目。在左窗格中，选择源表。打开上下文 (右键单击) 菜单，然后选择**创建本地任务**。
1. 对于**任务名称**，请输入数据迁移任务的描述性名称。
1. 对于**迁移模式**，选择**提取、上传和复制**。
1. 选择**启用 CDC**。
1. 选择 **CDC 设置**选项卡并定义 CDC 会话的范围和计划。
1. 选择**测试任务**以验证是否可连接到您的工作文件夹、Amazon S3 存储桶和 Amazon Redshift 数据仓库。
1. 选择**创建**以创建任务。
1. 选择**任务**选项卡，从列表中选择您的任务，然后选择**开始**。
1. 该 AWS SCT 任务在目标数据库上保持事务一致性。数据提取代理按事务 ID 顺序从源复制事务。
如果您停止任何迁移会话或迁移会话失败，则 CDC 处理也会停止。
## Netezza 到 Amazon Redshift 的转换设置
要编辑 Netezza 到 Amazon Redshift 的转换设置，**请在 AWS SCT中选择** “设置”，然后**选择 “**转换设置”。从上方的列表中选择 Nete **zza，然后选择 Netezza** **— Amazon Redshift**。 AWS SCT 显示 Netezza 到 Amazon Redshift 转换的所有可用设置。
中的 Netezza 到 Amazon Redshift AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Netezza 到 Amazon Redshift 的转换优化设置
要编辑 Netezza 到 Amazon Redshift 的转化优化设置，请在 AWS SCT中**选择 “**设置”，然后**选择 “**转化设置”。从上方的列表中选择 **Netezza**，然后选择 **Netezza – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Netezza 到 Amazon Redshift 转换的转化优化设置。
Netezza 到 Amazon Redshift AWS SCT 的转化优化设置包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 将 Oracle 数据仓库与 AWS SCT
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Oracle 数据仓库转换为 Amazon Redshift 或 Amazon Redshift，然后组合 AWS Glue 使用。
## 将 Oracle 数据仓库用作源的权限
下面列出了将 Oracle 数据仓库用作源所需的权限：
+ connect
+ select\$1catalog\$1role
+ select any dictionary
## 连接到作为源的 Oracle 数据仓库
使用 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.OracleDW.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## Oracle 数据仓库到 Amazon Redshift 的转换设置
要编辑 Oracle 数据仓库到 Amazon Redshift 的转换**设置，请选择中的设置** AWS SCT，然后选择**转换**设置。从上方的列表中选择 **Oracle，然后选择 Oracle** **— Amazon Redshift**。 AWS SCT 显示 Oracle 数据仓库到 Amazon Redshift 转换的所有可用设置。
中的 Oracle 数据仓库到 Amazon Redshift 的转换设置 AWS SCT 包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 将数据类型格式化函数（例如 `TO_CHAR`、`TO_DATE` 和 `TO_NUMBER`）与 Amazon Redshift 不支持的日期时间格式元素进行转换。默认情况下， AWS SCT 使用扩展包函数来模拟转换后的代码中这些不支持的格式元素的用法。
与 Amazon Redshift 中的日期时间格式字符串相比，Oracle 中的日期时间格式模型包含更多元素。如果源代码仅包含 Amazon Redshift 支持的日期时间格式元素，则无需在转换后的代码中使用扩展包函数。为避免在转换后的代码中使用扩展包函数，请选择 **Oracle 代码中使用的日期类型格式元素与 Amazon Redshift 中的日期时间格式字符串相似**。在这种情况下，转换后的代码运行更快。
与 Amazon Redshift 中的数字格式字符串相比，Oracle 中的数字格式模型包含更多的元素。如果源代码仅包含 Amazon Redshift 支持的数字格式元素，则无需在转换后的代码中使用扩展包函数。为避免在转换后的代码中使用扩展包函数，请选择 **Oracle 代码中使用的数字格式元素与 Amazon Redshift 中的数字格式字符串相似**。在这种情况下，转换后的代码运行更快。
+ 转换 Oracle `LEAD` 和 `LAG` 分析函数。默认情况下， AWS SCT 会为每个 `LEAD` 和 `LAG` 函数引发一个操作项。
当源代码在这些函数中不使用默认偏移值时， AWS SCT 可以使用 `NVL` 函数模拟这些函数的用法。为此，请选择**使用 NVL 函数模拟 Oracle LEAD 和 LAG 函数的行为**。
+ 要模拟 Amazon Redshift 集群中主键和唯一键的行为，请选择**模拟主键和唯一键的行为**。
Amazon Redshift 不强制使用唯一键和主键，它们仅用于提供信息。如果您在代码中使用这些约束，请确保在转换后的代码中 AWS SCT 模拟它们的行为。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Oracle 数据仓库到 Amazon Redshift 的转换优化设置
要编辑 Oracle Data Warehoushift 到 Amazon Redshift 的转化优化**设置 AWS SCT，请选择中的设置**，然后选择**转换**设置。从上面的列表中选择 **Oracle**，然后选择 **Oracle – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Oracle 数据仓库到 Amazon Redshift 转换的转换优化设置。
中的 Oracle 数据仓库到 Amazon Redshift 的转换优化设置 AWS SCT 包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 使用以下命令连接到 Snowflake 数据仓库 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Snowflake 转换为 Amazon Redshift。
## 将 Snowflake 用作源数据库的权限
您可以使用 `SECURITYADMIN` 角色和 `SECURITYADMIN` 会话上下文创建具有权限的角色并向该角色授予用户名。
以下示例创建了最低权限并将其授予 `min_privs` 用户。
```
create role role_name;
grant role role_name to role sysadmin;
grant usage on database db_name to role role_name;
grant usage on schema db_name.schema_name to role role_name;
grant usage on warehouse datawarehouse_name to role role_name;
grant monitor on database db_name to role role_name;
grant monitor on warehouse datawarehouse_name to role role_name;
grant select on all tables in schema db_name.schema_name to role role_name;
grant select on future tables in schema db_name.schema_name to role role_name;
grant select on all views in schema db_name.schema_name to role role_name;
grant select on future views in schema db_name.schema_name to role role_name;
grant select on all external tables in schema db_name.schema_name to role role_name;
grant select on future external tables in schema db_name.schema_name to role role_name;
grant usage on all sequences in schema db_name.schema_name to role role_name;
grant usage on future sequences in schema db_name.schema_name to role role_name;
grant usage on all functions in schema db_name.schema_name to role role_name;
grant usage on future functions in schema db_name.schema_name to role role_name;
grant usage on all procedures in schema db_name.schema_name to role role_name;
grant usage on future procedures in schema db_name.schema_name to role role_name;
create user min_privs password='real_user_password'
DEFAULT_ROLE = role_name DEFAULT_WAREHOUSE = 'datawarehouse_name';
grant role role_name to user min_privs;
```
在上述示例中，替换以下占位符：
+ 将 *`role_name`* 替换为具有只读权限的角色名称。
+ 将 `db_name` 替换为源数据库的名称。
+ 将 `schema_name` 替换为源架构的名称。
+ 将 *`datawarehousename`* 替换为所需数据仓库的名称。
+ 将 `min_privs` 替换为具有最低权限的用户名。
`DEFAULT_ROLE` 和 `DEFAULT_WAREHOUSE` 参数是密钥敏感的。
## 配置对 Amazon S3 的安全访问权限
Amazon S3 存储桶的安全和访问权限管理策略允许 Snowflake 访问 S3 存储桶、从中读取数据并将数据写入存储桶。您可以使用 Snowflake `STORAGE INTEGRATION` 对象类型配置私有 Amazon S3 存储桶的安全访问权限。Snowflake 存储集成对象将身份验证责任委托给 Snowflake 身份和访问权限管理实体。
有关更多信息，请参阅 Snowflake 文档中的[配置 Snowflake 存储集成以访问 Amazon S3](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html)。
## 连接到作为源的 Snowflake
使用 AWS Schema Conversion Tool按照以下过程连接到源数据库。
**连接到 Snowflake 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Snowflake**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Snowflake 源数据仓库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Snowflake.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## Snowflake 作为源的限制
以下是使用 Snowflake 作为来源时的限制： AWS SCT
+ 对象标识符在对象类型和父对象的上下文中必须是唯一的：
**数据库**
架构标识符在数据库中必须唯一。
**架构**
对象标识符（例如表和视图的标识符）在架构中必须是唯一的。
**表格/视图**
表中的列标识符必须唯一。
+ 大型和 xlarge 集群节点类型的最大表数为 9,900。8xlarge 集群节点类型的最大表数为 100,000。限制包括在查询处理或系统维护期间由用户定义或由 Amazon Redshift 创建的临时表。有关更多信息，请参阅 *Amazon Redshift 集群管理指南*中的 [Amazon Redshift 配额](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
+ 对于存储过程，输入和输出参数的最大数量为 32。
## Snowflake 的源数据类型
接下来，您可以找到使用时支持的 Snowflake 源数据类型 AWS SCT 以及与 Amazon Redshift 目标的默认映射。
| Snowflake 数据类型 | Amazon Redshift 数据类型。 |
| --- | --- |
| NUMBER | NUMERIC(38) |
| NUMBER(p) | 如果 p =< 4，则为 SMALLINT 如果 p => 5 且 =< 9，则为 INTEGER 如果 p => 10 且 =< 18，则为 BIGINT 如果 p => 19 则为 NUMERIC(p) |
| NUMBER(p, 0) | 如果 p =< 4，则为 SMALLINT 如果 p => 5 且 =< 9，则为 INTEGER 如果 p => 10 且 =< 18，则为 BIGINT 如果 p => 19 则为：NUMERIC(p,0) |
| NUMBER(p, s) | 如果 p => 1 且 =< 38，并且如果 s => 1 且 =< 37，那么 NUMERIC (p,s) |
| FLOAT | FLOAT |
| TEXT Unicode 字符最多 16,777,216 字节；每个字符最多 4 个字节。 | VARCHAR(MAX) |
| TEXT(p) Unicode 字符最多 65,535 字节；每个字符最多 4 个字节。 | 如果 p =< 65,535 那么，VARCHAR (p) |
| TEXT(p) Unicode 字符最多 16,777,216 字节；每个字符最多 4 个字节。 | 如果 p => 65535 且 =< 16,777,216 则为 VARCHAR(MAX) |
| BINARY 单字节字符最多 8,388,608 字节；每个字符 1 字节。 | VARCHAR(MAX) |
| BINARY(p) 单字节字符最多 65,535 字节；每个字符 1 字节。 | VARCHAR(p) |
| BINARY(p) 单字节字符最多 8,388,608 字节；每个字符 1 字节。 | VARCHAR(MAX) |
| BOOLEAN | BOOLEAN |
| DATE | DATE |
| TIME 介于 00:00:00 和 23:59:59.999999999 之间的时间值。 | VARCHAR(18) |
| TIME(f) 介于 00:00:00 和 23:59:59.9(f) 之间的时间值。 | VARCHAR(n) – 9 \$1 dt-attr-1 |
| TIMESTAMP\$1NTZ | TIMESTAMP |
| TIMESTAMP\$1TZ | TIMESTAMPTZ |
## Snowflake 到 Amazon Redshift 的转换设置
**要编辑 Snowflake 到 Amazon Redshift 的转换设置，请在**中选择**设置 AWS SCT，然后选择转换设置。**从上方的列表中选择 Snowflake，然后选择 **Snowflake** — **Amazon Redshif** t。 AWS SCT 显示 Snowflake 到 Amazon Redshift 转换的所有可用设置。
中的 Snowflake 到 Amazon Redshift AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Snowflake 到 Amazon Redshift 的转换优化设置
**要编辑 Snowflake 到 Amazon Redshift 的转化优化设置，请在 AWS SCT中**选择 “**设置”，然后选择 “转化设置”。**从上方的列表中选择 **Snowflake**，然后选择 **Snowflake – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Snowflake 到 Amazon Redshift 转换的转化优化设置。
中的 Snowflake 到 Amazon Redshift AWS SCT 的转化优化设置包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 使用连接到 SQL Server 数据仓库 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从微软 SQL Server DW 转换为 Amazon Redshift 或 Amazon Redshift，然后组合 AWS Glue 使用。
## 将 Microsoft SQL Server 数据仓库用作源的权限
下面列出了将 Microsoft SQL Server 数据仓库用作源所需的权限：
+ VIEW DEFINITION
+ VIEW DATABASE STATE
+ 在架构上选择:: **
在前面的示例中，将**占位符替换为源 source\$1schema 的名称。
对要转换其架构的每个数据库重复以上授权。
此外，授予以下权限，并在主数据库上运行该授权：
+ VIEW SERVER STATE
## 将 SQL Server 数据仓库作为源的限制
目前不支持将 Microsoft SQL Server 并行数据仓库（PDW）作为源。
## 连接到作为源的 SQL Server 数据仓库
使用 AWS Schema Conversion Tool按照以下过程连接到 SQL Server 数据仓库源数据库。
**连接到 SQL Server 数据仓库源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Microsoft SQL Server**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Microsoft SQL Server 源数据仓库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServerDW.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## SQL Server 数据仓库到 Amazon Redshift 的转换设置
要编辑 SQL Server 数据仓库到 Amazon Redshift 的转换**设置，请选择中的设置** AWS SCT，然后选择**转换**设置。从上方的列表中选择**微软 SQL Server，然后选择微软 SQL** **Server — Amazon Reds** hift。 AWS SCT 显示 SQL Server 数据仓库到 Amazon Redshift 转换的所有可用设置。
中的 SQL Server 数据仓库到 Amazon Redshift 的转换设置 AWS SCT 包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## SQL Server 数据仓库到 Amazon Redshift 的转换优化设置
要编辑 SQL Server 数据仓库到 Amazon Redshift 的转化优化**设置，请选择中的设置** AWS SCT，然后选择**转换**设置。从上方的列表中选择 **Microsoft SQL Server**，然后选择 **Microsoft SQL Server – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 SQL Server 数据仓库到 Amazon Redshift 转换的转换优化设置。
中的 SQL Server 数据仓库到 Amazon Redshift 的转化优化设置 AWS SCT 包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 使用连接到 Teradata 数据仓库 AWS Schema Conversion Tool
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Teradata 转换为 Amazon Redshift 或 Amazon Redshift，然后组合使用。 AWS Glue
## 将 Teradata 用作源的权限
下面列出了将 Teradata 用作源所需的权限：
+ SELECT ON DBC
+ SELECT ON SYSUDTLIB
+ SELECT ON SYSLIB
+ 选择开启 **
+ 在上创建程序 **
在上述示例中，将 ** 占位符替换为源数据库的名称。
AWS SCT 需要具有 CREATE PROCEDURE 权限才能对源数据库中的所有过程执行帮助过程。 AWS SCT 不会使用此权限在源 Teradata 数据库中创建任何新对象。
## 连接到作为源的 Teradata
使用 AWS Schema Conversion Tool按照以下过程连接到 Teradata 源数据库。
**连接到 Teradata 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Teradata**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Teradata 源数据库连接信息，请按照以下说明进行操作：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
### Teradata 源使用 LDAP 身份验证
要为在 Windows 中运行 Microsoft Active Directory 的 Teradata 用户设置轻量目录访问协议 (LDAP) 身份验证，请使用以下过程。
在以下过程中，Active Directory 域为 `test.local.com`。Windows 服务器为 `DC` 并且使用了默认设置进行配置。以下脚本创建 `test_ldap` Active Directory 账户，并且该账户使用 `test_ldap` 密码。
**为在 Windows 中运行 Microsoft Active Directory 的 Teradata 用户设置 LDAP 身份验证**
1. 在 `/opt/teradata/tdat/tdgss/site` 目录中，编辑文件 `TdgssUserConfigFile.xml`。将 LDAP 部分更改为以下内容。
```
AuthorizationSupported="no"
LdapServerName="DC.test.local.com"
LdapServerPort="389"
LdapServerRealm="test.local.com"
LdapSystemFQDN="dc= test, dc= local, dc=com"
LdapBaseFQDN="dc=test, dc=local, dc=com"
```
1. 通过运行如下所示的配置来应用更改。
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. 通过运行以下命令来测试配置。
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
该输出值应该类似于以下内容。
```
LdapGroupBaseFQDN: dc=Test, dc=local, dc=com
LdapUserBaseFQDN: dc=Test, dc=local, dc=com
LdapSystemFQDN: dc= test, dc= local, dc=com
LdapServerName: DC.test.local.com
LdapServerPort: 389
LdapServerRealm: test.local.com
LdapClientUseTls: no
LdapClientTlsReqCert: never
LdapClientMechanism: SASL/DIGEST-MD5
LdapServiceBindRequired: no
LdapClientTlsCRLCheck: none
LdapAllowUnsafeServerConnect: yes
UseLdapConfig: no
AuthorizationSupported: no
FQDN: CN=test, CN=Users, DC=Anthem, DC=local, DC=com
AuthUser: ldap://DC.test.local.com:389/CN=test1,CN=Users,DC=test,DC=local,DC=com
DatabaseName: test
Service: tdsbind
```
1. 使用以下命令重新启动 TPA。
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. 在 Teradata 数据库中创建与 Active Directory 中相同的用户，如下所示。
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
如果您在 Active Directory 中更改 LDAP 用户的用户密码，则应在 LDAP 模式下连接到 Teradata 时指定此新密码。在默认模式下，您仍必须使用 LDAP 用户名和任意密码连接 Teradata。
## 在源 Teradata 数据仓库中配置统计数据收集
要转换您的源 Teradata 数据仓库，请 AWS SCT 使用统计数据来优化转换后的 Amazon Redshift 数据仓库。您可以在 AWS SCT 中收集统计数据或上传统计数据文件。有关更多信息，请参阅 [收集或上传统计数据](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics)。
要确保 AWS SCT 可以从您的数据仓库收集统计数据，请完成以下先决任务。
**从 Teradata 数据仓库收集统计数据**
1. 运行以下查询以重新收集数据仓库中所有表的统计信息。
```
collect summary statistics on table_name;
```
在前面的示例中，*table\$1name*替换为源表的名称。对您转换的每个表重复查询。
1. 运行以下查询以确定用于转换数据仓库的用户的账户字符串。
```
select * from dbc.accountinfo where username ='user_name'
```
1. 使用上一个示例中的账户字符串为特定用户开启查询日志记录。
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
或者，为所有数据库用户开启查询日志记录。
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
收集完数据仓库统计数据后，关闭查询日志记录。为此，您可以使用以下代码示例。
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## 在离线模下从源 Teradata 数据仓库收集统计数据
在 Teradata 数据仓库中配置统计数据收集后，即可在项目中收集统计数据。 AWS SCT 或者，您可以使用 Basic Teradata Query（BTEQ）脚本在离线模式下收集统计信息。然后，您可以将包含收集到的统计数据的文件上传到 AWS SCT 项目。有关更多信息，请参阅 [收集或上传统计数据](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics)。
**在离线模式下从 Teradata 数据仓库收集统计数据**
1. 创建包含以下内容的 `off-line_stats.bteq` 脚本。
```
.OS IF EXIST column-stats-tera.csv del /F column-stats-tera.csv
.OS IF EXIST table-stats-tera.csv del /F table-stats-tera.csv
.OS IF EXIST column-skew-script-tera.csv del /F column-skew-script-tera.csv
.OS IF EXIST column-skew-stats-tera.csv del /F column-skew-stats-tera.csv
.OS IF EXIST query-stats-tera.csv del /F query-stats-tera.csv
.LOGON your_teradata_server/your_login, your_password
.EXPORT REPORT FILE = table-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'"' || OREPLACE(COALESCE(c.DatabaseName, ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(c.TableName, ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(s.reference_count, '0')) || '";' ||
'"' || TRIM(COALESCE(CAST(p.RowCount AS BIGINT), '0')) || '";' ||
'"' || CAST(CAST(w.size_in_mb AS DECIMAL (38,1) FORMAT 'Z9.9') AS VARCHAR(38)) || '";' ||
'"' || TRIM(COALESCE(r.stat_fk_dep_count, '0')) || '";' ||
'"' || CAST(CAST(current_timestamp(0) as timestamp(0) format 'YYYY-MM-DDBHH:MI:SS') as VARCHAR(19)) || '"'
(TITLE '"database_name";"table_name";"reference_count";"row_count";"size_in_mb";"stat_fk_dep_count";"current_ts"')
FROM (select databasename, tablename
from DBC.tablesv
where tablekind IN ('T','O')
and databasename = 'your_database_name'
) c
left join
(select DatabaseName, TableName, max(RowCount) RowCount
from dbc.tableStatsv
group by 1,2)p
on p.databasename = c.databasename
and p.tablename = c.tablename
left join
(SELECT r.ChildDB as DatabaseName,
r.ChildTable as TableName,
COUNT(DISTINCT r.ParentTable) reference_count
FROM DBC.All_RI_ChildrenV r
GROUP BY r.ChildDB, r.ChildTable) s
on s.databasename = c.databasename
and s.tablename = c.tablename
left join
(SELECT r.ParentDB as DatabaseName,
r.ParentTable as TableName,
COUNT(DISTINCT r.ChildTable) stat_fk_dep_count
FROM DBC.All_RI_ParentsV r
GROUP BY r.ParentDB, r.ParentTable) r
on r.databasename = c.databasename
and r.tablename = c.tablename
left join
(select databasename, tablename,
sum(currentperm)/1024/1024 as size_in_mb
from dbc.TableSizeV
group by 1,2) w
on w.databasename = c.databasename
and w.tablename = c.tablename
WHERE COALESCE(r.stat_fk_dep_count,0) + COALESCE(CAST(p.RowCount AS BIGINT),0) + COALESCE(s.reference_count,0) > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
SELECT
'"' || OREPLACE(COALESCE(trim(tv.DatabaseName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.TableName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.columnname), ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
'"' || CAST(current_timestamp AS VARCHAR(19)) || '"' (TITLE '"database_name";"table_name";"column_name";"cardinality";"current_ts"')
FROM dbc.columnsv tv
LEFT JOIN
(
SELECT
c.DatabaseName AS DATABASE_NAME,
c.TABLENAME AS TABLE_NAME,
c.ColumnName AS COLUMN_NAME,
c.UniqueValueCount AS CARD
FROM dbc.tablestatsv c
WHERE c.DatabaseName = 'your_database_name'
AND c.RowCount <> 0
) t2
ON tv.DATABASENAME = t2.DATABASE_NAME
AND tv.TABLENAME = t2.TABLE_NAME
AND tv.COLUMNNAME = t2.COLUMN_NAME
WHERE t2.card > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-script-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'SELECT CAST(''"' || TRIM(c.DatabaseName) || '";"' || TRIM(c.TABLENAME) || '";"' || TRIM(c.COLUMNNAME) || '";"'' ||
TRIM(CAST(COALESCE(MAX(cnt) * 1.0 / SUM(cnt), 0) AS NUMBER FORMAT ''9.9999'')) || ''";"'' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || ''"'' AS VARCHAR(512))
AS """DATABASE_NAME"";""TABLE_NAME"";""COLUMN_NAME"";""SKEWED"";""CURRENT_TS"""
FROM(
SELECT COUNT(*) AS cnt
FROM "' || c.DATABASENAME || '"."' || c.TABLENAME ||
'" GROUP BY "' || c.COLUMNNAME || '") t' ||
CASE WHEN ROW_NUMBER() OVER(PARTITION BY c.DATABASENAME
ORDER BY c.TABLENAME DESC, c.COLUMNNAME DESC) <> 1
THEN ' UNION ALL'
ELSE ';' END (TITLE '--SKEWED--')
FROM dbc.columnsv c
INNER JOIN
(SELECT databasename, TABLENAME
FROM dbc.tablesv WHERE tablekind = 'T'
AND databasename = 'your_database_name') t
ON t.databasename = c.databasename
AND t.TABLENAME = c.TABLENAME
INNER JOIN
(SELECT databasename, TABLENAME, columnname FROM dbc.indices GROUP BY 1,2,3
WHERE TRANSLATE_CHK (databasename USING LATIN_TO_UNICODE) + TRANSLATE_CHK (TABLENAME USING LATIN_TO_UNICODE) + TRANSLATE_CHK (columnname USING LATIN_TO_UNICODE) = 0
) i
ON i.databasename = c.databasename
AND i.TABLENAME = c.TABLENAME
AND i.columnname = c.columnname
WHERE c.ColumnType NOT IN ('CO','JN','N','++','VA','UT','AN','XM','A1','BO')
ORDER BY c.TABLENAME, c.COLUMNNAME;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
.RUN FILE = column-skew-script-tera.csv
.EXPORT RESET
.EXPORT REPORT FILE = query-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 32000
SELECT
'"' || RTRIM(CAST(SqlTextInfo AS VARCHAR(31900)), ';') || '";"' ||
TRIM(QueryCount) || '";"' ||
TRIM(QueryId) || '";"' ||
TRIM(SqlRowNo) || '";"' ||
TRIM(QueryParts) || '";"' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || '"'
(TITLE '"query_text";"query_count";"query_id";"sql_row_no";"query_parts";"current_ts"')
FROM
(
SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
SUM(QueryFirstRow) OVER (ORDER BY QueryCount DESC, QueryId ASC, SqlRowNo ASC
ROWS UNBOUNDED PRECEDING) AS topN
FROM
(SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
CASE WHEN
ROW_NUMBER() OVER (PARTITION BY QueryCount, SqlTextInfo ORDER BY QueryId, SqlRowNo) = 1 AND SqlRowNo = 1
THEN 1 ELSE 0 END AS QueryFirstRow
FROM (
SELECT q.QueryId, q.SqlTextInfo, q.SqlRowNo,
MAX(q.SqlRowNo) OVER (PARTITION BY q.QueryId) QueryParts,
COUNT(q.SqlTextInfo) OVER (PARTITION BY q.SqlTextInfo) QueryCount
FROM DBC.dbqlsqltbl q
INNER JOIN
(
SELECT QueryId
FROM DBC.DBQLogTbl t
WHERE TRIM(t.StatementType) IN ('SELECT')
AND TRIM(t.AbortFlag) = '' AND t.ERRORCODE = 0
AND (CASE WHEN 'All users' IN ('All users') THEN 'All users' ELSE TRIM(t.USERNAME) END) IN ('All users') --user_name list
AND t.StartTime > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) t
ON q.QueryId = t.QueryId
INNER JOIN
(
SELECT QueryId
FROM DBC.QryLogObjectsV
WHERE ObjectDatabaseName = 'your_database_name'
AND ObjectType = 'Tab'
AND CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) r
ON r.QueryId = t.QueryId
WHERE q.CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
) t
) t
WHERE SqlTextInfo NOT LIKE '%";"%'
) q
WHERE
QueryParts >=1
AND topN <= 50
ORDER BY QueryCount DESC, QueryId, SqlRowNo
QUALIFY COUNT(QueryId) OVER (PARTITION BY QueryId) = QueryParts;
.EXPORT RESET
.LOGOFF
.QUIT
```
1. 创建用于运行您在上一步中创建的 BTEQ 脚本的 `td_run_bteq.bat` 文件。此文件使用以下内容。
```
@echo off > off-line_stats1.bteq & setLocal enableDELAYedexpansion
@echo off > off-line_stats2.bteq & setLocal enableDELAYedexpansion
set old1=your_teradata_server
set new1=%1
set old2=your_login
set new2=%2
set old3=your_database_name
set new3=%3
set old4=your_password
set /p new4=Input %2 pass?
for /f "tokens=* delims= " %%a in (off-line_stats.bteq) do (
set str1=%%a
set str1=!str1:%old1%=%new1%!
>> off-line_stats1.bteq echo !str1!
)
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str2=%%a
set str2=!str2:%old2%=%new2%!
>> off-line_stats2.bteq echo !str2!
)
type nul > off-line_stats1.bteq
for /f "tokens=* delims= " %%a in (off-line_stats2.bteq) do (
set str3=%%a
set str3=!str3:%old3%=%new3%!
>> off-line_stats1.bteq echo !str3!
)
type nul > off-line_stats2.bteq
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str4=%%a
set str4=!str4:%old4%=%new4%!
>> off-line_stats2.bteq echo !str4!
)
del .\off-line_stats1.bteq
echo export starting...
bteq -c UTF8 < off-line_stats.bteq > metadata_export.log
pause
```
1. 创建用于运行您在上一步中创建的批处理文件的 `runme.bat` 文件。此文件使用以下内容。
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
在`runme.bat`文件中，将*ServerName**UserName*、和*DatabaseName*替换为适用的值。
然后，运行 `runme.bat` 文件。转换到 Amazon Redshift 的每个数据仓库重复此步骤。
运行此脚本后，会收到三个文件，其中包含每个数据库的统计信息。您可以将这些文件上传到您的 AWS SCT 项目中。为此，请从项目的左侧面板中选择数据仓库，然后打开上下文 (右键单击) 菜单。选择**上传统计数据**。
## Teradata 到 Amazon Redshift 的转换设置
**要编辑 Teradata 到 Amazon Redshift 的转换设置，**请在中选择**设置 AWS SCT，然后选择转换设置。**从上方的列表中选择 Teradata，然后选择 **Teradata** — **Amazon Redshif** t。 AWS SCT 显示 Teradata 到 Amazon Redshift 转换的所有可用设置。
中的 Teradata 到 Amazon Redshift AWS SCT 的转换设置包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
+ 要在 `SELECT *` 语句转换后的代码中使用显式列列表，请选择**使用显式列声明**。
+ 要模拟 Amazon Redshift 集群中主键和唯一键的行为，请选择**模拟主键和唯一键的行为**。
Amazon Redshift 不强制使用唯一键和主键，它们仅用于提供信息。如果您在代码中使用这些约束，请确保在转换后的代码中 AWS SCT 模拟它们的行为。
+ 确保目标 Amazon Redshift 表中的数据唯一性。为此，请选择**模拟 SET 表的行为**。
Teradata 使用 `SET` 语法元素作为默认选项创建表。您不能在 `SET` 表中添加重复的行。如果源代码不使用此唯一性约束，请关闭此选项。在这种情况下，转换后的代码运行更快。
如果源代码使用表中的 `SET` 选项作为唯一性约束，请启用此选项。在这种情况下，在转换后的代码中 AWS SCT 重写`INSERT..SELECT`语句以模拟源数据库的行为。
## Teradata 到 Amazon Redshift 的转换优化设置
**要编辑 Teradata 到 Amazon Redshift 的转化优化设置，请在 AWS SCT中**选择 “**设置”，然后选择 “转换设置”。**从上方的列表中选择 **Teradata**，然后选择 **Teradata – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Teradata 到 Amazon Redshift 转换的转换优化设置。
Teradata 到 Amazon Redshift 的转化优化设置 AWS SCT 包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
# 将连接 AWS Schema Conversion Tool 到 Vertica 数据库
您可以使用 AWS SCT 将架构、代码对象和应用程序代码从 Vertica 转换为 Amazon Redshift。
## 将 Vertica 用作源的权限
下面列出了将 Vertica 用作源所需的权限：
+ 架构上的用法 **
+ USAGE ON SCHEMA PUBLIC
+ 在架构中的所有表上选择 **
+ 在架构中的所有序列上选择 **
+ 对架构中的所有函数执行 **
+ 按程序执行 **
在上述示例中，替换以下占位符：
+ 将 *schema\$1name* 替换为源架构的名称。
+ *procedure\$1name*替换为源过程的名称。对正在转换的每个过程重复授权。
+ *procedure\$1signature*替换为以逗号分隔的过程参数类型列表。
## 连接到作为源的 Vertica
使用 AWS Schema Conversion Tool按照以下过程连接到 Vertica 源数据库。
**连接到 Vertica 源数据库**
1. 在中 AWS Schema Conversion Tool，选择**添加来源**。
1. 选择 **Vertica**，然后选择**下一步**。
此时显示**添加源**对话框。
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)。
+ 要手动输入 Vertica 源数据库连接信息，请按照以下说明进行操作：
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/SchemaConversionTool/latest/userguide/CHAP_Source.Vertica.html)
1. 选择 “**测试连接**” 以验证是否 AWS SCT 可以连接到您的源数据库。
1. 选择**连接**以连接到源数据库。
## Vertica 到 Amazon Redshift 的转换设置
要编辑 Vertica 到 Amazon Redshift 的转换设置，请在 AWS SCT中**选择** “设置”，然后**选择 “**转换设置”。从上方的列表中选择 **Vertica，然后选择 Vertica** **— Amazon Redshift**。 AWS SCT 显示 Vertica 到 Amazon Redshift 转换的所有可用设置。
中的 Vertica 到 Amazon Redshift 转换设置 AWS SCT 包括以下选项：
+ 限制转换后的代码中操作项的注释数量。
对于在**转换后的代码中为所选严重性及更高的措施项添加注释**，请选择措施项的严重性。 AWS SCT 在转换后的代码中为选定严重性及更高的措施项添加注释。
例如，要最大限度地减少转换后的代码中的注释数量，请选择**仅错误**。要在转换后的代码中包含所有操作项的注释，请选择**所有消息**。
+ 设置 AWS SCT 可以应用于您的目标 Amazon Redshift 集群的最大表数。
对于**目标 Amazon Redshift 集群的最大表**数，请选择 AWS SCT 可以应用于您的 Amazon Redshift 集群的表数量。
Amazon Redshift 具有限制了不同集群节点类型使用表数的配额。如果您选择 “**自动**”，则根据节点类型 AWS SCT 确定要应用于目标 Amazon Redshift 集群的表数量。或者，手动选择值。有关更多信息，请参阅《Amazon Redshift 管理指南》**中的 [Amazon Redshift 中的配额和限制](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)。
AWS SCT 转换您的所有源表，即使这超过了您的 Amazon Redshift 集群所能存储的容量。 AWS SCT 将转换后的代码存储在您的项目中，并且不会将其应用于目标数据库。如果应用转换后的代码时达到了 Amazon Redshift 集群的表配额，则 AWS SCT 会显示一条警告消息。此外，还要 AWS SCT 将表应用于您的目标 Amazon Redshift 集群，直到表的数量达到上限。
+ 在 Amazon Redshift 中将源表的分区迁移到单独的表。为此，请选择**使用 UNION ALL 视图**，然后输入 AWS SCT 可以为单个源表创建的最大目标表数。
Amazon Redshift 不支持表分区。要模拟此行为并加快查询运行速度， AWS SCT 可以将源表的每个分区迁移到 Amazon Redshift 中的单独表中。然后， AWS SCT 创建一个包含所有这些表中的数据的视图。
AWS SCT 自动确定源表中的分区数量。根据源表分区的类型，此数量可能会超过您可以应用于 Amazon Redshift 集群的表配额。为避免达到此配额，请输入 AWS SCT 可以为单个源表的分区创建的最大目标表数。默认选项为 368 个表，它表示一年中 366 天的分区和以及 `NO RANGE` 和 `UNKNOWN` 分区的两个表。
+ 对 Amazon Redshift 表列应用压缩。为此，请选择**使用压缩编码**。
AWS SCT 使用默认 Amazon Redshift 算法自动为列分配压缩编码。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[压缩编码](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html)。
默认情况下，Amazon Redshift 不对定义为排序键和分配键的列应用压缩。您可以更改此行为并对这些列进行压缩。为此，请选择**为 KEY 列使用压缩编码**。只有选择**使用压缩编码**选项时，才能选择此选项。
## Vertica 到 Amazon Redshift 的转换优化设置
要编辑 Vertica 到 Amazon Redshift 的转化优化设置，请在**中选择**设置 AWS SCT，然后**选择**转换设置。从上方的列表中选择 **Vertica**，然后选择 **Vertica – Amazon Redshift**。在左侧窗格中，选择**优化策略**。 AWS SCT 显示 Vertica 到 Amazon Redshift 转换的转化优化设置。
中的 Vertica 到 Amazon Redshift 转化优化设置 AWS SCT 包括以下选项：
+ 使用自动表优化。为此，请选择**使用 Amazon Redshift 自动调整表格**。
自动表优化是 Amazon Redshift 中的一种自我调整过程，可自动优化表的设计。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》**中的[使用自动表优化](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html)。
要仅使用自动表优化，请在**初始键选择策略**中选择**无**。
+ 使用策略选择排序键和分配键。
您可以使用 Amazon Redshift 元数据、统计信息或这两个选项选择排序键和分配键。对于**优化策略**选项卡上的**初始键选择策略**，请选择以下选项之一：
+ 使用元数据，忽略统计信息
+ 忽略元数据，使用统计信息
+ 使用元数据和统计信息
根据您选择的选项，您可以选择优化策略。然后，请为每种策略输入值（0–100）。这些值定义了每种策略的权重。 AWS SCT 使用这些权重值定义每条规则如何影响分布键和排序键的选择。默认值基于 AWS 迁移最佳实践。
您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数以将其定义为小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。
+ 配置策略详细信息。
除了定义每种优化策略的权重外，您还可以配置优化设置。为此，请选择**转换优化**。
+ 对于**排序键列数限制**，在排序键中输入最大列数。
+ 在**倾斜阈值**中，输入列偏斜值的百分比 (0—100)。 AWS SCT 从分布键的候选列表中排除倾斜值大于阈值的列。 AWS SCT 将列的偏斜值定义为最常见值的出现次数与记录总数的百分比比率。
+ 对于**查询历史表中的前 N 个查询**，请输入要分析的最常用查询的数量（1–100）。
+ 在**选择统计数据用户**中，选择要分析查询统计数据的数据库用户。
此外，在**优化策略**选项卡上，您可以为**查找小型表**策略定义小型表的大小。在 “**最小表格行数**” 和 “**最大表格行数**” 中，输入表格中最小和最大行数，将其视为一个小表。 AWS SCT 将`ALL`分配方式应用于小表。在这种情况下，向每个节点分配整个表的副本。