`。
您可以在下表中找到範例。
| 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 Enterprise Edition 中的一個選項，與 Oracle Database 11g Release 2 一同推出。Amazon RDS for Oracle 不支援 RAC 功能。使用 Amazon RDS 異地同步備份以提供高可用性。
在異地同步備份部署中，Amazon RDS 會自動佈建，並在不同的可用區域中維持同步待命複本。主資料庫執行個體會在待命複本的可用區域間進行同步複製。此功能可提供資料備援，排除 I/O 凍結，並降低系統備份時的延遲遽增。
+ Oracle Spatial 提供的 SQL 結構描述和函數，有助於 Oracle 資料庫中空間資料集合的儲存、擷取、更新和查詢。Oracle Locator 提供通常支援下列項目所需的功能：網際網路和無線服務型應用程式和合作夥伴型 GIS 解決方案。Oracle Locator 是功能有限的 Oracle Spatial 子集。
若要使用 Oracle Spatial 和 Oracle Locator 功能，請將 SPATIAL 選項或 LOCATOR 選項 (兩者互斥) 新增至資料庫執行個體的選項群組。
在 Amazon RDS for Oracle 資料庫執行個體上使用 Oracle Spatial 和 Oracle Locator 有一些先決條件：
+ 執行個體應使用 Oracle Enterprise Edition 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 分以上的安全漏洞或其他公布的安全漏洞，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 和 Graph](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph)。
+ Data Guard 包含在 Oracle Database Enterprise Edition 中。使用 Amazon RDS 異地同步備份功能以提供高可用性。
在異地同步備份部署中，Amazon RDS 會自動佈建，並在不同的可用區域中維持同步待命複本。主資料庫執行個體會在待命複本的可用區域間進行同步複製。此功能可提供資料備援，排除 I/O 凍結，並降低系統備份時的延遲遽增。
+ AWS SCT 支援在遷移至 Amazon RDS for Oracle 時轉換 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 物件。若要使用資料庫連結，請附加 `@dblink` 至表格、檢視或 PL/SQL 物件名稱。您可用 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 Cluster。
+ 磁碟讀寫負載。
+ 磁碟輸送量總平均。
+ 伺服器資訊，如：伺服器名稱、作業系統、主機名稱和字元集。
## RDS for 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 Unified Auditing 的傳統稽核、精細稽核。
+ Amazon RDS for Oracle 不支援變更資料擷取 (CDC)。若要在資料庫遷移期間和之後執行 CDC，請使用 AWS Database Migration Service。
# 使用 連線至 PostgreSQL 資料庫 AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、資料庫程式碼物件和應用程式程式碼從 PostgreSQL 轉換為下列目標：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
如需詳細資訊，請參閱下列章節：
**Topics**
+ [PostgreSQL 做為來源資料庫的權限](#CHAP_Source.PostgreSQL.Permissions)
+ [連接至 PostgreSQL 做為來源](#CHAP_Source.PostgreSQL.Connecting)
+ [MySQL 做為目標資料庫的權限](#CHAP_Source.PostgreSQL.ConfigureMySQL)
## PostgreSQL 做為來源資料庫的權限
PostgreSQL 做為來源所需的權限如下：
+ CONNECT ON DATABASE **
+ USAGE ON SCHEMA **
+ SELECT ON ALL TABLES IN SCHEMA **
+ SELECT ON ALL SEQUENCES IN SCHEMA **
## 連接至 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 Secret**，選擇秘密的名稱。
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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.PostgreSQL.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
## MySQL 做為目標資料庫的權限
當您從 PostgreSQL MySQL 遷移時，MySQL 做為目標所需的權限如下：
+ CREATE ON \$1.\$1
+ ALTER ON \$1.\$1
+ DROP ON \$1.\$1
+ INDEX ON \$1.\$1
+ 參考開啟 \$1.\$1
+ SELECT ON \$1.\$1
+ 在 \$1.\$1 上建立檢視
+ SHOW VIEW ON \$1.\$1
+ 觸發開啟 \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERT，更新 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-Compatible Edition
+ Amazon RDS for MariaDB
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
如需詳細資訊，請參閱下列章節：
**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)
使用下列程序，透過 連線至 SAP ASE 來源資料庫 AWS Schema Conversion Tool。
**連線至 SAP ASE 來源資料庫**
1. 在 中 AWS Schema Conversion Tool，選擇**新增來源**。
1. 選擇 **SAP ASE**，然後選擇**下一步**。
**新增來源**對話方塊隨即出現。
1. 在**連線名稱**中，輸入資料庫的名稱。 會在左側面板的樹狀目錄中 AWS SCT 顯示此名稱。
1. 使用來自 的資料庫登入資料 AWS Secrets Manager 或手動輸入：
+ 若要從 Secrets Manager 使用資料庫登入資料，請使用下列指示：
1. 針對 **AWS Secret**，選擇秘密的名稱。
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_tw/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
+ 參考開啟 \$1.\$1
+ SELECT ON \$1.\$1
+ 在 \$1.\$1 上建立檢視
+ SHOW VIEW ON \$1.\$1
+ 觸發開啟 \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERT，更新 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** – 在 PostgreSQL 中使用 SAP ASE 資料庫和結構描述名稱的組合做為結構描述名稱。
+ 在轉換後的程式碼中使用來源資料庫物件的確切名稱。
根據預設， 會將資料庫物件、變數和參數的名稱 AWS SCT 轉換為小寫。若要保留這些名稱的原始案例，請選取**將來源資料庫物件名稱視為區分大小寫**。如果您在來源 SAP ASE 資料庫伺服器中使用區分大小寫的物件名稱，請選擇此選項。
對於區分大小寫的操作， AWS SCT 可以避免將資料庫物件名稱轉換為小寫。若要這樣做，請選取**避免轉換為小寫，以進行區分大小寫的操作**。
+ 允許在 SAP ASE 的不同資料表中使用具有相同名稱的索引。
在 PostgreSQL 中，您在結構描述中使用的所有索引名稱都必須是唯一的。若要確保 AWS SCT 產生所有索引的唯一名稱，請選取**產生索引的唯一名稱**。
# 使用 連接 Microsoft SQL Server AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、資料庫程式碼物件和應用程式程式碼從 SQL Server 轉換為下列目標：
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS for PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
+ Amazon RDS for SQL Server
+ Amazon RDS for MariaDB
**注意**
AWS SCT 不支援使用 Amazon RDS for SQL Server 做為來源。
您可以使用 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 遷移至 Amazon RDS for SQL Server 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 Enterprise Edition 的功能。
對您要轉換其結構描述的每個資料庫重複授予。
此外，請授與 `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 代理程式角色的名稱。然後將``預留位置取代為您之前授予 權限的使用者名稱。如需詳細資訊，請參閱《*Amazon RDS 使用者指南*》中的「[將使用者新增至 SQLAgentUser 角色](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 為基礎的內部網路，您可以在存取資料庫時使用 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]
```
### 搭配 JDBC 連線使用 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<*version*>\$1<*language*>\$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 Secret**，選擇秘密的名稱。
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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
# 將 SQL Server 轉換到 MySQL
若要在轉換後的 MySQL 程式碼中模擬 Microsoft SQL Server 資料庫函數，請使用 SQL Server 到 MySQL 延伸套件 AWS SCT。如需詳細了解延伸套件，請參閱：[搭配 使用延伸套件 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
+ ON \$1.\$1 參考資料
+ SELECT ON \$1.\$1
+ 在 \$1.\$1 上建立檢視
+ SHOW VIEW ON \$1.\$1
+ 觸發開啟 \$1.\$1
+ 建立路由開啟 \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERT，更新 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 版或更低版本做為目標，請執行下列命令。對於 MySQL 資料庫 8.0 版和更新版本，此命令已棄用。
```
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 可以使用 `INSERT ON DUPLICATE KEY`子句和 `MERGE`陳述式，在轉換期間模擬`UPDATE FROM and DELETE FROM`陳述式。
若要使用 正確模擬`INSERT ON DUPLICATE KEY`，請確定目標 MySQL 資料庫上存在唯一的限制條件或主索引鍵。
+ 您可以使用`GOTO`陳述式和標籤來變更陳述式執行的順序。任何遵循陳述式的 Transact-SQL `GOTO`陳述式都會略過，處理會在 標籤繼續。您可以在程序、批次或`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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL 不支援多陳述式資料表值函數。 透過建立暫存資料表和重寫陳述式來使用這些暫存資料表，在轉換期間 AWS SCT 模擬資料表值函數。
# 使用 從 SQL Server 遷移至 PostgreSQL AWS Schema Conversion Tool
您可以在其中使用 SQL Server 到 PostgreSQL 延伸套件 AWS SCT。此延伸套件會在轉換後的 PostgreSQL 程式碼中模擬 SQL Server 資料庫函數。使用 SQL Server 到 PostgreSQL 延伸套件來模擬 SQL Server Agent 和 SQL Server Database Mail。如需詳細了解延伸套件，請參閱：[搭配 使用延伸套件 AWS Schema Conversion Tool](CHAP_ExtensionPack.md)。
**Topics**
+ [PostgreSQL 做為目標資料庫的權限](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [SQL 伺服器到 PostgreSQL 轉換設定](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [將 SQL Server 分割區轉換為 PostgreSQL 第 10 版分割區](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [遷移考量事項](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [使用 AWS SCT 延伸套件模擬 PostgreSQL 中的 SQL Server Agent](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [使用 AWS SCT 延伸套件模擬 PostgreSQL 中的 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 伺服器到 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** – 在 PostgreSQL 中使用 SQL Server 資料庫和結構描述名稱的組合做為結構描述名稱。
+ 保留來源物件名稱的字母大小寫。
若要避免將物件名稱轉換為小寫，請選取**避免轉換為小寫以進行區分大小寫的操作**。此選項僅適用於您在目標資料庫中開啟區分大小寫選項時。
+ 保留來源資料庫中的參數名稱。
若要將雙引號新增至轉換程式碼中的參數名稱，請選取**保留原始參數名稱**。
## 將 SQL Server 分割區轉換為 PostgreSQL 第 10 版分割區
當您將 Microsoft SQL Server 資料庫轉換為 Amazon Aurora PostgreSQL 相容版本 (Aurora PostgreSQL) 或 Amazon Relational Database Service for PostgreSQL (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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL 不支援 MERGE 陳述式。 會以下列方式 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 轉換為 Amazon RDS for PostgreSQL 時， AWS SCT 會取代使用 PATINDEX 搭配 aws\$1sqlserver\$1ext.patindex (， ) 的應用程式程式碼。
+ 在 SQL Server 中，使用者定義資料表類型是一種代表資料表結構定義的類型。您可以使用使用者定義的資料表類型來宣告預存程序或函數的資料表值參數。您也可以使用使用者定義的資料表類型，宣告您想要在批次或預存程序或函數內文中使用的資料表變數。透過建立暫存資料表，在 PostgreSQL 中 AWS SCT 模擬此類型。
從 SQL Server 轉換為 PostgreSQL 時， 會將 SQL Server 系統物件 AWS SCT 轉換為 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\$1TYPES |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1COLUMNS |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1COLUMNS |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEYS |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSFOREIGNKEYS |
| SYS.FOREIGN\$1KEY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEY\$1COLUMNS |
| SYS.KEY\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.SYS\$1KEY\$1CONSTRAINTS |
| SYS.IDENTITY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1IDENTITY\$1COLUMNS |
| SYS.PROCEDURES | AWS\$1SQLSERVER\$1EXT.SYS\$1PROCEDURES |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1INDEXES |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXES |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJECTS |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1OBJECTS |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJECTS |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULES |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1DATABASES |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SCHEMATA |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1VIEWS |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLES |
| INFORMATION\$1SCHEMA.COLUMNS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1COLUMNS |
| INFORMATION\$1SCHEMA.CHECK\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CHECK\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.REFERENTIAL\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1REFERENTIAL\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.TABLE\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLE\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.KEY\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1KEY\$1COLUMN\$1USAGE |
| 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\$1ROUTINES |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSPROCESSES |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSTEM\$1OBJECTS |
# 使用 AWS SCT 延伸套件模擬 PostgreSQL 中的 SQL Server Agent
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 Agent 功能，請 AWS SCT 建立延伸套件。此延伸套件使用 AWS Lambda 和 Amazon CloudWatch。 AWS Lambda 實作您用來管理排程和執行任務的界面。Amazon 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 Agent 行為， AWS SCT 延伸套件也會建立下列資料表和程序。
## 在 PostgreSQL 中模擬 SQL Server 代理程式的資料表
若要模擬 SQL Server Agent，延伸套件會使用下列資料表：
**sysjobs**
儲存任務的相關資訊。
**sysjobsteps**
儲存有關任務步驟的資訊。
**sysschedules**
儲存任務排程的相關資訊。
**sysjobschedules**
儲存個別任務的排程資訊。
**sysjobhistory**
儲存排程任務執行的相關資訊。
## 在 PostgreSQL 中模擬 SQL Server 代理程式的程序
若要模擬 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 Agent 來執行任務，您可以使用 SQL Server 到 PostgreSQL 延伸套件 AWS SCT ，讓 將此程式碼轉換為 PostgreSQL。延伸套件使用 AWS Lambda 函數來模擬 SQL Server Agent 的行為。
您可以建立新的 AWS Lambda 函數或註冊現有的函數。
**建立新的 AWS Lambda 函數**
1. 在 AWS SCT目標資料庫樹狀目錄中，開啟內容 （按一下滑鼠右鍵） 選單，選擇**套用延伸套件，**然後選擇 **PostgreSQL**。
會顯示延伸套件精靈。
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 Resource Name (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);
```
# 使用 AWS SCT 延伸套件模擬 PostgreSQL 中的 SQL Server 資料庫郵件
您可以使用 SQL Server Database Mail，從 SQL Server Database Engine 或 Azure SQL 受管執行個體傳送電子郵件訊息給使用者。這些電子郵件訊息可以包含查詢結果，或包含來自您網路上任何資源的檔案。如需 SQL Server Database Mail 的詳細資訊，請參閱 [Microsoft 技術文件](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15)。
PostgreSQL 沒有 SQL Server Database Mail 的同等項目。若要模擬 SQL Server Database Mail 功能， AWS SCT 會建立延伸套件。此延伸套件使用 AWS Lambda 和 Amazon Simple Email Service (Amazon SES)。 AWS Lambda 提供使用者與 Amazon SES 電子郵件傳送服務互動的界面。若要設定此互動，請新增 Lambda 函數的 Amazon Resource Name (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 Database Mail 行為，延伸 AWS SCT 套件會使用下列資料表、檢視和程序。
## 在 PostgreSQL 中模擬 SQL Server 資料庫郵件的資料表
若要模擬 SQL Server Database Mail，延伸套件會使用下列資料表：
**sysmail\$1account**
儲存電子郵件帳戶的相關資訊。
**sysmail\$1profile**
儲存有關使用者設定檔的資訊。
**sysmail\$1server**
存放電子郵件伺服器的相關資訊。
**sysmail\$1mailitems**
儲存電子郵件訊息的清單。
**sysmail\$1attachments**
包含每個電子郵件附件的一列。
**sysmail\$1log**
儲存有關傳送電子郵件訊息的服務資訊。
**sysmail\$1profileaccount**
儲存使用者設定檔和電子郵件帳戶的相關資訊。
## 在 PostgreSQL 中模擬 SQL Server 資料庫郵件的檢視
若要模擬 SQL Server Database Mail， 會在 PostgreSQL 資料庫中 AWS SCT 建立下列檢視，以確保相容性。延伸套件不會使用它們，但轉換後的程式碼可以查詢這些檢視。
**sysmail\$1allitems**
包含所有電子郵件的清單。
**sysmail\$1faileditems**
包含無法傳送的電子郵件清單。
**sysmail\$1sentitems**
包含已傳送的電子郵件清單。
**sysmail\$1unsentitems**
包含尚未傳送的電子郵件清單。
**sysmail\$1mailattachments**
包含連接檔案的清單。
## 在 PostgreSQL 中模擬 SQL Server 資料庫郵件的程序
若要模擬 SQL Server Database Mail，延伸套件會使用下列程序：
**sp\$1send\$1dbmail**
傳送電子郵件給指定的收件人。
**sysmail\$1add\$1profile\$1sp**
建立新的使用者設定檔。
**sysmail\$1add\$1account\$1sp**
建立新的電子郵件帳戶，以存放 Simple Mail Transfer Protocol (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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 程序的詳細資訊，請參閱 [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 Database Mail 來傳送電子郵件，您可以使用 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 遷移至 Amazon RDS for SQL Server AWS Schema Conversion Tool
將 SQL Server 結構描述和程式碼遷移到 Amazon RDS for SQL Server 的一些考量事項：
+ AWS SCT 可以轉換 SQL Server Agent，以在 Amazon RDS for SQL Server 資料庫執行個體上提供排程、提醒和任務。轉換後，您可以將 Amazon RDS for SQL Server 資料庫執行個體搭配 SQL Server Reporting Service (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 轉換應用程式程式碼。不過，請務必檢閱使用連結伺服器之物件的行為，然後再執行轉換的程式碼。
+ 系統會使用 Always on。
+ AWS SCT 評估報告提供轉換的伺服器指標。這類有關 SQL Server 執行個體的各項指標包括：
+ 已使用資料鏡像。
+ 已設定 SQL Server 記錄傳送。
+ 已使用容錯移轉叢集。
+ 已設定 Database Mail。
+ 已使用全文檢索搜尋服務。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 Analytics 與 連線 AWS Schema Conversion Tool](CHAP_Source.AzureSynapse.md)
+ [使用 連線至 Google 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 Data Warehouse AWS SCT](CHAP_Source.OracleDW.md)
+ [使用 連線至 Snowflake 資料倉儲 AWS Schema Conversion Tool](CHAP_Source.Snowflake.md)
+ [使用 連線至 SQL Server Data Warehouse AWS Schema Conversion Tool](CHAP_Source.SQLServerDW.md)
+ [使用 連線至 Teradata Data Warehouse 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 來最佳化 Amazon Redshift 叢集。 AWS SCT 為您提供有關為 Amazon Redshift 叢集選擇分佈和排序索引鍵的建議。您可以將 Amazon Redshift 最佳化專案視為指向不同 Amazon Redshift 叢集的來源和目標 AWS SCT 專案。
## Amazon Redshift 做為來源資料庫的權限
使用 Amazon Redshift 做為來源時需要下列權限：
+ USAGE ON SCHEMA **
+ SELECT ON ALL TABLES IN SCHEMA **
+ SELECT ON PG\$1CATALOG.PG\$1STATISTIC
+ SELECT ON SVV\$1TABLE\$1INFO
+ SELECT ON TABLE STV\$1BLOCKLIST
+ SELECT ON TABLE STV\$1TBL\$1PERM
+ 在 SYS\$1SERVERLESS\$1USAGE 上選取
+ 在 PG\$1DATABASE\$1INFO 上選取
+ SELECT ON PG\$1STATISTIC
在上述範例中，將 ** 預留位置取代為來源結構描述的名稱。
如需 Amazon Redshift 做為目標所需的權限，請參閱 [Amazon Redshift 做為目標的許可](CHAP_Converting.DW.md#CHAP_Converting.DW.ConfigureTarget)。
## 以來源身分連線至 Amazon Redshift
使用下列程序，透過 連線至 Amazon Redshift 來源資料庫 AWS Schema Conversion Tool。
**連線至 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_tw/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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數上限。
+ 針對**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 會將偏斜值大於閾值的資料欄從分佈索引鍵的候選項目清單中排除。 AWS SCT 會將資料欄偏斜值定義為最常用值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析其查詢統計資料的資料庫使用者。
# 將 Azure Synapse Analytics 與 連線 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
使用下列程序，透過 連線至 Azure Synapse Analytics 資料倉儲 AWS Schema Conversion Tool。
**以來源身分連線至 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_tw/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 Synapse – Amazon Redshift**。 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數目上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常出現之值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 針對**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
# 使用 連線至 Google BigQuery AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 BigQuery 轉換為 Amazon Redshift。
## 作為來源的 BigQuery 權限
若要使用 BigQuery 資料倉儲做為 中的來源 AWS SCT，請建立服務帳戶。在 Google Cloud 中，應用程式會使用服務帳戶來進行授權的 API 呼叫。服務帳戶與使用者帳戶不同。如需詳細資訊，請參閱 Google Cloud Identity and Access Management 文件中的[服務帳戶](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：//[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 Admin**。
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. 選擇**連線**以連線至來源 BigQuery 專案。
## 使用 BigQuery 做為 來源的限制 AWS SCT
使用 BigQuery 做為 來源時，適用下列限制 AWS SCT：
+ AWS SCT 不支援在分析函數中轉換子查詢。
+ 您無法使用 AWS SCT 轉換 BigQuery `SELECT AS STRUCT`和 `SELECT AS VALUE` 陳述式。
+ AWS SCT 不支援轉換下列類型的函數：
+ 大約彙總
+ 位元
+ 除錯
+ 聯合查詢
+ 地理
+ 雜湊
+ 數學
+ 淨值
+ 統計彙總
+ UUID
+ AWS SCT 提供有限的字串函數轉換支援。
+ AWS SCT 不支援轉換`UNNEST`運算子。
+ 您無法在 中轉換關聯的聯結操作 AWS SCT。
+ AWS SCT 不支援轉換 `QUALIFY`、`LIMIT`、 `WINDOW`和 `OFFSET`子句。
+ 您無法使用 AWS SCT 來轉換遞迴通用資料表表達式。
+ AWS SCT 不支援在 `VALUES`子句內使用子查詢轉換`INSERT`陳述式。
+ AWS SCT 不支援轉換巢狀欄位和重複記錄的`UPDATE`陳述式。
+ 您無法使用 AWS SCT 來轉換 `STRUCT`和 `ARRAY` 資料類型。
## BigQuery 至 Amazon Redshift 轉換設定
若要編輯 BigQuery 至 Amazon Redshift 轉換設定，請選擇 中的**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中選擇 **Google BigQuery**，然後選擇 **Google 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 到 Amazon Redshift 轉換最佳化設定
若要編輯 BigQuery 至 Amazon Redshift 轉換最佳化設定，請選擇**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中選擇 **Google BigQuery**，然後選擇 **Google BigQuery – Amazon Redshift**。在左側窗格中，選擇**最佳化策略**。 AWS SCT 顯示 BigQuery 到 Amazon 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數目上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常出現之值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 針對**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
# 使用 連接 Greenplum 資料庫 AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Greenplum Database 轉換為 Amazon Redshift。
## Greenplum 資料庫做為來源的權限
使用 Greenplum 資料庫做為來源時，需要下列權限：
+ CONNECT ON DATABASE **
+ USAGE ON SCHEMA **
+ SELECT ON *.*
+ SELECT ON SEQUENCE *.*
在上述範例中，取代預留位置，如下所示：
+ 將 *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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.Greenplum.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
## Greenplum 至 Amazon Redshift 轉換設定
若要編輯 Greenplum 至 Amazon Redshift 轉換設定，請選擇 中的**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中，選擇 **Greenplum**，然後選擇 **Greenplum – 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數目上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常出現的值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
# 使用 連線至 Netezza AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Netezza 轉換為 Amazon Redshift。
## Netezza 做為來源的權限
使用 Netezza 做為來源時需要下列權限：
+ 在 system.definition\$1schema.system 檢視上選取
+ 在 system.definition\$1schema.system 資料表上選取
+ 在 system.definition\$1schema.management 資料表上選取
+ ** 上的清單
+ ** 上的清單
+ **.all.table 上的清單
+ **.all.external 資料表上的清單
+ **.all.view 上的清單
+ **.all.materialized 檢視上的清單
+ **.all.procedure 上的清單
+ **.all.sequence 上的清單
+ **.all.function 上的清單
+ **.all.aggregate 上的清單
在上述範例中，取代預留位置，如下所示：
+ 將 *database\$1name* 取代為來源資料庫的名稱。
+ 將 *schema\$1name* 取代為來源結構描述的名稱。
AWS SCT 需要存取下列系統資料表和檢視。您可以授予這些物件的存取權，而不是授予對上述清單中 `system.definition_schema.system view`和 `system.definition_schema.system tables`的存取權。
+ 在 system.definition\$1schema.\$1t\$1aggregate 上選取
+ 在 system.definition\$1schema.\$1t\$1class 上選取
+ 在 system.definition\$1schema.\$1t\$1constraint 上選取
+ 在 system.definition\$1schema.\$1t\$1const\$1relattr 上選取
+ 在 system.definition\$1schema.\$1t\$1database 上選取
+ 在 system.definition\$1schema.\$1t\$1grpobj\$1priv 上選取
+ 在 system.definition\$1schema.\$1t\$1grpusr 上選取
+ 在 system.definition\$1schema.\$1t\$1hist\$1config 上選取
+ 在 system.definition\$1schema.\$1t\$1object 上選取
+ 在 system.definition\$1schema.\$1t\$1object\$1classes 上選取
+ 在 system.definition\$1schema.\$1t\$1proc 上選取
+ 在 system.definition\$1schema.\$1t\$1type 上選取
+ 在 system.definition\$1schema.\$1t\$1user 上選取
+ 在 system.definition\$1schema.\$1t\$1usrobj\$1priv 上選取
+ 在 system.definition\$1schema.\$1vt\$1sequence 上選取
+ 在 system.definition\$1schema.\$1v\$1aggregate 上選取
+ 在 system.definition\$1schema.\$1v\$1constraint\$1depends 上選取
+ 在 system.definition\$1schema.\$1v\$1database 上選取
+ 在 system.definition\$1schema.\$1v\$1datatype 上選取
+ 在 system.definition\$1schema.\$1v\$1dslice 上選取
+ 在 system.definition\$1schema.\$1v\$1function 上選取
+ 在 system.definition\$1schema.\$1v\$1group 上選取
+ 在 system.definition\$1schema.\$1v\$1obj\$1relation 上選取
+ 在 system.definition\$1schema.\$1v\$1obj\$1relation\$1xdb 上選取
+ 在 system.definition\$1schema.\$1v\$1procedure 上選取
+ 在 system.definition\$1schema.\$1v\$1relation\$1column 上選取
+ 在 system.definition\$1schema.\$1v\$1relation\$1keydata 上選取
+ 在 system.definition\$1schema.\$1v\$1relobjclasses 上選取
+ 在 system.definition\$1schema.\$1v\$1schema\$1xdb 上選取
+ 在 system.definition\$1schema.\$1v\$1sequence 上選取
+ 在 system.definition\$1schema.\$1v\$1synonym 上選取
+ 在 system.definition\$1schema.\$1v\$1system\$1info 上選取
+ 在 system.definition\$1schema.\$1v\$1sys\$1constraint 上選取
+ 在 system.definition\$1schema.\$1v\$1sys\$1object\$1dslice\$1info 上選取
+ 在 system.definition\$1schema.\$1v\$1sys\$1user 上選取
+ 在 system.definition\$1schema.\$1v\$1table 上選取
+ 在 system.definition\$1schema.\$1v\$1table\$1constraint 上選取
+ 在 system.definition\$1schema.\$1v\$1table\$1dist\$1map 上選取
+ 在 system.definition\$1schema.\$1v\$1table\$1organize\$1column 上選取
+ 在 system.definition\$1schema.\$1v\$1table\$1storage\$1stat 上選取
+ 在 system.definition\$1schema.\$1v\$1user 上選取
+ 在 system.definition\$1schema.\$1v\$1view 上選取
+ 在 system.information\$1schema.\$1v\$1relation\$1column 上選取
+ 在 system.information\$1schema.\$1v\$1table 上選取
+ 選取 \$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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.Netezza.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
## 設定持續資料複寫
轉換 Netezza 資料庫結構描述並將其套用至 Amazon Redshift 資料庫後，您可以使用資料擷取代理程式遷移 AWS SCT 資料。代理程式會擷取您的資料並將其上傳至 Amazon S3 儲存貯體。然後，您可以使用 AWS SCT 將資料從 Amazon S3 複製到 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，然後選擇**轉換設定**。從上方清單中選擇 **Netezza**，然後選擇 **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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數目上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常出現之值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 針對**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
# 使用 連接 Oracle Data Warehouse AWS SCT
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Oracle Data Warehouse 轉換為 Amazon Redshift 或 Amazon Redshift，並結合 AWS Glue 使用。
## 做為來源的 Oracle Data Warehouse 權限
使用 Oracle Data Warehouse 做為來源時需要下列權限：
+ 連線
+ select\$1catalog\$1role
+ 選取任何字典
## 以來源身分連線至 Oracle Data Warehouse
使用以下程序，透過 AWS Schema Conversion Tool連接到您的 Oracle 資料倉儲來源資料庫。
**連線至 Oracle Data Warehouse 來源資料庫**
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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.OracleDW.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
## Oracle 資料倉儲到 Amazon Redshift 轉換設定
若要編輯 Oracle Data Warehouse 至 Amazon Redshift 轉換設定，請選擇**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中選擇 **Oracle**，然後選擇 **Oracle – Amazon Redshift**。 AWS SCT 顯示 Oracle Data Warehouse 到 Amazon Redshift 轉換的所有可用設定。
中的 Oracle Data Warehouse 至 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 不支援`TO_NUMBER`的日期時間格式元素來轉換資料類型格式函數`TO_CHAR`，例如 `TO_DATE`、 和 。根據預設， AWS SCT 會使用延伸套件函數來模擬轉換程式碼中這些不支援格式元素的使用情況。
相較於 Amazon Redshift 中的日期時間格式字串，Oracle 中的日期時間格式模型包含更多元素。當您的原始程式碼僅包含 Amazon Redshift 支援的日期時間格式元素時，您不需要轉換程式碼中的延伸套件函數。若要避免在轉換後的程式碼中使用延伸套件函數，請選取**您在 Oracle 程式碼中使用的 Datetype 格式元素，類似於 Amazon Redshift 中的日期時間格式字串**。在此情況下，轉換後的程式碼運作得更快。
相較於 Amazon Redshift 中的數值格式字串，Oracle 中的數值格式模型包含更多元素。當您的原始程式碼僅包含 Amazon Redshift 支援的數值格式元素時，您不需要轉換程式碼中的延伸套件函數。若要避免在轉換後的程式碼中使用延伸套件函數，請選取**您在 Oracle 程式碼中使用的數值格式元素，類似於 Amazon Redshift 中的數值格式字串**。在此情況下，轉換後的程式碼運作得更快。
+ 轉換 Oracle `LAG` `LEAD`和分析函數。根據預設， 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 Data Warehouse 到 Amazon Redshift 轉換最佳化設定
若要編輯 Oracle Data Warehouse 至 Amazon Redshift 轉換最佳化設定，請選擇**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中，選擇 **Oracle**，然後選擇 **Oracle – Amazon Redshift**。在左側窗格中，選擇**最佳化策略**。 AWS SCT 顯示 Oracle Data Warehouse 到 Amazon Redshift 轉換的轉換最佳化設定。
中的 Oracle Data Warehouse 到 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常用值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
# 使用 連線至 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_tw/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 => 65，535 且 =< 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 Redshift**。 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常出現之值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 針對**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。對於**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
# 使用 連線至 SQL Server Data Warehouse AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Microsoft SQL Server DW 轉換為 Amazon Redshift 或 Amazon Redshift，並結合 AWS Glue 使用。
## 做為來源的 Microsoft SQL Server Data Warehouse 權限
使用 Microsoft SQL Server 資料倉儲做為來源時，需要下列權限：
+ VIEW DEFINITION
+ VIEW DATABASE STATE
+ SELECT ON SCHEMA :: **
在上述範例中，將 ** 預留位置取代為 source\$1schema 的名稱。
對您要轉換其結構描述的每個資料庫重複授予。
此外，授予以下項目，並在主資料庫上執行授予：
+ VIEW SERVER STATE
## SQL Server Data Warehouse 做為來源的限制
目前不支援使用 Microsoft SQL Server Parallel Data Warehouse (PDW) 做為來源。
## 以來源身分連線至 SQL Server Data Warehouse
使用下列程序，透過 連線至 SQL Server Data Warehouse 來源資料庫 AWS Schema Conversion Tool。
**連線至 SQL Server Data Warehouse 來源資料庫**
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_tw/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServerDW.html)
1. 選擇**測試連線**以驗證 AWS SCT 可以連接到您的來源資料庫。
1. 選擇**連線**以連線至來源資料庫。
## SQL Server Data Warehouse 到 Amazon Redshift 轉換設定
若要將 SQL Server Data Warehouse 編輯為 Amazon Redshift 轉換設定，請選擇**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中選擇 **Microsoft SQL Server**，然後選擇 **Microsoft SQL Server – Amazon Redshift**。 AWS SCT 會顯示 SQL Server Data Warehouse 到 Amazon Redshift 轉換的所有可用設定。
中的 SQL Server Data Warehouse 到 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 Data Warehouse 到 Amazon Redshift 轉換最佳化設定
若要編輯 SQL Server Data Warehouse 至 Amazon Redshift 轉換最佳化設定，請選擇 中的**設定** AWS SCT，然後選擇**轉換設定**。從上方清單中選擇 **Microsoft SQL Server**，然後選擇 **Microsoft SQL Server – Amazon Redshift**。在左側窗格中，選擇**最佳化策略**。 AWS SCT 顯示 SQL Server Data Warehouse 到 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常見值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
# 使用 連線至 Teradata Data Warehouse AWS Schema Conversion Tool
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Teradata 轉換為 Amazon Redshift 或 Amazon Redshift，並結合 AWS Glue 使用。
## 做為來源的 Teradata 權限
使用 Teradata 做為來源時需要下列權限：
+ SELECT ON DBC
+ SELECT ON SYSUDTLIB
+ SELECT ON SYSLIB
+ SELECT ON **
+ CREATE PROCEDURE ON **
在上述範例中，將 ** 預留位置取代為來源資料庫的名稱。
AWS SCT 需要 CREATE PROCEDURE 權限，才能針對來源資料庫中的所有程序執行 HELP 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_tw/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;
```
如果您為 LDAP 使用者變更 Active Directory 中的使用者密碼，請在 LDAP 模式下連線至 Teradata 期間指定此新密碼。在 DEFAULT 模式中，您可以使用 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 專案中收集統計資料。或者，您可以使用基本 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 Redshift**。 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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數目上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常見值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發到每個節點。
# 將 AWS Schema Conversion Tool 連線至 Vertica 資料庫
您可以使用 AWS SCT 將結構描述、程式碼物件和應用程式程式碼從 Vertica 轉換為 Amazon Redshift。
## Vertica 做為來源的權限
使用 Vertica 做為來源時需要下列權限：
+ USAGE ON SCHEMA **
+ USAGE ON SCHEMA PUBLIC
+ SELECT ON ALL TABLES IN SCHEMA **
+ SELECT ON ALL SEQUENCES IN SCHEMA **
+ EXECUTE ON ALL FUNCTIONS IN SCHEMA **
+ EXECUTE ON PROCEDURE **
在上述範例中，取代預留位置，如下所示：
+ 將 *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_tw/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 遷移最佳實務為基礎。
您可以為**尋找小型資料表策略定義小型資料表**的大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其定義為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。
+ 設定策略詳細資訊。
除了定義每個最佳化策略的權重之外，您還可以設定最佳化設定。若要這麼做，請選擇**轉換最佳化**。
+ 針對**排序索引鍵資料欄限制**，輸入排序索引鍵中的資料欄數上限。
+ 對於**偏斜閾值**，輸入資料欄偏斜值的百分比 (0–100)。 AWS SCT 排除分佈索引鍵候選項目清單中的偏斜值大於閾值的資料欄。 將資料欄偏斜值 AWS SCT 定義為最常見值與記錄總數的百分比比率。
+ 對於**查詢歷史記錄表中的前 N 個查詢**，輸入要分析之最常用查詢的數目 (1–100)。
+ 對於**選取統計資料使用者**，選擇您要分析查詢統計資料的資料庫使用者。
此外，在**最佳化策略**索引標籤上，您可以定義尋找小型資料表策略的**小型資料表**大小。針對**最小資料表資料列計數**和**最大資料表資料列計數**，輸入資料表中的最小和最大資料列數，將其視為小型資料表。 會將`ALL`分佈樣式 AWS SCT 套用至小型資料表。在這種情況下，整個資料表的副本會分發給每個節點。