` verwendet.
Beispiele finden Sie in der folgenden Tabelle.
| Oracle-Anweisung | MySQL-Anweisung |
| --- | --- |
| 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;
|
# Migration von Oracle Database zu Amazon RDS for Oracle mit AWS Schema Conversion Tool
Bei der Migration von Oracle-Schema und -Code in Amazon RDS für Oracle sind einige Punkte zu beachten:
+ AWS SCT kann Verzeichnisobjekte zum Objektbaum hinzufügen. *Verzeichnisobjekte* sind logische Strukturen, die jeweils ein physisches Verzeichnis im Dateisystem des Servers darstellen. Sie können Verzeichnisobjekte mit Paketen, wie z. B. DBMS\$1LOB, UTL\$1FILE, DBMS\$1FILE\$1TRANSFER, dem DATAPUMP Dienstprogramm usw. verwenden.
+ AWS SCT unterstützt die Konvertierung von Oracle-Tablespaces in eine Amazon RDS for Oracle Oracle-DB-Instance. Oracle speichert Daten logisch in Tabellenräumen und physisch in Datendateien, die dem entsprechenden Tabellenraum zugeordnet sind. In Oracle können Sie einen Tabellenraum mit Datendateinamen erstellen. Amazon RDS unterstützt Oracle Managed Files (OMF) nur für Datendateien, Protokolldateien und Kontrolldateien. AWS SCT erstellt die benötigten Datendateien während der Konvertierung.
+ AWS SCT kann Rollen und Rechte auf Serverebene konvertieren. Die Oracle-Datenbank-Engine verwendet rollenbasierte Sicherheit. Eine Rolle ist eine Sammlung von Sonderrechten, die Sie einem Benutzer gewähren oder entziehen können. Eine vordefinierte Rolle in Amazon RDS mit den Namen DBA lässt normalerweise alle administrativen Sonderrechte in einer Oracle-Datenbank-Engine zu. Die folgenden Sonderrechte sind nicht für die Feedback-Schleifen-Rolle in einer Amazon RDS-DB-Instance verfügbar, welche die Oracle-Engine verwendet:
+ Ändern der Datenbank
+ Ändern des Systems
+ Erstellen eines Verzeichnisses
+ Gewähren von Sonderrechten
+ Gewähren einer Rolle
+ Erstellen eines externen Auftrags
Sie können alle anderen Berechtigungen für eine Amazon RDS for Oracle-Benutzerrolle, u. a. erweiterte Filterungs- und Spaltenberechtigungen, erteilen.
+ AWS SCT unterstützt die Konvertierung von Oracle-Jobs in Jobs, die auf Amazon RDS for Oracle ausgeführt werden können. Es gibt einige Einschränkungen für die Konvertierung, unter anderem:
+ Ausführbare Aufträge werden nicht unterstützt.
+ Die Einplanung von Aufträgen, die den ANYDATA-Datentyp als Argument verwenden, werden nicht unterstützt.
+ Oracle Real Application Clusters (RAC) One Node ist eine Option der Oracle Database Enterprise Edition, die mit Oracle Database 11g Release 2 eingeführt wurde. Amazon RDS for Oracle unterstützt die RAC-Funktion nicht. Verwenden Sie Amazon RDS Multi-AZ für Hochverfügbarkeit.
Bei einer Multi-AZ-Bereitstellung sorgt Amazon RDS für eine automatische Bereitstellung und Verwaltung eines synchronen Standby-Replikats in einer anderen Availability Zone. Die primäre DB-Instance wird über die Availability Zone synchron auf eine Standby-Replikation repliziert. Diese Funktion bietet Datenredundanz, verhindert I/O Einfrierungen und minimiert Latenzspitzen bei System-Backups.
+ Oracle Spatial stellt ein SQL-Schema und Funktionen bereit, die Speicherung, Abruf, Update und Abfrage von Sammlungen großer Datensätze in einer Oracle-Datenbank ermöglichen. Oracle Locator stellt Funktionalitäten zur Verfügung, die üblicherweise für die Unterstützung von Anwendungen auf Internet- und Wireless-Servicebasis sowie von GIS-Lösungen auf Partnerbasis erforderlich sind. Oracle Locator ist ein begrenzter Teilbereich von Oracle Spatial.
Um Oracle Spatial- und Oracle Locator-Funktionen verwenden zu können, fügen Sie die Option SPATIAL oder die Option LOCATOR (schließen sich gegenseitig aus) zur Optionsgruppe Ihrer DB-Instance hinzu.
Es gibt einige Voraussetzungen für die Verwendung von Oracle Spatial und Oracle Locator auf einer Amazon RDS for Oracle-DB-Instance:
+ Die Instanz sollte Oracle Enterprise Edition Version 12.1.0.2.v6 oder höher oder 11.2.0.4.v10 oder höher verwenden.
+ Die Instance sollte sich innerhalb einer Virtual Private Cloud (VPC) befinden.
+ Die Instance sollte die Version der DB-Instance-Klasse sein, die die Oracle-Funktion unterstützen kann. Beispiel: Oracle Spatial wird für die DB-Instance-Klassen db.m1.small, db.t1.micro, db.t2.micro und db.t2.small nicht unterstützt. [Weitere Informationen finden Sie unter DB-Instance-Klassenunterstützung für Oracle.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html#Oracle.Concepts.InstanceClasses)
+ Die Instance muss die Option „Auto Minor Version Upgrade“ (Upgrade einer Unterversion automatisch durchführen) aktiviert haben. Amazon RDS aktualisiert Ihre DB-Instance auf die neueste Oracle-PSU, falls Schwachstellen mit einem CVSS-Schweregrad von 9\$1 oder andere gemeldete Schwachstellen vorliegen. Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).
[Einstellungen für Oracle-DB-Instances](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ModifyInstance.Oracle.html#USER_ModifyInstance.Oracle.Settings).
+ Wenn Ihre DB-Instance Version 11.2.0.4.v10 oder höher ist, müssen Sie die XMLDB-Option installieren. Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).
Oracle XML [DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.XMLDB.html).
+ Sie sollten über eine Oracle Spatial-Lizenz von Oracle verfügen. Weitere Informationen finden Sie unter [Oracle Spatial and Graph](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph) in der Oracle-Dokumentation.
+ Data Guard ist in der Oracle Database Enterprise Edition enthalten. Verwenden Sie Amazon RDS Multi-AZ für Hochverfügbarkeit.
Bei einer Multi-AZ-Bereitstellung sorgt Amazon RDS für eine automatische Bereitstellung und Verwaltung eines synchronen Standby-Replikats in einer anderen Availability Zone. Die primäre DB-Instance wird über die Availability Zone synchron auf eine Standby-Replikation repliziert. Diese Funktion bietet Datenredundanz, verhindert I/O Einfrierungen und minimiert Latenzspitzen bei System-Backups.
+ AWS SCT unterstützt die Konvertierung von Oracle DBMS\$1SCHEDULER-Objekten bei der Migration zu Amazon RDS for Oracle. Der AWS SCT Bewertungsbericht gibt an, ob ein Zeitplanobjekt konvertiert werden kann. Weitere Informationen zur Verwendung von Zeitplanobjekten mit Amazon RDS finden Sie in der [Amazon RDS-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.System.html#Appendix.Oracle.CommonDBATasks.ModifyScheduler).
+ Für Umwandlungen von Oracle zu Amazon RDS wird DB Links unterstützt. Ein Datenbanklink ist ein Schemaobjekt in einer Datenbank, mit dessen Hilfe Sie auf Objekte in einer anderen Datenbank zugreifen können. Die andere Datenbank muss keine Oracle-Datenbank sein. Für den Zugriff auf andere als Oracle-Datenbanken müssen Sie jedoch Oracle Heterogeneous Services verwenden.
Sobald Sie einen Datenbank-Link erstellt haben, können Sie den Link in SQL-Anweisungen verwenden, um auf Tabellen, Ansichten und PL/SQL Objekte in der anderen Datenbank zu verweisen. Um einen Datenbank-Link zu verwenden, fügen Sie ihn `@dblink` an den Namen der Tabelle, Ansicht oder des PL/SQL Objekts an. Sie können eine Tabelle oder Ansicht in der anderen Datenbank mit der SELECT-Anweisung abfragen. Weitere Informationen zur Verwendung von Oracle-Datenbanklinks finden Sie in der [Oracle-Dokumentation](https://docs.oracle.com/cd/B28359_01/server.111/b28310/ds_concepts002.htm#ADMIN12083).
Weitere Informationen zur Verwendung von Datenbanklinks mit Amazon RDS finden Sie in der [Amazon RDS-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Database.html#Appendix.Oracle.CommonDBATasks.DBLinks).
+ Der AWS SCT Bewertungsbericht enthält Server-Metriken für die Konvertierung. Zu diesen Metriken über Ihre Oracle-Instance gehören:
+ Datenverarbeitungs- und Speicherkapazität der Ziel-DB-Instance.
+ Nicht unterstützte Oracle-Funktionen wie Real Application Clusters, die Amazon RDS nicht unterstützt.
+ Datenträger-Lese-/Schreib-Last
+ Durchschnittlicher Datenträger-Gesamtdurchsatz
+ Serverinformationen wie Servername, Betriebssystem, Hostname und Zeichensatz.
## Rechte für RDS für Oracle als Ziel
Um zu Amazon RDS for Oracle zu migrieren, erstellen Sie einen privilegierten Datenbankbenutzer. Sie können das folgende Codebeispiel verwenden.
```
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;
```
Ersetzen Sie es im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *your\$1password* durch ein sicheres Passwort.
## Einschränkungen bei der Konvertierung von Oracle zu Amazon RDS for Oracle
Bei der Migration von Oracle-Schema und -Code in Amazon RDS for Oracle sind einige Einschränkungen zu beachten:
+ Eine vordefinierte Rolle in Amazon RDS mit den Namen DBA lässt normalerweise alle administrativen Sonderrechte in einer Oracle-Datenbank-Engine zu. Die folgenden Sonderrechte sind nicht für die Feedback-Schleifen-Rolle in einer Amazon RDS-DB-Instance verfügbar, welche die Oracle-Engine verwendet:
+ Ändern der Datenbank
+ Ändern des Systems
+ Erstellen eines Verzeichnisses
+ Gewähren von Sonderrechten
+ Gewähren einer Rolle
+ Erstellen eines externen Auftrags
Sie können einer Oracle RDS-Benutzerrolle alle anderen Berechtigungen erteilen.
+ Amazon RDS for Oracle unterstützt traditionelle Prüfungen, detaillierte Prüfungen mit dem Paket DBMS\$1FGA und Oracle Unified Auditing.
+ Amazon RDS for Oracle unterstützt Change Data Capture (CDC) nicht. Um CDC während und nach einer Datenbankmigration durchzuführen, verwenden Sie. AWS Database Migration Service
# Herstellen einer Verbindung zu PostgreSQL-Datenbanken mit dem AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Datenbankcodeobjekte und Anwendungscode von PostgreSQL in die folgenden Ziele zu konvertieren:
+ Amazon RDS für MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS für PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
Weitere Informationen finden Sie in den folgenden Abschnitten:
**Topics**
+ [Rechte für PostgreSQL als Quelldatenbank](#CHAP_Source.PostgreSQL.Permissions)
+ [Verbindung zu PostgreSQL als Quelle herstellen](#CHAP_Source.PostgreSQL.Connecting)
+ [Rechte für MySQL als Zieldatenbank](#CHAP_Source.PostgreSQL.ConfigureMySQL)
## Rechte für PostgreSQL als Quelldatenbank
Die für PostgreSQL als Quelle erforderlichen Rechte lauten wie folgt:
+ STELLEN SIE EINE VERBINDUNG ZUR DATENBANK HER **
+ VERWENDUNG IM SCHEMA **
+ WÄHLEN SIE FÜR ALLE TABELLEN IM SCHEMA **
+ WÄHLEN SIE ALLE SEQUENZEN IM SCHEMA AUS **
## Verbindung zu PostgreSQL als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit dem AWS Schema Conversion Tool eine Verbindung zu Ihrer PostgreSQL-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer PostgreSQL-Quelldatenbank her**
1. Wählen Sie im die Option AWS Schema Conversion Tool Quelle **hinzufügen** aus.
1. **Wählen Sie **PostgreSQL** und dann Weiter.**
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen für die PostgreSQL-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.PostgreSQL.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Rechte für MySQL als Zieldatenbank
Die Rechte, die für MySQL als Ziel erforderlich sind, wenn Sie von PostgreSQL migrieren, lauten wie folgt:
+ ERSTELLEN AM \$1 . \$1
+ SPÄTER AM \$1 . \$1
+ VORBEIKOMMEN \$1 . \$1
+ INDEX AUF \$1 . \$1
+ REFERENZEN AUF \$1 . \$1
+ SELECT ON \$1.\$1
+ ANSICHT ERSTELLEN AUF \$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ AUSLÖSEN AM \$1 . \$1
+ ROUTINE ERSTELLEN AUF \$1 . \$1
+ ROUTINE ÄNDERN AUF \$1 . \$1
+ AUSFÜHREN AM \$1 . \$1
+ EINFÜGEN, AUF AWS\$1POSTGRESQL \$1EXT AKTUALISIEREN. \$1
+ EINFÜGEN, AKTUALISIEREN, LÖSCHEN AUF AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
+ ERSTELLEN SIE TEMPORÄRE TABELLEN AUF AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
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';
```
Ersetzen Sie es im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *your\$1password* durch ein sicheres Passwort.
Setzen Sie den Parameter `lower_case_table_names` auf `1`, um Amazon RDS für MySQL oder Aurora MySQL als Ziel zu verwenden. Dieser Wert bedeutet, dass der MySQL-Server Kennungen von Objektnamen wie Tabellen, Indizes, Auslösern und Datenbanken ohne Berücksichtigung der Groß- und Kleinschreibung behandelt. Wenn Sie die binäre Protokollierung in Ihrer Ziel-Instance aktiviert haben, setzen Sie den Parameter `log_bin_trust_function_creators` auf `1`. In diesem Fall müssen Sie die Eigenschaften `DETERMINISTIC`, `READS SQL DATA` oder `NO SQL` nicht verwenden, um gespeicherte Funktionen zu erstellen. Erstellen Sie zum Konfigurieren dieser Parameter eine neue DB-Parametergruppe oder ändern Sie eine vorhandene DB-Parametergruppe.
# Herstellen einer Verbindung zu SAP-Datenbanken mit dem AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Datenbankcodeobjekte und Anwendungscode aus SAP (Sybase) Adaptive Server Enterprise (ASE) in die folgenden Ziele zu konvertieren:
+ Amazon RDS für MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS für MariaDB
+ Amazon RDS für PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
Weitere Informationen finden Sie in den folgenden Abschnitten:
**Topics**
+ [Rechte für SAP ASE als Quelldatenbank](#CHAP_Source.SAP.Permissions)
+ [Verbindung zu SAP ASE (Sybase) als Quelle herstellen](#CHAP_Source.SAP.Connecting)
+ [Rechte für MySQL als Zieldatenbank](#CHAP_Source.SAP.ConfigureMySQL)
+ [Einstellungen für die Konvertierung von SAP ASE nach MySQL](#CHAP_Source.SAP.MySQLConversionSettings)
+ [Rechte für PostgreSQL als Zieldatenbank](#CHAP_Source.SAP.ConfigurePostgreSQL)
+ [Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL](#CHAP_Source.SAP.PostgreSQLConversionSettings)
## Rechte für SAP ASE als Quelldatenbank
Um eine SAP ASE-Datenbank als Quelle zu verwenden, erstellen Sie einen Datenbankbenutzer und gewähren Berechtigungen. Gehen Sie dazu wie folgt vor.
**Erstellen und konfigurieren Sie einen Datenbankbenutzer**
1. Stellt eine Verbindung zur Quelldatenbank her.
1. Erstellen Sie einen Datenbankbenutzer mit den folgenden Befehlen. Geben Sie ein Passwort für den neuen Benutzer ein.
```
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. Erteilen Sie für jede Datenbank, die Sie migrieren möchten, die folgenden Rechte.
```
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
```
## Verbindung zu SAP ASE (Sybase) als Quelle herstellen
Gehen Sie wie folgt vor, um eine Verbindung zu Ihrer SAP ASE-Quelldatenbank mit dem herzustellen AWS Schema Conversion Tool.
**So stellen Sie eine Verbindung zu einer SAP ASE-Quelldatenbank her**
1. Wählen Sie in der die AWS Schema Conversion Tool Option **Quelle hinzufügen** aus.
1. Wählen Sie **SAP ASE** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen zur SAP ASE-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SAP.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Rechte für MySQL als Zieldatenbank
Die für MySQL als Ziel erforderlichen Rechte lauten wie folgt:
+ ERSTELLEN AM \$1 . \$1
+ SPÄTER AM \$1 . \$1
+ VORBEIKOMMEN \$1 . \$1
+ INDEX AUF \$1 . \$1
+ REFERENZEN AUF \$1 . \$1
+ SELECT ON \$1.\$1
+ ANSICHT ERSTELLEN AUF \$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ AUSLÖSEN AM \$1 . \$1
+ ROUTINE ERSTELLEN AUF \$1 . \$1
+ ROUTINE ÄNDERN AUF \$1 . \$1
+ AUSFÜHREN AM \$1 . \$1
+ EINFÜGEN, AUF AWS\$1SAPASE \$1EXT AKTUALISIEREN. \$1
+ ERSTELLEN SIE TEMPORÄRE TABELLEN AUF AWS\$1SAPASE \$1EXT. \$1
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
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';
```
Ersetzen Sie es im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *your\$1password* durch ein sicheres Passwort.
Setzen Sie den Parameter `lower_case_table_names` auf `1`, um Amazon RDS für MySQL oder Aurora MySQL als Ziel zu verwenden. Dieser Wert bedeutet, dass der MySQL-Server Kennungen von Objektnamen wie Tabellen, Indizes, Auslösern und Datenbanken ohne Berücksichtigung der Groß- und Kleinschreibung behandelt. Wenn Sie die binäre Protokollierung in Ihrer Ziel-Instance aktiviert haben, setzen Sie den Parameter `log_bin_trust_function_creators` auf `1`. In diesem Fall müssen Sie die Eigenschaften `DETERMINISTIC`, `READS SQL DATA` oder `NO SQL` nicht verwenden, um gespeicherte Funktionen zu erstellen. Erstellen Sie zum Konfigurieren dieser Parameter eine neue DB-Parametergruppe oder ändern Sie eine vorhandene DB-Parametergruppe.
## Einstellungen für die Konvertierung von SAP ASE nach MySQL
Um die Einstellungen für die Konvertierung von SAP ASE in MySQL zu bearbeiten, wählen Sie **Einstellungen** und dann **Konvertierungseinstellungen**. Wählen Sie in der oberen Liste **SAP ASE** und dann **SAP ASE — MySQL** oder **SAP ASE — Amazon Aurora (MySQL-kompatibel)** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL an.
Die Einstellungen für die Konvertierung von SAP ASE in MySQL AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die exakten Namen der Quelldatenbankobjekte im konvertierten Code zu verwenden.
AWS SCT Konvertiert standardmäßig die Namen von Datenbankobjekten, Variablen und Parametern in Kleinbuchstaben. Um die ursprüngliche Groß- und Kleinschreibung für diese Namen beizubehalten, wählen Sie **Objektnamen der Quelldatenbank unter Berücksichtigung von Groß- und Kleinschreibung behandeln** aus. Wählen Sie diese Option, wenn Sie in Ihrem SAP ASE-Quelldatenbankserver Objektnamen verwenden, bei denen Groß- und Kleinschreibung beachtet wird.
## Rechte für PostgreSQL als Zieldatenbank
Um PostgreSQL als Ziel zu verwenden, ist das AWS SCT Privileg erforderlich. `CREATE ON DATABASE` Stellen Sie sicher, dass Sie dieses Recht für jede PostgreSQL-Zieldatenbank gewähren.
Um die konvertierten öffentlichen Synonyme zu verwenden, ändern Sie den Standardsuchpfad der Datenbank in. `"$user", public_synonyms, public`
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
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;
```
Ersetzen Sie ihn im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *db\$1name* durch den Namen Ihrer Zieldatenbank. Schließlich ersetzen Sie es *your\$1password* durch ein sicheres Passwort.
In PostgreSQL kann nur der Schemaeigentümer oder ein `superuser` ein Schema entfernen. Der Besitzer kann ein Schema und alle Objekte, die dieses Schema enthält, löschen, auch wenn der Eigentümer des Schemas einige seiner Objekte nicht besitzt.
Wenn Sie verschiedene Benutzer verwenden, um verschiedene Schemas zu konvertieren und auf Ihre Zieldatenbank anzuwenden, erhalten Sie möglicherweise eine Fehlermeldung, wenn ein Schema nicht gelöscht AWS SCT werden kann. Verwenden Sie die Rolle `superuser`, um diese Fehlermeldung zu vermeiden.
## Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL
Um die Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL zu bearbeiten, wählen Sie **Einstellungen** und dann **Konvertierungseinstellungen**. Wählen Sie in der oberen Liste **SAP ASE** und dann SAP ASE **— PostgreSQL oder SAP ASE —** **Amazon Aurora (PostgreSQL-kompatibel**) aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL an.
Die Einstellungen für die Konvertierung von SAP ASE nach PostgreSQL AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die Vorlage zu definieren, die für die Schemanamen im konvertierten Code verwendet werden soll. Wählen Sie für die **Vorlage zur Generierung von Schemanamen** eine der folgenden Optionen aus:
+ ****— Verwendet den SAP ASE-Datenbanknamen als Schemanamen in PostgreSQL.
+ ****— Verwendet den SAP ASE-Schemanamen als Schemanamen in PostgreSQL.
+ **\$1** — Verwendet eine Kombination aus der SAP ASE-Datenbank und Schemanamen als Schemanamen in PostgreSQL.
+ Um die exakten Namen der Quelldatenbankobjekte im konvertierten Code zu verwenden.
AWS SCT Konvertiert standardmäßig die Namen von Datenbankobjekten, Variablen und Parametern in Kleinbuchstaben. Um die ursprüngliche Groß- und Kleinschreibung für diese Namen beizubehalten, wählen Sie **Objektnamen der Quelldatenbank unter Berücksichtigung von Groß- und Kleinschreibung behandeln** aus. Wählen Sie diese Option, wenn Sie in Ihrem SAP ASE-Quelldatenbankserver Objektnamen verwenden, bei denen Groß- und Kleinschreibung beachtet wird.
Bei Operationen, bei denen die Groß- und Kleinschreibung beachtet wird, AWS SCT kann die Konvertierung von Datenbankobjektnamen in Kleinbuchstaben vermieden werden. Wählen Sie dazu bei Operationen, bei denen die Groß- und Kleinschreibung **beachtet wird, die Umwandlung in Kleinbuchstaben vermeiden** aus.
+ Um die Verwendung von Indizes mit demselben Namen in verschiedenen Tabellen in SAP ASE zu ermöglichen.
In PostgreSQL müssen alle Indexnamen, die Sie im Schema verwenden, eindeutig sein. Um sicherzustellen, dass dadurch eindeutige Namen für alle Ihre Indizes AWS SCT generiert werden, wählen Sie **Eindeutige Namen für Indizes generieren** aus.
# Connect Microsoft SQL Server mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Datenbankcode-Objekte und Anwendungscode aus SQL Server in die folgenden Ziele zu konvertieren:
+ Amazon RDS für MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS für PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
+ Amazon RDS für SQL Server
+ Amazon RDS für MariaDB
**Anmerkung**
AWS SCT unterstützt nicht die Verwendung von Amazon RDS for SQL Server als Quelle.
Sie können AWS SCT damit einen Bewertungsbericht für die Migration von Schemas, Datenbankcodeobjekten und Anwendungscode von SQL Server zu Babelfish for Aurora PostgreSQL erstellen, wie im Folgenden beschrieben.
**Topics**
+ [Berechtigungen für Microsoft SQL Server als Quelle](#CHAP_Source.SQLServer.Permissions)
+ [Verwenden der Windows-Authentifizierung bei Verwendung von Microsoft SQL Server als Quelle](#CHAP_Source.SQLServer.Permissions.WinAuth)
+ [Verbindung zu SQL Server als Quelle herstellen](#CHAP_Source.SQLServer.Connecting)
+ [Umwandeln von SQL Server in MySQL](CHAP_Source.SQLServer.ToMySQL.md)
+ [Migration von SQL Server zu PostgreSQL mit AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToPostgreSQL.md)
+ [Migration von SQL Server zu Amazon RDS for SQL Server mit AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToRDSSQLServer.md)
## Berechtigungen für Microsoft SQL Server als Quelle
Die für Microsoft SQL Server als Quelle erforderlichen Rechte lauten wie folgt:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Mit dieser `VIEW DEFINITION` Berechtigung können Benutzer mit öffentlichem Zugriff Objektdefinitionen einsehen. AWS SCT verwendet das `VIEW DATABASE STATE` Recht, um die Funktionen der SQL Server Enterprise Edition zu überprüfen.
Gewähren Sie die erforderlichen Berechtigungen für alle Datenbanken, deren Schemata Sie konvertieren.
Gewähren Sie außerdem die folgenden Berechtigungen für die Datenbank `master`:
+ VIEW SERVER STATE
+ VIEW ANY DEFINITION
AWS SCT verwendet das `VIEW SERVER STATE` Recht, Servereinstellungen und -konfigurationen zu sammeln. Stellen Sie sicher, dass Sie die `VIEW ANY DEFINITION` Berechtigung zum Anzeigen von Endpunkten gewähren.
Führen Sie den folgenden Befehl in der Datenbank `master` aus, um Informationen über Microsoft Analysis Services zu lesen.
```
EXEC master..sp_addsrvrolemember @loginame = N'', @rolename = N'sysadmin'
```
Ersetzen Sie im vorherigen Beispiel den `` Platzhalter durch den Namen des Benutzers, dem Sie zuvor die Berechtigungen erteilt haben.
Um Informationen über den SQL Server-Agent zu lesen, fügen Sie Ihren Benutzer zur `SQLAgentUser` Rolle hinzu. Führen Sie den folgenden Befehl für die Datenbank `msdb` aus.
```
EXEC sp_addrolemember , ;
```
Ersetzen Sie im vorherigen Beispiel den Platzhalter `` durch den Namen der SQL-Server-Agent-Rolle. Ersetzen Sie dann den `` Platzhalter durch den Namen des Benutzers, dem Sie zuvor die Berechtigungen erteilt haben. Weitere Informationen finden Sie unter [Hinzufügen eines Benutzers zur SQLAgent Benutzerrolle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.Agent.html#SQLServerAgent.AddUser) im *Amazon RDS-Benutzerhandbuch*.
Gewähren Sie die Berechtigung `SELECT on dbo.log_shipping_primary_databases` für die Datenbank `msdb`, um den Versand von Protokollen zu erkennen.
Um den Benachrichtigungsansatz der DDL-Replikation zu verwenden, gewähren Sie die entsprechenden `RECEIVE ON .` Rechte für Ihre Quelldatenbanken. Ersetzen Sie in diesem Beispiel den Platzhalter `` durch den Schemanamen Ihrer Datenbank. Ersetzen Sie dann den Platzhalter `` durch den Namen einer Warteschlangen-Tabelle.
## Verwenden der Windows-Authentifizierung bei Verwendung von Microsoft SQL Server als Quelle
Wenn Ihre Anwendung auf einem Windows-basierten Intranet ausgeführt wird, können Sie möglicherweise die Windows-Authentifizierung für den Zugriff auf die Datenbank verwenden. Die Windows-Authentifizierung verwendet die aktuelle Windows-Identität auf der Betriebssystem-Thread für den Zugriff auf die SQL Server-Datenbank. Sie können dann die Windows-Identität auf eine SQL Server-Datenbank und Berechtigungen abbilden. Zum Herstellen einer Verbindung mit SQL Server unter Verwendung der Windows-Authentifizierung müssen Sie die Windows-Identität angeben, die Ihre Anwendung verwendet. Außerdem müssen Sie der Windows-Identität Zugriff auf die SQL Server-Datenbank erteilen.
SQL Server verfügt über zwei Zugriffsmodi: Windows-Authentifizierung-Modus und gemischter Modus. Der Windows-Authentifizierung-Modus aktiviert die Windows-Authentifizierung und deaktiviert die SQL Server-Authentifizierung. Der gemischte Modus aktiviert die Windows-Authentifizierung und die SQL Server-Authentifizierung. Die Windows-Authentifizierung ist immer verfügbar und kann nicht deaktiviert werden. Weitere Informationen über die Windows-Authentifizierung finden Sie in der Microsoft Windows-Dokumentation.
Nachfolgend finden Sie ein Beispiel für das Erstellen eines Benutzers in TEST\$1DB.
```
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
```
### Verwenden der Windows-Authentifizierung mit einer JDBC-Verbindung
Der JDBC-Treiber unterstützt keine Windows-Authentifizierung, wenn der Treiber für Nicht-Windows-Betriebssysteme verwendet wird. Anmeldeinformationen für die Windows-Authentifizierung, wie z. B. Benutzername und Kennwort, werden nicht automatisch angegeben, wenn von einem anderen Betriebssystem als Windows aus eine Verbindung zu SQL Server hergestellt wird. In solchen Fällen müssen die Anwendungen stattdessen die SQL Server-Authentifizierung verwenden.
In der JDBC-Verbindungszeichenfolge, muss der Parameter `integratedSecurity` angegeben werden, um eine Verbindung unter Verwendung der Windows-Authentifizierung herzustellen. Der JDBC-Treiber unterstützt die integrierte Windows-Authentifizierung auf Windows-Betriebssysteme über den `integratedSecurity`-Verbindungszeichenfolgenparameter.
Verwendung der integrierten Authentifizierung
1. Installieren Sie den JDBC-Treiber.
1. Kopieren Sie die `sqljdbc_auth.dll`-Datei in ein Verzeichnis im Windows-Systempfad auf dem Computer, auf dem der JDBC-Treiber installiert ist.
Die `sqljdbc_auth.dll` Dateien werden am folgenden Speicherort installiert:
<*Installationsverzeichnis*>\$1sqljdbc\$1<*version*>\$1<*language*>\$1auth\$1
Wenn Sie versuchen, eine Verbindung zu SQL Server-Datenbank unter Verwendung der Windows-Authentifizierung herzustellen, ist es möglich, dass der folgende Fehler auftritt: Dieser Treiber ist nicht für die integrierte Authentifizierung konfiguriert. Dieses Problem kann gelöst werden, indem Sie die folgenden Aktionen ausführen:
+ Deklarieren Sie zwei Variablen, die auf den installierten Pfad Ihres JDBC verweisen:
`variable name: SQLJDBC_HOME; variable value: D:\lib\JDBC4.1\enu`(wo Ihre sqljdbc4.jar existiert);
`variable name: SQLJDBC_AUTH_HOME; variable value: D\lib\JDBC4.1\enu\auth\x86`(wenn Sie ein 32-Bit-Betriebssystem verwenden) oder `D\lib\JDBC4.1\enu\auth\x64` (wenn Sie ein 64-Bit-Betriebssystem verwenden). Hier befindet sich Ihr`sqljdbc_auth.dll`.
+ Kopieren `sqljdbc_auth.dll` Sie in den Ordner, in dem Ihr JDK/JRE läuft. Sie können in den lib-Ordner, in den bin-Ordner usw. kopieren. Beispielsweise können Sie in den folgenden Ordner kopieren.
```
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
```
+ Stellen Sie sicher, dass Sie in Ihrem JDBC-Bibliotheksordner nur die SQLJDBC4 JAR-Datei haben. Entfernen Sie alle anderen sqljdbc\$1.jar-Dateien aus diesem Ordner (oder kopieren Sie sie in einen anderen Ordner). Wenn Sie den Treiber als Teil Ihres Programms hinzufügen, stellen Sie sicher, dass Sie nur SQLJDBC4 .jar als zu verwendenden Treiber hinzufügen.
+ Kopieren Sie die sqljdbc\$1auth.dll-Datei in den Ordner mit Ihrer Anwendung.
**Anmerkung**
Wenn Sie eine 32-Bit-JVM (Java Virtual Machine) ausführen, verwenden Sie die sqljdbc\$1auth.dll-Datei im Ordner x86, auch wenn das Betriebssystem die x64-Version ist. Wenn Sie eine 64-Bit-JVM auf einem x64-Prozessor ausführen, verwenden Sie die sqljdbc\$1auth.dll-Datei im Ordner x64.
Wenn Sie eine Verbindung zu einer SQL Server-Datenbank herstellen, können Sie entweder **Windows Authentication (Windows-Authentifizierung)** oder **SQL Server Authentication (SQL Server-Authentifizierung)** für die Option **Authentication (Authentifizierung)** verwenden.
## Verbindung zu SQL Server als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit dem AWS Schema Conversion Tool eine Verbindung zu Ihrer Microsoft SQL Server-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer Microsoft SQL Server-Quelldatenbank her**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen** aus.
1. Wählen Sie **Microsoft SQL Server** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen zur Microsoft SQL Server-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
# Umwandeln von SQL Server in MySQL
Verwenden Sie das Erweiterungspaket SQL Server to MySQL, um Microsoft SQL Server-Datenbankfunktionen in Ihrem konvertierten MySQL-Code zu emulieren. AWS SCT Weitere Informationen zu Erweiterungspaketen finden Sie unter [Verwenden von Erweiterungspaketen mit AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Rechte für MySQL als Zieldatenbank](#CHAP_Source.SQLServer.ToMySQL.ConfigureTarget)
+ [Einstellungen für die Konvertierung von SQL Server in MySQL](#CHAP_Source.SQLServer.ToMySQL.ConversionSettings)
+ [Überlegungen zur Migration](#CHAP_Source.SQLServer.ToMySQL.MigrationConsiderations)
## Rechte für MySQL als Zieldatenbank
Die für MySQL als Ziel erforderlichen Rechte lauten wie folgt:
+ ERSTELLEN AM \$1 . \$1
+ SPÄTER AM \$1 . \$1
+ VORBEIKOMMEN \$1 . \$1
+ INDEX AUF \$1 . \$1
+ REFERENZEN AUF \$1 . \$1
+ SELECT ON \$1.\$1
+ ANSICHT ERSTELLEN AUF \$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ AUSLÖSEN AM \$1 . \$1
+ ROUTINE ERSTELLEN AUF \$1 . \$1
+ ROUTINE ÄNDERN AUF \$1 . \$1
+ AUSFÜHREN AM \$1 . \$1
+ EINFÜGEN, AUF AWS\$1SQLSERVER \$1EXT AKTUALISIEREN. \$1
+ EINFÜGEN, AKTUALISIEREN, LÖSCHEN AUF AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
+ ERSTELLEN SIE TEMPORÄRE TABELLEN AUF AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
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';
```
Ersetzen Sie es im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *your\$1password* durch ein sicheres Passwort.
Wenn Sie eine MySQL-Datenbank Version 5.7 oder niedriger als Ziel verwenden, führen Sie den folgenden Befehl aus. Für MySQL-Datenbanken der Version 8.0 und höher ist dieser Befehl veraltet.
```
GRANT SELECT ON mysql.proc TO 'user_name';
```
Setzen Sie den Parameter `lower_case_table_names` auf `1`, um Amazon RDS für MySQL oder Aurora MySQL als Ziel zu verwenden. Dieser Wert bedeutet, dass der MySQL-Server Kennungen von Objektnamen wie Tabellen, Indizes, Auslösern und Datenbanken ohne Berücksichtigung der Groß- und Kleinschreibung behandelt. Wenn Sie die binäre Protokollierung in Ihrer Ziel-Instance aktiviert haben, setzen Sie den Parameter `log_bin_trust_function_creators` auf `1`. In diesem Fall müssen Sie die Eigenschaften `DETERMINISTIC`, `READS SQL DATA` oder `NO SQL` nicht verwenden, um gespeicherte Funktionen zu erstellen. Erstellen Sie zum Konfigurieren dieser Parameter eine neue DB-Parametergruppe oder ändern Sie eine vorhandene DB-Parametergruppe.
## Einstellungen für die Konvertierung von SQL Server in MySQL
Um die Einstellungen für die Konvertierung von SQL Server in MySQL zu bearbeiten, AWS SCT wählen Sie **Einstellungen** und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **SQL Server** und dann **SQL Server — MySQL** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SQL Server zu MySQL an.
Die Einstellungen für die Konvertierung von SQL Server in MySQL AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Damit Ihre SQL Server-Quelldatenbank die Ausgabe von `EXEC` in einer Tabelle speichern kann. AWS SCT erstellt temporäre Tabellen und ein zusätzliches Verfahren, um diese Funktion zu emulieren. Um diese Emulation zu verwenden, wählen Sie **Zusätzliche Routinen für den Umgang mit offenen Datensätzen erstellen** aus.
## Überlegungen zur Migration
Beachten Sie bei der Migration eines SQL Server-Schemas zu MySQL die folgenden Punkte:
+ MySQL unterstützt die `MERGE` Anweisung nicht. AWS SCT Kann die `MERGE` Anweisung jedoch während der Konvertierung emulieren, indem es die `INSERT ON DUPLICATE KEY` Klausel und die `UPDATE FROM and DELETE FROM` Anweisungen verwendet.
Stellen Sie für eine korrekte Verwendung der Emulation sicher`INSERT ON DUPLICATE KEY`, dass in der MySQL-Zieldatenbank eine eindeutige Einschränkung oder ein eindeutiger Primärschlüssel vorhanden ist.
+ Sie können eine `GOTO` Anweisung und ein Label verwenden, um die Reihenfolge zu ändern, in der Anweisungen ausgeführt werden. Alle Transact-SQL-Anweisungen, die auf eine `GOTO` Anweisung folgen, werden übersprungen, und die Verarbeitung wird an der Bezeichnung fortgesetzt. Sie können `GOTO` Anweisungen und Labels an einer beliebigen Stelle innerhalb einer Prozedur, eines Batches oder eines Anweisungsblocks verwenden. Sie können `GOTO` Anweisungen auch verschachteln.
MySQL verwendet keine `GOTO` Anweisungen. Wenn Code AWS SCT konvertiert wird, der eine `GOTO` Anweisung enthält, wird die Anweisung so konvertiert, dass sie eine `BEGIN…END` `LOOP…END LOOP` OR-Anweisung verwendet. In der folgenden Tabelle finden Sie Beispiele dafür, wie `GOTO` Anweisungen AWS SCT konvertiert werden.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL unterstützt keine Tabellenwertfunktionen mit mehreren Anweisungen. AWS SCT simuliert Tabellenwertfunktionen während einer Konvertierung, indem temporäre Tabellen erstellt und Anweisungen so umgeschrieben werden, dass sie diese temporären Tabellen verwenden.
# Migration von SQL Server zu PostgreSQL mit AWS Schema Conversion Tool
Sie können das Erweiterungspaket SQL Server to PostgreSQL in verwenden. AWS SCT Dieses Erweiterungspaket emuliert SQL Server-Datenbankfunktionen im konvertierten PostgreSQL-Code. Verwenden Sie das Erweiterungspaket SQL Server to PostgreSQL, um SQL Server Agent und SQL Server Database Mail zu emulieren. Weitere Informationen zu Erweiterungspaketen finden Sie unter [Verwenden von Erweiterungspaketen mit AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Rechte für PostgreSQL als Zieldatenbank](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [Einstellungen für die Konvertierung von SQL Server in PostgreSQL](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [Konvertieren von SQL Server-Partitionen in PostgreSQL Version 10-Partitionen](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [Überlegungen zur Migration](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [Verwenden eines AWS SCT Erweiterungspakets zum Emulieren des SQL Server-Agents in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [Verwenden eines AWS SCT Erweiterungspakets zum Emulieren von SQL Server-Datenbank-Mail in PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## Rechte für PostgreSQL als Zieldatenbank
Um PostgreSQL als Ziel zu verwenden, ist das AWS SCT Privileg erforderlich. `CREATE ON DATABASE` Stellen Sie sicher, dass Sie dieses Recht für jede PostgreSQL-Zieldatenbank gewähren.
Um die konvertierten öffentlichen Synonyme zu verwenden, ändern Sie den Standardsuchpfad der Datenbank in. `"$user", public_synonyms, public`
Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.
```
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;
```
Ersetzen Sie ihn im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *db\$1name* durch den Namen Ihrer Zieldatenbank. Schließlich ersetzen Sie es *your\$1password* durch ein sicheres Passwort.
In PostgreSQL kann nur der Schemaeigentümer oder ein `superuser` ein Schema entfernen. Der Besitzer kann ein Schema und alle Objekte, die dieses Schema enthält, löschen, auch wenn der Eigentümer des Schemas einige seiner Objekte nicht besitzt.
Wenn Sie verschiedene Benutzer verwenden, um verschiedene Schemas zu konvertieren und auf Ihre Zieldatenbank anzuwenden, erhalten Sie möglicherweise eine Fehlermeldung, wenn ein Schema nicht gelöscht AWS SCT werden kann. Verwenden Sie die Rolle `superuser`, um diese Fehlermeldung zu vermeiden.
## Einstellungen für die Konvertierung von SQL Server in PostgreSQL
Um die Einstellungen für die Konvertierung von SQL Server in PostgreSQL zu bearbeiten, wählen Sie **Einstellungen** und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **SQL Server** und dann **SQL Server — PostgreSQL** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SQL Server zu PostgreSQL an.
Die Einstellungen für die Konvertierung von SQL Server in PostgreSQL AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die Verwendung von Indizes mit demselben Namen in verschiedenen Tabellen in SQL Server zu ermöglichen.
In PostgreSQL müssen alle Indexnamen, die Sie im Schema verwenden, eindeutig sein. Um sicherzustellen, dass dadurch eindeutige Namen für alle Ihre Indizes AWS SCT generiert werden, wählen Sie **Eindeutige Namen für Indizes generieren** aus.
+ Um SQL Server-Prozeduren in PostgreSQL-Funktionen zu konvertieren.
PostgreSQL Version 10 und früher unterstützt keine Prozeduren. Kunden, die mit der Verwendung von Prozeduren in PostgreSQL nicht vertraut sind, AWS SCT können Prozeduren in Funktionen konvertieren. Wählen Sie dazu **Verfahren in Funktionen konvertieren** aus.
+ Um die Ausgabe von `EXEC` in einer Tabelle zu emulieren.
Ihre SQL Server-Quelldatenbank kann die Ausgabe von `EXEC` in einer Tabelle speichern. AWS SCT erstellt temporäre Tabellen und eine zusätzliche Prozedur, um diese Funktion zu emulieren. Um diese Emulation zu verwenden, wählen Sie **Zusätzliche Routinen für den Umgang mit offenen Datensätzen erstellen** aus.
+ Um die Vorlage zu definieren, die für die Schemanamen im konvertierten Code verwendet werden soll. Wählen Sie für die **Vorlage zur Generierung von Schemanamen** eine der folgenden Optionen aus:
+ ****— Verwendet den SQL Server-Datenbanknamen als Schemanamen in PostgreSQL.
+ ****— Verwendet den SQL Server-Schemanamen als Schemanamen in PostgreSQL.
+ **\$1** — Verwendet eine Kombination aus der SQL Server-Datenbank und Schemanamen als Schemanamen in PostgreSQL.
+ Um die Groß- und Kleinschreibung Ihrer Quellobjektnamen beizubehalten.
Um zu verhindern, dass Objektnamen in Kleinbuchstaben umgewandelt werden, wählen Sie bei **Operationen, bei denen Groß- und Kleinschreibung beachtet wird, die Option Kleinschreibung vermeiden** aus. Diese Option gilt nur, wenn Sie die Option zur Berücksichtigung von Groß- und Kleinschreibung in Ihrer Zieldatenbank aktivieren.
+ Um die Parameternamen aus Ihrer Quelldatenbank beizubehalten.
Um den Namen der Parameter im konvertierten Code doppelte Anführungszeichen hinzuzufügen, wählen Sie **Ursprüngliche Parameternamen beibehalten** aus.
## Konvertieren von SQL Server-Partitionen in PostgreSQL Version 10-Partitionen
Beachten Sie Folgendes, wenn Sie eine Microsoft SQL Server-Datenbank in Amazon Aurora PostgreSQL-Compatible Edition (Aurora PostgreSQL) oder Amazon Relational Database Service for PostgreSQL (Amazon RDS for PostgreSQL) konvertieren.
In SQL Server können Sie Partitionen mit Partitionsfunktionen erstellen. Bei der Umwandlung einer partitionierten SQL Server-Tabelle in eine partitionierte PostgreSQL Version 10-Tabelle sind die folgenden potenziellen Probleme zu beachten:
+ SQL Server ermöglicht es Ihnen, eine Tabelle mit einer Spalte ohne NOT NULL-Einschränkung zu partitionieren. In diesem Fall werden alle NULL-Werte in die ganz links befindliche Partition verschoben. PostgreSQL unterstützt keine NULL-Werte für RANGE-Partitionierungen.
+ SQL Server ermöglicht Ihnen die Erstellung primärer und eindeutiger Schlüssel für partitionierte Tabellen. Sie erstellen für PostgreSQL primäre oder eindeutige Schlüssel direkt für jede Partition. Daher muss bei einer Migration in PostgreSQL die PRIMARY KEY- oder UNIQUE KEY-Einschränkung von ihrer übergeordneten Tabelle entfernt werden. Die `_` resultierenden Schlüsselnamen haben das folgende Format.
+ SQL Server ermöglicht Ihnen die Erstellung von Einschränkungen für Fremdschlüsselverweise aus und in partitionierte Tabellen. PostgreSQL unterstützt keine Fremdschlüssel, die auf partitionierte Tabellen verweisen. PostgreSQL unterstützt auch keine Fremdschlüsselverweise aus einer partitionierten Tabelle in eine andere Tabelle.
+ SQL Server ermöglicht Ihnen die Erstellung von Indizes für partitionierte Tabellen. Für PostgreSQL sollte für jede Partition direkt ein Index erstellt werden. Folglich müssen Indizes bei der Migration in PostgreSQL aus den ihnen übergeordneten Tabellen entfernt werden. Die sich ergebenden Indexnamen weisen das Format `_` auf.
+ PostgreSQL unterstützt keine partitionierten Indizes.
## Überlegungen zur Migration
Einige Dinge, die Sie bei der Migration eines SQL Server-Schemas nach PostgreSQL beachten sollten:
+ In PostgreSQL müssen alle Objektnamen in einem Schema eindeutig sein. Dies gilt auch für Indizes. Indexnamen müssen im Schema der Basistabelle eindeutig sein. In SQL Server kann ein Indexname für verschiedene Tabellen gleich sein.
Um die Eindeutigkeit von Indexnamen zu gewährleisten, AWS SCT haben Sie die Möglichkeit, eindeutige Indexnamen zu generieren, falls Ihre Indexnamen nicht eindeutig sind. Wählen Sie hierzu die Option **Generate unique index names (Eindeutige Indexnamen generieren)** in den Projekteigenschaften. Diese Funktion ist standardmäßig aktiviert. Wenn diese Option aktiviert ist, werden eindeutige Indexnamen im Format IX\$1table\$1name\$1index\$1name erstellt. Wenn diese Option deaktiviert ist, werden Indexnamen nicht geändert.
+ Mithilfe einer GOTO-Anweisung und einer Bezeichnung lässt sich die Reihenfolge ändern, in der Anweisungen ausgeführt werden. Alle Transact-SQL-Anweisungen, die auf eine GOTO-Anweisung folgen, werden übersprungen, und die Verarbeitung wird ab der Bezeichnung fortgesetzt. GOTO-Anweisungen und Bezeichnungen können an beliebiger Stelle innerhalb eines Verfahrens, Stapels oder Anweisungsblocks verwendet werden. GOTO-Anweisungen können auch verschachtelt werden.
PostgreSQL verwendet keine GOTO-Anweisungen. Wenn Code AWS SCT konvertiert wird, der eine GOTO-Anweisung enthält, wird die Anweisung so konvertiert, dass sie eine BEGIN... END- oder LOOP... END LOOP-Anweisung verwendet. In der folgenden Tabelle finden Sie Beispiele dafür, wie GOTO-Anweisungen AWS SCT konvertiert werden.
**SQL Server GOTO-Anweisungen und die konvertierten PostgreSQL-Anweisungen**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL unterstützt keine MERGE-Anweisung. AWS SCT emuliert das Verhalten einer MERGE-Anweisung auf folgende Weise:
+ Durch INSERT ON CONFLICT-Konstruktion.
+ Durch die Verwendung der UPDATE FROM DML-Anweisung, wie z. B. MERGE ohne WHEN NOT MATCHED-Klausel.
+ Durch die Verwendung von CURSOR, z. B. mit einer MERGE-Anweisung mit DELETE-Klausel, oder durch die Verwendung einer komplexen MERGE ON-Bedingungsanweisung.
+ AWS SCT kann Datenbank-Trigger zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ AWS SCT kann Trigger auf Serverebene zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ SQL Server erstellt `deleted` und verwaltet automatisch `inserted` Tabellen. Sie können diese temporären, speicherresidenten Tabellen verwenden, um die Auswirkungen bestimmter Datenänderungen zu testen und Bedingungen für DML-Triggeraktionen festzulegen. AWS SCT kann die Verwendung dieser Tabellen innerhalb von DML-Triggeranweisungen konvertieren.
+ AWS SCT kann verknüpfte Server zum Objektbaum hinzufügen, wenn Amazon RDS das Ziel ist.
+ Bei der Migration von Microsoft SQL Server zu PostgreSQL wird die integrierte SUSER\$1SNAME-Funktion wie folgt umgewandelt:
+ SUSER\$1SNAME – Gibt den Anmeldenamen zurück, der einer Sicherheits-ID (SID) zugeordnet ist.
+ SUSER\$1SNAME() – Nicht unterstützt.
+ SUSER\$1SNAME() CURRENT\$1USER – Gibt den Benutzernamen des aktuellen Ausführungskontexts zurück.
+ SUSER\$1SNAME(NULL) – Gibt NULL zurück.
+ Die Umwandlung von Tabellenwertfunktionen wird unterstützt. Tabellenwertfunktionen geben eine Tabelle zurück und können in einer Abfrage die Stelle einer Tabelle einnehmen.
+ PATINDEX gibt die Startposition des ersten Auftretens eines Musters in einem bestimmten Ausdruck zurück. Dabei werden alle gültigen Text und Zeichendatentypen unterstützt. Nullen werden zurückgegeben, wenn das Muster nicht gefunden wird. AWS SCT Ersetzt bei der Konvertierung von SQL Server zu Amazon RDS for PostgreSQL den Anwendungscode, der PATINDEX verwendet, durch aws\$1sqlserver\$1ext.patindex (,).
+ In SQL Server ist ein benutzerdefinierter Tabellentyp ein Typ, der die Definition einer Tabellenstruktur darstellt. Sie verwenden einen benutzerdefinierten Tabellentyp, um table-value-Parameter für gespeicherte Prozeduren oder Funktionen zu deklarieren. Sie können auch einen benutzerdefinierten Tabellentyp verwenden, um Tabellenvariablen zu deklarieren, die Sie in einem Batch oder im Hauptteil einer gespeicherten Prozedur oder Funktion verwenden möchten. AWS SCT emulierte diesen Typ in PostgreSQL, indem eine temporäre Tabelle erstellt wurde.
AWS SCT Konvertiert bei der Konvertierung von SQL Server nach PostgreSQL SQL Server-Systemobjekte in erkennbare Objekte in PostgreSQL. Die folgende Tabelle zeigt, wie die Systemobjekte umgewandelt werden.
| Anwendungsfälle für MS SQL Server | PostgreSQL-Substitution |
| --- | --- |
| SYS.SCHEMAS | AWS\$1SQLSERVER\$1EXT.SYS\$1SCHEMAS |
| SYS.TABLES | AWS\$1SQLSERVER\$1EXT.SYS\$1TABELLEN |
| SYS.VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ANSICHTEN |
| SYS.ALL\$1VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1ANSICHTEN |
| SYS.TYPES | AWS\$1SQLSERVER\$1EXT.SYS\$1TYPEN |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1SPALTEN |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1SPALTEN |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FREMDSCHLÜSSEL |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYS FREMDSCHLÜSSEL |
| 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\$1PROZEDUREN |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1INDIZES |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXE |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJECTS |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALLE\$1OBJEKTE |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJEKTE |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULE |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1DATENBANKEN |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SCHEMATA |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1ANSICHTEN |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABELLEN |
| 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\$1ROUTINEN |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSPROZESSE |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSTEM\$1OBJECTS |
# Verwenden eines AWS SCT Erweiterungspakets zum Emulieren des SQL Server-Agents in PostgreSQL
SQL Server Agent ist ein Microsoft Windows-Dienst, der SQL Server-Jobs ausführt. Der SQL Server-Agent führt Jobs nach einem Zeitplan, als Reaktion auf ein bestimmtes Ereignis oder bei Bedarf aus. Weitere Informationen zum SQL Server-Agent finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15).
PostgreSQL hat kein Äquivalent für SQL Server Agent. AWS SCT Erstellt ein Erweiterungspaket, um die Funktionen des SQL Server-Agents zu emulieren. Dieses Erweiterungspaket verwendet AWS Lambda Amazon CloudWatch. AWS Lambda implementiert die Schnittstelle, die Sie zum Verwalten von Zeitplänen und zum Ausführen von Jobs verwenden. Amazon CloudWatch hält die Zeitplanregeln ein.
AWS Lambda und Amazon CloudWatch verwendet einen JSON-Parameter für die Interaktion. Dieser JSON-Parameter hat die folgende Struktur.
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
Im vorherigen Beispiel *`mode`* ist dies der Typ der Aufgabe und `list of parameters` besteht aus einer Reihe von Parametern, die vom Typ der Aufgabe abhängen. Dies `procedure name` ist auch der Name der Prozedur, die nach Abschluss der Aufgabe ausgeführt wird.
AWS SCT verwendet eine Lambda-Funktion zur Steuerung und Ausführung von Jobs. Die CloudWatch Regel startet die Ausführung des Jobs und stellt die erforderlichen Informationen zum Starten des Jobs bereit. Wenn die CloudWatch Regel ausgelöst wird, startet sie die Lambda-Funktion mit den Parametern aus der Regel.
Verwenden Sie das folgende Format, um einen einfachen Job zu erstellen, der eine Prozedur aufruft.
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
Verwenden Sie das folgende Format, um einen Job mit mehreren Schritten zu erstellen.
```
{
"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
},
...
]
}
```
Um das Verhalten des SQL Server-Agents in PostgreSQL zu emulieren, erstellt das AWS SCT Erweiterungspaket auch die folgenden Tabellen und Prozeduren.
## Tabellen, die den SQL Server-Agent in PostgreSQL emulieren
Um den SQL Server-Agent zu emulieren, verwendet das Erweiterungspaket die folgenden Tabellen:
**sysjobs**
Speichert die Informationen über die Jobs.
**sysjobsteps**
Speichert die Informationen über die Schritte eines Jobs.
**Sysschedules**
Speichert die Informationen über die Jobpläne.
**sysjobschedules**
Speichert die Zeitplaninformationen für einzelne Jobs.
**sysjobhistory**
Speichert die Informationen über die Ausführung von geplanten Aufträgen.
## Verfahren, die den SQL Server-Agent in PostgreSQL emulieren
Um den SQL Server-Agent zu emulieren, verwendet das Erweiterungspaket die folgenden Verfahren:
**sp\$1add\$1job**
Fügt einen neuen Job hinzu.
**sp\$1add\$1jobstep**
Fügt einem Job einen Schritt hinzu.
**sp\$1add\$1schedule**
Erstellt eine neue Zeitplanregel in Amazon CloudWatch. Sie können diesen Zeitplan für eine beliebige Anzahl von Jobs verwenden.
**sp\$1attach\$1schedule**
Legt einen Zeitplan für den ausgewählten Job fest.
**sp\$1add\$1jobschedule**
Erstellt eine Zeitplanregel für einen Job in Amazon CloudWatch und legt das Ziel für diese Regel fest.
**sp\$1update\$1job**
Aktualisiert die Attribute des zuvor erstellten Jobs.
**sp\$1update\$1jobstep**
Aktualisiert die Attribute des Schritts in einem Job.
**sp\$1update\$1schedule**
Aktualisiert die Attribute einer Zeitplanregel in Amazon CloudWatch.
**sp\$1update\$1jobschedule**
Aktualisiert die Attribute des Zeitplans für den angegebenen Job.
**sp\$1delete\$1job**
Löscht einen Job.
**sp\$1delete\$1jobstep**
Löscht einen Auftragsschritt aus einem Job.
**sp\$1delete\$1schedule**
Löscht einen Zeitplan.
**sp\$1delete\$1jobschedule**
Löscht die Zeitplanregel für den angegebenen Job von Amazon CloudWatch.
**sp\$1detach\$1schedule**
Entfernt eine Verknüpfung zwischen einem Zeitplan und einem Job.
**get\$1jobs, update\$1job**
Interne Verfahren, die interagieren mit. 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**
Interne Verfahren, die Einstellungen überprüfen.
## Syntax für Prozeduren, die den SQL Server-Agent in PostgreSQL emulieren
Die `aws_sqlserver_ext.sp_add_job` Prozedur im Erweiterungspaket emuliert die Prozedur. `msdb.dbo.sp_add_job` Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_jobstep` Prozedur emuliert die `msdb.dbo.sp_add_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_schedule` Prozedur emuliert die `msdb.dbo.sp_add_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_attach_schedule` Prozedur emuliert die `msdb.dbo.sp_attach_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_add_jobschedule` Prozedur emuliert die `msdb.dbo.sp_add_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_job` Prozedur emuliert die `msdb.dbo.sp_delete_job` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_jobstep` Prozedur emuliert die `msdb.dbo.sp_delete_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_jobschedule` Prozedur emuliert die `msdb.dbo.sp_delete_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_delete_schedule` Prozedur emuliert die `msdb.dbo.sp_delete_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_detach_schedule` Prozedur emuliert die `msdb.dbo.sp_detach_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_job` Prozedur emuliert die `msdb.dbo.sp_update_job` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_jobschedule` Prozedur emuliert die `msdb.dbo.sp_update_jobschedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_jobstep` Prozedur emuliert die `msdb.dbo.sp_update_jobstep` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sp_update_schedule` Prozedur emuliert die `msdb.dbo.sp_update_schedule` Prozedur. Weitere Informationen zur Quellprozedur des SQL Server-Agents finden Sie in der [technischen Dokumentation von 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
```
## Beispiele für die Verwendung von Prozeduren, die den SQL Server-Agent in PostgreSQL emulieren
Gehen Sie wie `aws_sqlserver_ext.sp_add_job` folgt vor, um einen neuen Job hinzuzufügen.
```
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');
```
Gehen Sie wie `aws_sqlserver_ext.sp_add_jobstep` folgt vor, um einen neuen Auftragsschritt hinzuzufügen.
```
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');
```
Gehen Sie wie `aws_sqlserver_ext.sp_add_schedule` folgt vor, um einen einfachen Zeitplan hinzuzufügen.
```
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`Gehen Sie wie folgt vor, um einen Zeitplan für einen Job festzulegen.
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
`aws_sqlserver_ext.sp_add_jobschedule`Gehen Sie wie folgt vor, um einen Zeitplan für einen Job zu erstellen.
```
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);
```
## Anwendungsbeispiele für die Emulation des SQL Server-Agents in PostgreSQL
Wenn Ihr Quelldatenbankcode den SQL Server-Agent zum Ausführen von Aufträgen verwendet, können Sie das SQL Server to PostgreSQL-Erweiterungspaket für verwenden, um diesen Code AWS SCT nach PostgreSQL zu konvertieren. Das Erweiterungspaket verwendet AWS Lambda Funktionen, um das Verhalten des SQL Server-Agents zu emulieren.
Sie können eine neue AWS Lambda Funktion erstellen oder eine vorhandene Funktion registrieren.
**Um eine neue AWS Lambda Funktion zu erstellen**
1. Öffnen Sie in der Zieldatenbankstruktur das Kontextmenü (Rechtsklick), wählen Sie **Erweiterungspaket anwenden für** und wählen Sie dann **PostgreSQL**. AWS SCT
Der Assistent des Erweiterungspakets wird angezeigt.
1. Gehen Sie auf der Registerkarte **SQL Server-Agent-Emulationsdienst** wie folgt vor:
+ Wählen Sie ** AWS Lambda Funktion erstellen** aus.
+ Geben Sie für **Datenbank-Login** den Namen des Zieldatenbankbenutzers ein.
+ Geben Sie unter **Datenbankkennwort** das Passwort für den Benutzernamen ein, den Sie im vorherigen Schritt eingegeben haben.
+ Geben Sie für **Python-Bibliotheksordner** den Pfad zu Ihrem Python-Bibliotheksordner ein.
+ Wählen Sie „** AWS Lambda Funktion erstellen**“ und dann „**Weiter**“.
**Um eine AWS Lambda Funktion zu registrieren, die Sie zuvor bereitgestellt haben**
+ Führen Sie das folgende Skript in Ihrer Zieldatenbank aus.
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
Im vorherigen Beispiel *`ARN`* ist dies der Amazon-Ressourcenname (ARN) der bereitgestellten AWS Lambda Funktion.
Das folgende Beispiel erstellt eine einfache Aufgabe, die aus einem Schritt besteht. Diese Aufgabe führt alle fünf Minuten die zuvor erstellte `job_example` Funktion aus. Diese Funktion fügt Datensätze in die `job_example_table` Tabelle ein.
**Um diese einfache Aufgabe zu erstellen**
1. Erstellen Sie einen Job mit der `aws_sqlserver_ext.sp_add_job` Funktion wie folgt.
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. Erstellen Sie einen Auftragsschritt mithilfe der `aws_sqlserver_ext.sp_add_jobstep` Funktion, wie im Folgenden gezeigt.
```
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;');
```
Der Job-Schritt gibt an, was die Funktion macht.
1. Erstellen Sie mithilfe der `aws_sqlserver_ext.sp_add_jobschedule` Funktion einen Scheduler für den Job, wie im Folgenden gezeigt.
```
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 */);
```
Der Job-Schritt gibt an, was die Funktion macht.
Um diesen Job zu löschen, verwenden Sie die `aws_sqlserver_ext.sp_delete_job` Funktion wie folgt.
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# Verwenden eines AWS SCT Erweiterungspakets zum Emulieren von SQL Server-Datenbank-Mail in PostgreSQL
Sie können SQL Server Database Mail verwenden, um E-Mail-Nachrichten von der SQL Server Database Engine oder Azure SQL Managed Instance aus an Benutzer zu senden. Diese E-Mail-Nachrichten können Abfrageergebnisse oder Dateien aus beliebigen Ressourcen in Ihrem Netzwerk enthalten. Weitere Informationen zu SQL Server Database Mail finden Sie in der [technischen Dokumentation von Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15).
PostgreSQL hat kein Äquivalent für SQL Server Database Mail. AWS SCT Erstellt ein Erweiterungspaket, um die Funktionen von SQL Server Database Mail zu emulieren. Dieses Erweiterungspaket verwendet AWS Lambda einen Amazon Simple Email Service (Amazon SES). AWS Lambda bietet Benutzern eine Schnittstelle zur Interaktion mit dem Amazon SES SES-E-Mail-Versandservice. Um diese Interaktion einzurichten, fügen Sie den Amazon-Ressourcennamen (ARN) Ihrer Lambda-Funktion hinzu.
Verwenden Sie für ein neues E-Mail-Konto den folgenden Befehl.
```
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;
```
Verwenden Sie den folgenden Befehl, um den ARN Ihrer Lambda-Funktion zum vorhandenen E-Mail-Konto hinzuzufügen.
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
In den vorherigen Beispielen *`ARN`* ist das der ARN Ihrer Lambda-Funktion.
Um das Verhalten von SQL Server-Datenbankmail in PostgreSQL zu emulieren, verwendet das AWS SCT Erweiterungspaket die folgenden Tabellen, Ansichten und Prozeduren.
## Tabellen, die SQL Server-Datenbankmail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, verwendet das Erweiterungspaket die folgenden Tabellen:
**sysmail\$1account**
Speichert die Informationen über die E-Mail-Konten.
**sysmail\$1profile**
Speichert die Informationen zu den Benutzerprofilen.
**sysmail\$1server**
Speichert die Informationen über die E-Mail-Server.
**sysmail\$1mailitems**
Speichert die Liste der E-Mail-Nachrichten.
**sysmail\$1attachments**
Enthält eine Zeile für jeden E-Mail-Anhang.
**sysmail\$1log**
Speichert die Dienstinformationen zum Senden von E-Mail-Nachrichten.
**sysmail\$1profile\$1account**
Speichert die Informationen zu den Benutzerprofilen und E-Mail-Konten.
## Ansichten, die SQL Server-Datenbankmail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, AWS SCT erstellt die folgenden Ansichten in der PostgreSQL-Datenbank, um die Kompatibilität sicherzustellen. Das Erweiterungspaket verwendet sie nicht, aber Ihr konvertierter Code kann diese Ansichten abfragen.
**sysmail\$1allitems**
Enthält eine Liste aller E-Mails.
**sysmail\$1faileditems**
Enthält eine Liste von E-Mails, die nicht gesendet werden konnten.
**sysmail\$1sentitems**
Enthält eine Liste der gesendeten E-Mails.
**sysmail\$1unsentitems**
Enthält eine Liste von E-Mails, die noch nicht gesendet wurden.
**sysmail\$1mailattachments**
Enthält eine Liste der angehängten Dateien.
## Verfahren, die SQL Server-Datenbank-Mail in PostgreSQL emulieren
Um SQL Server Database Mail zu emulieren, verwendet das Erweiterungspaket die folgenden Verfahren:
**sp\$1send\$1dbmail**
Sendet eine E-Mail an die angegebenen Empfänger.
**sysmail\$1add\$1profile\$1sp**
Erstellt ein neues Benutzerprofil.
**sysmail\$1add\$1account\$1sp**
Erstellt ein neues E-Mail-Konto, in dem Informationen wie SMTP-Anmeldeinformationen (Simple Mail Transfer Protocol) usw. gespeichert werden.
**sysmail\$1add\$1profileaccount\$1sp**
Fügt dem angegebenen Benutzerprofil ein E-Mail-Konto hinzu.
**sysmail\$1update\$1profile\$1sp**
Ändert die Attribute des Benutzerprofils wie Beschreibung, Name usw.
**sysmail\$1update\$1account\$1sp**
Ändert die Informationen im vorhandenen E-Mail-Konto.
**sysmail\$1update\$1profileaccount\$1sp**
Aktualisiert die E-Mail-Kontoinformationen im angegebenen Benutzerprofil.
**sysmail\$1delete\$1profileaccount\$1sp**
Entfernt ein E-Mail-Konto aus dem angegebenen Benutzerprofil.
**sysmail\$1delete\$1account\$1sp**
Löscht das E-Mail-Konto.
**sysmail\$1delete\$1profile\$1sp**
Löscht das Benutzerprofil.
**sysmail\$1delete\$1mailitems\$1sp**
Löscht E-Mails aus internen Tabellen.
**sysmail\$1help\$1profile\$1sp**
Zeigt Informationen über das Benutzerprofil an.
**sysmail\$1help\$1account\$1sp**
Zeigt Informationen über das E-Mail-Konto an.
**sysmail\$1help\$1profileaccount\$1sp**
Zeigt Informationen zu E-Mail-Konten an, die dem Benutzerprofil zugeordnet sind.
**sysmail\$1dbmail\$1json**
Eine interne Prozedur, die JSON-Anfragen für Funktionen generiert. AWS Lambda
**sysmail\$1verify\$1profile\$1sp, sysmail\$1verify\$1account\$1sp, sysmail\$1verify\$1addressparams\$1sp**
Interne Verfahren, die Einstellungen überprüfen.
**sp\$1get\$1dbmail, sp\$1set\$1dbmail, sysmail\$1dbmail\$1xml**
Veraltete interne Prozeduren.
## Syntax für Prozeduren, die SQL Server-Datenbankmail in PostgreSQL emulieren
Die `aws_sqlserver_ext.sp_send_dbmail` Prozedur im Erweiterungspaket emuliert die Prozedur. `msdb.dbo.sp_send_dbmail` Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_mailitems_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_mailitems_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_add_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_add_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_profile_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_profile_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_account_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_account_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_help_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_help_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_update_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_update_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
Die im Erweiterungspaket enthaltene `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` Prozedur emuliert die `msdb.dbo.sysmail_delete_profileaccount_sp` Prozedur. Weitere Informationen zum Quellverfahren für SQL Server-Datenbankmail finden Sie in der [technischen Dokumentation von 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
```
## Beispiele für die Verwendung von Prozeduren, die SQL Server-Datenbankmail emulieren, in PostgreSQL
Gehen Sie wie `aws_sqlserver_ext.sp_send_dbmail` folgt vor, um eine E-Mail zu senden.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
Das folgende Beispiel zeigt, wie eine E-Mail mit Abfrageergebnissen gesendet wird.
```
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'
);
```
Das folgende Beispiel zeigt, wie eine E-Mail mit HTML-Code gesendet wird.
```
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'
);
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_delete_mailitems_sp` folgt vor, um E-Mails zu löschen.
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
Das folgende Beispiel zeigt, wie die ältesten E-Mails gelöscht werden.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
Das folgende Beispiel zeigt, wie Sie alle E-Mails löschen, die nicht gesendet werden können.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_add_profile_sp` folgt vor, um ein neues Benutzerprofil zu erstellen.
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
Das folgende Beispiel zeigt, wie Sie ein neues Profil erstellen und die eindeutige Profil-ID in einer Variablen speichern.
```
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;
```
Gehen Sie wie `aws_sqlserver_ext.sysmail_add_account_sp` folgt vor, um ein neues E-Mail-Konto zu erstellen.
```
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`Gehen Sie wie folgt vor, um dem Benutzerprofil ein E-Mail-Konto hinzuzufügen.
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## Anwendungsbeispiele für die Emulation von SQL Server-Datenbank-Mail in PostgreSQL
Wenn Ihr Quelldatenbankcode SQL Server Database Mail zum Senden von E-Mails verwendet, können Sie das AWS SCT Erweiterungspaket verwenden, um diesen Code nach PostgreSQL zu konvertieren.
**Um eine E-Mail aus Ihrer PostgreSQL-Datenbank zu senden**
1. Erstellen und konfigurieren Sie Ihre AWS Lambda Funktion.
1. Wenden Sie das AWS SCT Erweiterungspaket an.
1. Erstellen Sie mit der folgenden `sysmail_add_profile_sp` Funktion ein Benutzerprofil.
1. Erstellen Sie mit der folgenden `sysmail_add_account_sp` Funktion ein E-Mail-Konto.
1. Fügen Sie dieses E-Mail-Konto mithilfe der folgenden `sysmail_add_profileaccount_sp` Funktion zu Ihrem Benutzerprofil hinzu.
```
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. Senden Sie eine E-Mail mit der `sp_send_dbmail` Funktion wie unten gezeigt.
```
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`Gehen Sie wie folgt vor, um die Informationen zu allen Benutzerprofilen anzuzeigen.
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
Im folgenden Beispiel werden die Informationen über das spezifische Benutzerprofil angezeigt.
```
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`Gehen Sie wie folgt vor, um die Informationen zu allen E-Mail-Konten anzuzeigen.
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
Im folgenden Beispiel werden die Informationen zu dem jeweiligen E-Mail-Konto angezeigt.
```
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`Gehen Sie wie folgt vor, um die Informationen zu allen E-Mail-Konten anzuzeigen, die mit den Benutzerprofilen verknüpft sind.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
Im folgenden Beispiel werden die Datensätze nach ID, Profilname oder Kontoname gefiltert.
```
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`Gehen Sie wie folgt vor, um den Namen oder die Beschreibung des Benutzerprofils zu ändern.
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
Gehen Sie wie `ysmail_update_account_sp` folgt vor, um die E-Mail-Kontoeinstellungen zu ändern.
```
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'
);
```
# Migration von SQL Server zu Amazon RDS for SQL Server mit AWS Schema Conversion Tool
Bei der Migration von SQL Server-Schema und -Code in Amazon RDS für SQL Server sind einige Punkte zu beachten:
+ AWS SCT kann den SQL Server-Agent konvertieren, um Zeitpläne, Benachrichtigungen und Jobs auf einer Amazon RDS for SQL Server-DB-Instance bereitzustellen. Nach der Umwandlung können Sie eine Amazon RDS für SQL Server-DB-Instance mit SQL Server Reporting Services (SSRS), SQL Server Analysis Services (SSAS) und SQL Server Integration Services (SSIS) verwenden.
+ Amazon RDS unterstützt derzeit SQL Server Service Broker nicht, und auch keine zusätzlichen T-SQL-Endpunkte, für die Sie den Befehl CREATE ENDPOINT ausführen müssen.
+ Amazon RDS verfügt über begrenzten Support für verknüpfte Server. Bei der Konvertierung von SQL Server-Anwendungscode, der verknüpfte Server verwendet, AWS SCT wird der Anwendungscode konvertiert. Überprüfen Sie jedoch das Verhalten von Objekten, die Verbindungsserver verwenden, bevor Sie den umgewandelten Code ausführen.
+ AlwaysOn wird verwendet.
+ Der AWS SCT Bewertungsbericht enthält Servermetriken für die Konvertierung. Zu diesen Metriken über Ihre SQL Server-Instance gehören:
+ Datenspiegelung wird verwendet.
+ SQL Server-Protokollversand ist konfiguriert.
+ Failover-Cluster wird verwendet.
+ Datenbank-E-Mail ist konfiguriert.
+ Full Text Search Service wird verwendet. Amazon RDS für SQL Server verfügt über eine begrenzte Volltextsuche und unterstützt keine semantische Suche.
+ Data Quality Service (DQS) ist installiert. Amazon RDS bietet keine Unterstützung für DQS. Wir raten daher, SQL Server auf einer Amazon EC2-Instance zu installieren.
## Rechte für RDS für SQL Server als Ziel
Um zu RDS für SQL Server zu migrieren, erstellen Sie einen Datenbankbenutzer und gewähren Sie dann die erforderlichen Rechte für jede Datenbank. Sie können das folgende Codebeispiel verwenden.
```
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;
```
Ersetzen Sie es im vorherigen Beispiel *user\$1name* durch den Namen Ihres Benutzers. Ersetzen Sie es dann *db\$1name* durch den Namen Ihrer Zieldatenbank. Schließlich ersetzen Sie es *your\$1password* durch ein sicheres Passwort.
# Data Warehouse-Quellen für AWS Schema Conversion Tool
AWS SCT kann Schemas für die folgenden Quell-Data Warehouses in ein unterstütztes Ziel konvertieren. Informationen zu Berechtigungen, Verbindungen und Informationen darüber, was für die Verwendung mit der Zieldatenbank oder dem Data Warehouse konvertiert werden AWS SCT kann, finden Sie im Folgenden.
**Topics**
+ [Verbinden von Amazon Redshift mit dem AWS Schema Conversion Tool](CHAP_Source.Redshift.md)
+ [Azure Synapse Analytics verbinden mit AWS Schema Conversion Tool](CHAP_Source.AzureSynapse.md)
+ [Verbindung zu Google herstellen BigQuery mit AWS Schema Conversion Tool](CHAP_Source.BigQuery.md)
+ [Greenplum Database verbinden mit AWS Schema Conversion Tool](CHAP_Source.Greenplum.md)
+ [Verbindung zu Netezza herstellen mit AWS Schema Conversion Tool](CHAP_Source.Netezza.md)
+ [Oracle Data Warehouse verbinden mit AWS SCT](CHAP_Source.OracleDW.md)
+ [Verbindung zu einem Snowflake-Data Warehouse herstellen mit AWS Schema Conversion Tool](CHAP_Source.Snowflake.md)
+ [Herstellen einer Verbindung zu einem SQL Server Data Warehouse mit dem AWS Schema Conversion Tool](CHAP_Source.SQLServerDW.md)
+ [Herstellen einer Verbindung zu einem Teradata Data Warehouse mit dem AWS Schema Conversion Tool](CHAP_Source.Teradata.md)
+ [Verbindung der mit den AWS Schema Conversion Tool Vertica-Datenbanken herstellen](CHAP_Source.Vertica.md)
# Verbinden von Amazon Redshift mit dem AWS Schema Conversion Tool
Sie können es verwenden AWS SCT , um Ihren Amazon Redshift Redshift-Cluster zu optimieren. AWS SCT gibt Ihnen Empfehlungen zur Auswahl von Verteilungs- und Sortierschlüsseln für Ihren Amazon Redshift Redshift-Cluster. Sie können das Amazon Redshift Redshift-Optimierungsprojekt als ein AWS SCT Projekt betrachten, bei dem Quelle und Ziel auf die verschiedenen Amazon Redshift Redshift-Cluster verweisen.
## Rechte für Amazon Redshift als Quelldatenbank
Für die Verwendung von Amazon Redshift als Quelle sind die folgenden Rechte erforderlich:
+ VERWENDUNG IM SCHEMA **
+ WÄHLEN SIE FÜR ALLE TABELLEN IM SCHEMA AUS **
+ SELECT ON PG\$1CATALOG.PG\$1STATISTIC
+ SELECT ON SVV\$1TABLE\$1INFO
+ SELECT ON TABLE STV\$1BLOCKLIST
+ SELECT ON TABLE STV\$1TBL\$1PERM
+ WÄHLEN SIE FÜR SYS\$1SERVERLESS\$1USAGE
+ WÄHLEN SIE AUF PG\$1DATABASE\$1INFO
+ WÄHLEN SIE AUF PG\$1STATISTIC
Ersetzen Sie in den vorherigen Beispielen den ** Platzhalter durch den Namen des Quellschemas.
Informationen zu den für Amazon Redshift als Ziel erforderlichen Rechten finden Sie unter[Berechtigungen für Amazon Redshift als Ziel](CHAP_Converting.DW.md#CHAP_Converting.DW.ConfigureTarget).
## Verbindung zu Amazon Redshift als Quelle herstellen
Gehen Sie wie folgt vor, um mit dem eine Verbindung zu Ihrer Amazon Redshift Redshift-Quelldatenbank herzustellen. AWS Schema Conversion Tool
**So stellen Sie eine Verbindung zu einer Amazon Redshift Redshift-Quelldatenbank her**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen**.
1. Wählen Sie **Amazon Redshift** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen für die Amazon Redshift Redshift-Quelldatenbank einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Redshift.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Amazon Redshift Redshift-Optimierungseinstellungen
Um die Amazon Redshift Redshift-Optimierungseinstellungen zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Amazon Redshift** und dann **Amazon Redshift — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Amazon Redshift Redshift-Optimierung an.
Die Amazon Redshift Redshift-Optimierungseinstellungen AWS SCT beinhalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn die Anzahl der Tabellen größer ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um die Migrationsstrategie auszuwählen.
AWS empfiehlt, verschiedene Cluster als Quelle und Ziel für Ihr Optimierungsprojekt zu verwenden. Vor dem Start des Amazon Redshift Redshift-Optimierungsprozesses erstellen Sie eine Kopie Ihres Amazon Redshift Redshift-Quellclusters. Sie können Ihre Quelldaten in diese Kopie aufnehmen oder einen leeren Cluster erstellen.
Wählen Sie unter **Migrationsstrategie** die Option **Migration zu einer Kopie** aus, um Daten aus Ihrem Quellcluster in den Zielcluster aufzunehmen.
Wählen Sie **unter Migrationsstrategie** die Option **Migration to a Clean Slate aus**, um die Optimierungsvorschläge zu überprüfen. Nachdem Sie diese Vorschläge akzeptiert haben, migrieren Sie Ihre Quelldaten in den Zielcluster.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** ausgewählt haben.
+ Um mit der automatischen Tabellenoptimierung zu arbeiten.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Um diese Option nur für die automatische Tabellenoptimierung zu verwenden, wählen Sie **Optimierungsstrategien** im linken Bereich aus. Wählen Sie dann **Automatische Tabellenoptimierung von Amazon Redshift verwenden** und wählen Sie **Keine** für **Strategie zur anfänglichen Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, deren Schrägwert über dem Schwellenwert liegt, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, dessen Abfragestatistiken Sie analysieren möchten.
# Azure Synapse Analytics verbinden mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Azure Synapse Analytics nach Amazon Redshift zu konvertieren.
## Rechte für Azure Synapse Analytics als Quelldatenbank
Die folgenden Rechte sind erforderlich, um ein Azure Synapse Analytics-Data Warehouse als Quelle zu verwenden:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Wenden Sie die Berechtigungen für jede Datenbank an, deren Schema Sie konvertieren.
## Verbindung zu Azure Synapse Analytics als Quelle herstellen
Gehen Sie wie folgt vor, um mit dem eine Verbindung zu Ihrem Azure Synapse Analytics-Data Warehouse herzustellen. AWS Schema Conversion Tool
**Um eine Verbindung zu einem Azure Synapse Analytics-Data Warehouse als Quelle herzustellen**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen** aus.
1. Wählen Sie **Azure Synapse Analytics** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen für das Azure Synapse Analytics-Data Warehouse manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.AzureSynapse.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einstellungen für die Konvertierung von Azure Synapse Analytics nach Amazon Redshift
Um die Konvertierungseinstellungen von Azure Synapse Analytics zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Azure Synapse** und dann **Azure Synapse — Amazon** Redshift aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Azure Synapse Analytics zu Amazon Redshift an.
Die Konvertierungseinstellungen von Azure Synapse Analytics zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Einstellungen für die Optimierung der Konvertierung von Azure Synapse Analytics zu Amazon Redshift
Um die Einstellungen für die Konversionsoptimierung von Azure Synapse Analytics zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Azure Synapse** und dann **Azure Synapse — Amazon** Redshift aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Azure Synapse Analytics zu Amazon Redshift an.
Die Einstellungen für die Optimierung der Konvertierung von Azure Synapse Analytics zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Verbindung zu Google herstellen BigQuery mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von BigQuery zu Amazon Redshift zu konvertieren.
## Rechte für BigQuery als Quelle
Um ein BigQuery Data Warehouse als Quelle in zu verwenden AWS SCT, erstellen Sie ein Dienstkonto. In Google Cloud verwenden Anwendungen Dienstkonten, um autorisierte API-Aufrufe zu tätigen. Dienstkonten unterscheiden sich von Benutzerkonten. Weitere Informationen finden Sie unter [Dienstkonten](https://cloud.google.com/iam/docs/service-accounts) in der Google Cloud Identity and Access Management-Dokumentation.
Stellen Sie sicher, dass Sie Ihrem Dienstkonto die folgenden Rollen zuweisen:
+ `BigQuery Admin`
+ `Storage Admin`
Die `BigQuery Admin` Rolle bietet Berechtigungen zur Verwaltung aller Ressourcen innerhalb des Projekts. AWS SCT verwendet diese Rolle, um Ihre BigQuery Metadaten in das Migrationsprojekt zu laden.
Die `Storage Admin` Rolle gewährt die volle Kontrolle über Datenobjekte und Buckets. Sie finden diese Rolle unter`Cloud Storage`. AWS SCT verwendet diese Rolle, um Ihre Daten aus Amazon Redshift zu extrahieren BigQuery und sie dann in Amazon Redshift zu laden.
**Um eine Dienstkonto-Schlüsseldatei zu erstellen**
1. Melden Sie sich unter [https://console.cloud.google.com/](https://console.cloud.google.com/)bei der Google Cloud-Verwaltungskonsole an.
1. Wählen Sie auf der [BigQuery API-Seite](https://console.cloud.google.com/apis/library/bigquery.googleapis.com) die Option **Aktivieren** aus. Überspringen Sie diesen Schritt, wenn Sie „**API aktiviert“** sehen.
1. Wählen Sie auf der Seite [Dienstkonten](https://console.cloud.google.com/iam-admin/serviceaccounts) Ihr Projekt aus und klicken Sie dann auf **Dienstkonto erstellen**.
1. Geben Sie auf der Seite mit den **Dienstkontodetails** einen beschreibenden Wert für den **Namen des Dienstkontos** ein. Wählen Sie **Erstellen und fortfahren**. Die Seite „**Diesem Dienstkonto Zugriff auf das Projekt gewähren**“ wird geöffnet.
1. **Wählen Sie unter Rolle** auswählen **BigQuery**die Option und anschließend **BigQuery Admin** aus.
1. Wählen Sie **Weitere Rolle hinzufügen** aus. **Wählen Sie für Rolle** auswählen die Option **Cloud Storage** und dann **Storage Admin** aus.
1. Wählen Sie **Weiter** und dann **Fertig**.
1. Wählen Sie auf der Seite [Dienstkonten](https://console.cloud.google.com/iam-admin/serviceaccounts) das Dienstkonto aus, das Sie erstellt haben.
1. Wählen Sie **Schlüssel** und dann unter Schlüssel **hinzufügen** die Option **Neuen Schlüssel erstellen** aus.
1. Wählen Sie **JSON** und dann **Create** aus. Wählen Sie den Ordner aus, in dem Ihr privater Schlüssel gespeichert werden soll, oder wählen Sie den Standardordner für Downloads in Ihrem Browser aus.
Um Daten aus einem BigQuery Data Warehouse zu extrahieren, AWS SCT wird der Bucket-Ordner von Google Cloud Storage verwendet. Erstellen Sie diesen Bucket, bevor Sie mit der Datenmigration beginnen. Geben Sie im Dialogfeld „**Lokale Aufgabe erstellen**“ den Pfad zu Ihrem Google Cloud Storage-Bucket-Ordner ein. Weitere Informationen finden Sie unter [Eine AWS SCT Aufgabe erstellen, ausführen und überwachen](agents.md#agents.Tasks).
## Verbindung zu BigQuery als Quelle herstellen
Gehen Sie wie folgt vor, um mit dem eine Verbindung zu Ihrem BigQuery Quellprojekt herzustellen AWS Schema Conversion Tool.
**So stellen Sie eine Verbindung zu einem BigQuery Quell-Data Warehouse her**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen** aus.
1. Wählen **BigQuery**Sie und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihr BigQuery Projekt ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Geben Sie unter **Schlüsselpfad** den Pfad zur Schlüsseldatei des Dienstkontos ein. Weitere Informationen zum Erstellen dieser Datei finden Sie unter[Rechte für BigQuery als Quelle](#CHAP_Source.BigQuery.Permissions).
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrem BigQuery Quellprojekt hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrem BigQuery Quellprojekt herzustellen.
## Einschränkungen bei der Verwendung BigQuery als Quelle für AWS SCT
Bei der Verwendung BigQuery als Quelle für gelten die folgenden Einschränkungen AWS SCT:
+ AWS SCT unterstützt die Konvertierung von Unterabfragen in Analysefunktionen nicht.
+ Sie können nicht AWS SCT zur Konvertierung BigQuery `SELECT AS STRUCT` von AND-Anweisungen verwenden. `SELECT AS VALUE`
+ AWS SCT unterstützt die Konvertierung der folgenden Funktionstypen nicht:
+ Ungefähre Summe
+ Bit
+ Debuggen
+ Föderierte Abfrage
+ Geografie
+ Hash
+ Mathematisch
+ Netz
+ Statistisches Aggregat
+ UUID
+ AWS SCT bietet eingeschränkte Unterstützung für die Konvertierung von Zeichenkettenfunktionen.
+ AWS SCT unterstützt die Konvertierung von `UNNEST` Operatoren nicht.
+ Sie können korrelierte Join-Operationen nicht in AWS SCT konvertieren.
+ AWS SCT unterstützt die Konvertierung von`QUALIFY`,`WINDOW`, und `LIMIT` `OFFSET` -Klauseln nicht.
+ Sie können es nicht verwenden AWS SCT , um rekursive allgemeine Tabellenausdrücke zu konvertieren.
+ AWS SCT unterstützt nicht die Konvertierung von `INSERT` Anweisungen mit Unterabfragen innerhalb `VALUES` von Klauseln.
+ AWS SCT unterstützt nicht die Konvertierung von `UPDATE` Anweisungen für verschachtelte Felder und wiederholte Datensätze.
+ Sie können die Konvertierung von `STRUCT` `ARRAY` Datentypen nicht verwenden AWS SCT .
## BigQuery zu Amazon Redshift Redshift-Konvertierungseinstellungen
Um die Konvertierungseinstellungen BigQuery zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Google BigQuery** und dann **Google BigQuery — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung BigQuery zu Amazon Redshift an.
BigQuery zu Amazon Redshift Redshift-Konvertierungseinstellungen in AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## BigQuery zu den Einstellungen für die Konvertierungsoptimierung von Amazon Redshift
Um die Einstellungen BigQuery für die Konversionsoptimierung in Amazon Redshift zu ändern, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Google BigQuery** und dann **Google BigQuery — Amazon Redshift** aus. Wählen Sie im linken Bereich **Optimierungsstrategien** aus. AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die BigQuery Konvertierung in Amazon Redshift an.
BigQuery zu den Einstellungen für die Amazon Redshift Redshift-Konversionsoptimierung, AWS SCT einschließlich Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Greenplum Database verbinden mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Greenplum Database nach Amazon Redshift zu konvertieren.
## Rechte für die Greenplum-Datenbank als Quelle
Für die Verwendung der Greenplum-Datenbank als Quelle sind die folgenden Rechte erforderlich:
+ STELLEN SIE EINE VERBINDUNG ZUR DATENBANK HER **
+ VERWENDUNG IM SCHEMA **
+ WÄHLEN SIE EIN *.*
+ WÄHLEN SIE AUF SEQUENZ *.*
Ersetzen Sie im vorherigen Beispiel die Platzhalter wie folgt:
+ *database\$1name*Ersetzen Sie durch den Namen der Quelldatenbank.
+ *schema\$1name*Ersetzen Sie durch den Namen des Quellschemas.
+ *table\$1name*Ersetzen Sie durch den Namen der Quelltabelle.
+ *sequence\$1name*Ersetzen Sie durch den Namen des Sequenznamens.
## Verbindung zur Greenplum-Datenbank als Quelle herstellen
Verwenden Sie das folgende Verfahren, um eine Verbindung zu Ihrer Greenplum-Quelldatenbank herzustellen. AWS SCT
**So stellen Sie eine Verbindung zu einer Greenplum-Quelldatenbank her**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen**.
1. Wählen Sie **SAP ASE** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Anmeldeinformationen für die Greenplum-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Greenplum.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einstellungen für die Konvertierung von Greenplum nach Amazon Redshift
Um die Konvertierungseinstellungen von Greenplum zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen**. Wählen Sie in der oberen Liste **Greenplum** und dann **Greenplum — Amazon** Redshift aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Greenplum zu Amazon Redshift an.
Die Konvertierungseinstellungen von Greenplum zu Amazon Redshift AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Einstellungen zur Optimierung der Konvertierung von Greenplum nach Amazon Redshift
Um die Einstellungen für die Konversionsoptimierung von Greenplum nach Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Greenplum** und dann **Greenplum — Amazon** Redshift aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt die Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Greenplum zu Amazon Redshift an.
Die Einstellungen für die Konvertierungsoptimierung von Greenplum nach Amazon Redshift AWS SCT beinhalten Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Verbindung zu Netezza herstellen mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Netezza nach Amazon Redshift zu konvertieren.
## Rechte für Netezza als Quelle
Für die Verwendung von Netezza als Quelle sind die folgenden Rechte erforderlich:
+ wählen Sie in der Ansicht system.definition\$1schema.system
+ wählen Sie in der Tabelle system.definition\$1schema.system
+ wählen Sie in der Tabelle system.definition\$1schema.management
+ Liste auf **
+ Liste auf **
+ auf ** .all.table auflisten
+ Liste in der Tabelle .all.external **
+ Liste auf .all.view **
+ Liste in der Ansicht .all.materialized **
+ Liste auf ** .all.procedure
+ Liste auf .all.sequence **
+ Liste auf .all.function **
+ Liste auf .all.aggregate **
Ersetzen Sie im vorherigen Beispiel die Platzhalter wie folgt:
+ *database\$1name*Ersetzen Sie durch den Namen der Quelldatenbank.
+ *schema\$1name*Ersetzen Sie durch den Namen des Quellschemas.
AWS SCT erfordert Zugriff auf die folgenden Systemtabellen und Ansichten. Sie können Zugriff auf diese Objekte gewähren, anstatt Zugriff auf `system.definition_schema.system view` und `system.definition_schema.system tables` in der obigen Liste zu gewähren.
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1aggregate
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1class
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1constraint
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1const\$1relattr
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1database
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1grobj\$1priv
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1grpusr
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1hist\$1config
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1object
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1object\$1classes
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1proc
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1type
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1user
+ wählen Sie auf system.definition\$1schema aus. \$1t\$1usrobj\$1priv
+ wählen Sie auf system.definition\$1schema aus. \$1vt\$1sequence
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1aggregate
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1constraint\$1depends
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1database
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1datatype
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1dslice
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1function
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1group
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1obj\$1relation
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1obj\$1relation\$1xdb
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1procedure
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1relation\$1column
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1relation\$1keydata
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1relobjclasses
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1schema\$1xdb
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1sequence
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1Synonym
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1system\$1info
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1sys\$1constraint
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1sys\$1object\$1dslice\$1info
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1sys\$1user
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1table
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1table\$1constraint
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1table\$1dist\$1map
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1table\$1organize\$1column
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1table\$1storage\$1stat
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1user
+ wählen Sie auf system.definition\$1schema aus. \$1v\$1view
+ wählen Sie auf system.information\$1schema aus. \$1v\$1relation\$1column
+ wählen Sie auf system.information\$1schema aus. \$1v\$1table
+ wählen Sie auf \$1hist\$1column\$1access\$1\$1
## Verbindung zu Netezza als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit dem AWS Schema Conversion Tool eine Verbindung zu Ihrer Netezza-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer Netezza-Quelldatenbank her**
1. Wählen Sie im die AWS Schema Conversion Tool Option Quelle **hinzufügen**.
1. **Wählen Sie **Netezza** und dann Weiter.**
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen zur Netezza-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Netezza.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Konfiguration der fortlaufenden Datenreplikation
Nachdem Sie Ihre Netezza-Datenbankschemas konvertiert und auf Ihre Amazon Redshift Redshift-Datenbank angewendet haben, können Sie Daten mit AWS SCT Datenextraktionsagenten migrieren. Der Agent extrahiert Ihre Daten und lädt sie in Ihren Amazon S3 S3-Bucket hoch. Anschließend können Sie die Daten von Amazon S3 nach Amazon Redshift kopieren. AWS SCT
Wenn sich Daten in Ihrer Quelldatenbank während des Migrationsprozesses ändern, können Sie laufende Änderungen mit Ihren AWS SCT Datenextraktionsagenten erfassen. Anschließend können Sie diese laufenden Änderungen in Ihrer Zieldatenbank replizieren, nachdem Sie die erste Datenmigration abgeschlossen haben. Dieser Vorgang wird als fortlaufende Datenreplikation oder *Change Data Capture* (CDC) bezeichnet.
**So konfigurieren Sie die fortlaufende Datenreplikation für Migrationen von Netezza zu Amazon Redshift**
1. Erstellen Sie in Ihrer Quelldatenbank eine Verlaufsdatenbank. Sie können das folgende Codebeispiel in der Netezza-Befehlszeilenschnittstelle (CLI) verwenden.
```
nzhistcreatedb -d history_database_name -t query -v 1 -u load_user -o histdb_owner -p your_password
```
Ersetzen Sie es im vorherigen Beispiel *history\$1database\$1name* durch den Namen Ihrer Verlaufsdatenbank. Ersetzen Sie es anschließend *load\$1user* durch den Namen des Benutzers, den Sie für das Laden von Verlaufsdaten in die Datenbank definiert haben. *histdb\$1owner*Ersetzen Sie es dann durch den Namen des Benutzers, den Sie als Eigentümer der Verlaufsdatenbank definiert haben. Stellen Sie sicher, dass Sie diesen Benutzer bereits erstellt und die `CREATE DATABASE` Erlaubnis erteilt haben. Ersetzen Sie es abschließend *your\$1password* durch ein sicheres Passwort.
1. Konfigurieren Sie die Verlaufsprotokollierung. Verwenden Sie dazu das folgende Codebeispiel.
```
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;
```
Ersetzen Sie im vorherigen Beispiel *history\$1configuration\$1name* und *history\$1database\$1name* durch die Namen Ihrer Verlaufskonfiguration und Ihrer Verlaufsdatenbank. Ersetzen Sie es anschließend *load\$1user* durch den Namen des Benutzers, den Sie für das Laden von Verlaufsdaten in die Datenbank definiert haben. Ersetzen Sie es dann *your\$1password* durch ein sicheres Passwort.
1. Erteilen Sie Leseberechtigungen für alle Tabellen in der Verlaufsdatenbank. Sie können das folgende Codebeispiel verwenden, um die `SELECT` Berechtigung zu erteilen.
```
GRANT SELECT ON history_database_name.ALL.TABLE TO your_user;
```
Ersetzen Sie es im vorherigen Beispiel *history\$1database\$1name* durch den Namen Ihrer Verlaufsdatenbank. Als Nächstes ersetzen Sie ihn durch *your\$1user* den Namen des Benutzers mit minimalen Rechten für die Arbeit mit Ihrer Netezza-Datenbank. Sie verwenden die Anmeldeinformationen dieses Datenbankbenutzers in. AWS SCT
1. Sammeln Sie Statistiken für jede Tabelle in Ihrem Quellschema, um Informationen über die Kardinalität der Spalten zu erhalten. Sie können den folgenden Befehl verwenden, um Statistiken in Ihrer Verlaufsdatenbank zu generieren.
```
GENERATE STATISTICS on "schema_name"."table_name";
```
Ersetzen Sie im vorherigen Beispiel *schema\$1name* und *table\$1name* durch den Namen Ihres Datenbankschemas und der Tabelle.
1. Stellen Sie sicher, dass Sie die Voraussetzungen erfüllt haben, indem Sie die folgende Abfrage ausführen:
```
SELECT COUNT(*) FROM history_database_name.history_schema_name."$hist_column_access_N";
```
Ersetzen Sie im vorherigen Beispiel *history\$1database\$1name* und *history\$1schema\$1name* durch den Namen Ihrer Verlaufsdatenbank und Ihres Schemas. Als Nächstes *N* ersetzen Sie es durch die Versionsnummer Ihrer Verlaufsdatenbank. Weitere Informationen zu historischen Datenbankversionen finden Sie in der [IBM Netezza-Dokumentation](https://www.ibm.com/docs/en/netezza?topic=history-database-versions).
1. Installieren Sie Ihre Datenextraktionsagenten. Weitere Informationen finden Sie unter [Installation von Extraktionsagenten](agents.md#agents.Installing).
Stellen Sie sicher, dass der `{working.folder}` Parameter in der `settings.properties` Datei für alle Extraktor-Instanzen auf denselben Ordner verweist. In diesem Fall können Ihre Extraktoren die CDC-Sitzung koordinieren und einen einzigen Transaktionspunkt für alle Unteraufgaben verwenden.
1. Registrieren Sie Ihren Datenextraktionsagenten. Weitere Informationen finden Sie unter [Registrierung von Extraktionsagenten mit dem AWS Schema Conversion Tool](agents.md#agents.Using).
1. Erstellen Sie Ihre CDC-Aufgabe. Weitere Informationen finden Sie unter [Eine AWS SCT Aufgabe erstellen, ausführen und überwachen](agents.md#agents.Tasks).
1. Öffnen Sie Ihr Projekt in AWS SCT. Wählen Sie im linken Bereich Ihre Quelltabelle aus. Öffnen Sie das Kontextmenü (Rechtsklick) und wählen Sie **Lokale Aufgabe erstellen**.
1. Geben Sie **unter Aufgabenname** einen aussagekräftigen Namen für Ihre Datenmigrationsaufgabe ein.
1. Wählen Sie für **den Migrationsmodus** **Extrahieren, Hochladen und Kopieren** aus.
1. Wählen Sie **CDC aktivieren** aus.
1. Wählen Sie die Registerkarte **CDC-Einstellungen** und definieren Sie den Umfang und den Zeitplan der CDC-Sitzungen.
1. Wählen Sie **Testaufgabe**, um zu überprüfen, ob Sie eine Verbindung zu Ihrem Arbeitsordner, Amazon S3 S3-Bucket und Amazon Redshift Data Warehouse herstellen können.
1. Wählen Sie **Erstellen**, um Ihre Aufgabe zu erstellen.
1. Wählen Sie die Registerkarte **Aufgaben**, wählen Sie Ihre Aufgabe aus der Liste aus und klicken Sie auf **Start**.
1. Die AWS SCT Aufgabe gewährleistet die Transaktionskonsistenz in der Zieldatenbank. Der Datenextraktionsagent repliziert Transaktionen aus der Quelle in der Reihenfolge der Transaktions-IDs.
Wenn Sie eine der Migrationssitzungen beenden oder wenn sie fehlschlägt, wird auch die CDC-Verarbeitung gestoppt.
## Einstellungen für die Konvertierung von Netezza nach Amazon Redshift
**Um die Konvertierungseinstellungen von Netezza zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen.** Wählen Sie in der oberen Liste **Netezza** und dann **Netezza — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Netezza zu Amazon Redshift an.
Die Konvertierungseinstellungen von Netezza zu Amazon Redshift AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Einstellungen zur Optimierung der Konvertierung von Netezza nach Amazon Redshift
**Um die Einstellungen für die Konvertierungsoptimierung von Netezza zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen aus.** Wählen Sie in der oberen Liste **Netezza** und dann **Netezza — Amazon Redshift** aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Netezza zu Amazon Redshift an.
Die Einstellungen zur Optimierung der Konvertierung von Netezza zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Oracle Data Warehouse verbinden mit AWS SCT
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Oracle Data Warehouse nach Amazon Redshift oder Amazon Redshift zu konvertieren und in Kombination zu AWS Glue verwenden.
## Rechte für Oracle Data Warehouse als Quelle
Die folgenden Rechte sind erforderlich, um Oracle Data Warehouse als Quelle zu verwenden:
+ connect
+ select\$1catalog\$1role
+ select any dictionary
## Verbindung zu Oracle Data Warehouse als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit den AWS Schema Conversion Tool eine Verbindung zu Ihrer Oracle Data Warehouse-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer Oracle Data Warehouse-Quelldatenbank her**
1. Wählen Sie in der AWS Schema Conversion Tool**Quelle hinzufügen** aus.
1. Wählen Sie **Oracle** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Oracle-Quell-Data Warehouse-Verbindungsinformationen manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.OracleDW.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einstellungen für die Konvertierung von Oracle Data Warehouse zu Amazon Redshift
Um die Konvertierungseinstellungen von Oracle Data Warehouse zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen**. Wählen Sie in der oberen Liste **Oracle** und dann **Oracle — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Oracle Data Warehouse zu Amazon Redshift an.
Die Konvertierungseinstellungen von Oracle Data Warehouse nach Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um Formatierungsfunktionen für Datentypen wie `TO_CHAR``TO_DATE`, und `TO_NUMBER` mit Datetime-Formatelementen zu konvertieren, die Amazon Redshift nicht unterstützt. AWS SCT Verwendet standardmäßig die Funktionen des Erweiterungspakets, um die Verwendung dieser nicht unterstützten Formatelemente im konvertierten Code zu emulieren.
Das Datetime-Formatmodell in Oracle enthält im Vergleich zu Zeichenketten im Datetime-Format in Amazon Redshift mehr Elemente. Wenn Ihr Quellcode nur Elemente im Datetime-Format enthält, die Amazon Redshift unterstützt, benötigen Sie die Funktionen des Erweiterungspakets im konvertierten Code nicht. Um zu vermeiden, dass die Funktionen des Erweiterungspakets im konvertierten Code verwendet werden, wählen Sie **Datetype-Formatelemente aus, die Sie im Oracle-Code verwenden, ähneln Zeichenketten im Datetime-Format in** Amazon Redshift. In diesem Fall arbeitet der konvertierte Code schneller.
Das numerische Formatmodell in Oracle enthält mehr Elemente als numerische Formatzeichenfolgen in Amazon Redshift. Wenn Ihr Quellcode nur numerische Formatelemente enthält, die Amazon Redshift unterstützt, benötigen Sie die Erweiterungspaket-Funktionen im konvertierten Code nicht. Um zu vermeiden, dass die Funktionen des Erweiterungspakets im konvertierten Code verwendet werden, wählen Sie **Numerische Formatelemente aus, die Sie im Oracle-Code verwenden, ähneln numerischen Formatzeichenfolgen in Amazon Redshift**. In diesem Fall arbeitet der konvertierte Code schneller.
+ Um Oracle `LEAD` - und `LAG` Analysefunktionen zu konvertieren. Löst standardmäßig ein AWS SCT Aktionselement für jede `LEAD` `LAG` AND-Funktion aus.
Wenn Ihr Quellcode nicht die Standardwerte für Offset in diesen Funktionen verwendet, AWS SCT kann die Verwendung dieser Funktionen mit der `NVL` Funktion emuliert werden. Wählen Sie dazu **die NVL-Funktion verwenden, um das Verhalten der Oracle LEAD- und LAG-Funktionen zu emulieren**.
+ Um das Verhalten von Primär- und Einzelschlüsseln in Ihrem Amazon Redshift Redshift-Cluster zu emulieren, wählen Sie **Das Verhalten von Primär- und Einzelschlüsseln emulieren** aus.
Amazon Redshift erzwingt keine eindeutigen und primären Schlüssel und verwendet sie nur zu Informationszwecken. Wenn Sie diese Einschränkungen in Ihrem Code verwenden, stellen Sie sicher, dass ihr Verhalten im konvertierten Code AWS SCT emuliert wird.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Optimierungseinstellungen für die Konvertierung von Oracle Data Warehouse nach Amazon Redshift
Um die Einstellungen für die Konvertierungsoptimierung von Oracle Data Warehouse zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Oracle** und dann **Oracle — Amazon Redshift** aus. Wählen Sie im linken Bereich **Optimierungsstrategien** aus. AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Oracle Data Warehouse zu Amazon Redshift an.
Die Einstellungen für die Optimierung der Konvertierung von Oracle Data Warehouse nach Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Verbindung zu einem Snowflake-Data Warehouse herstellen mit AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Snowflake nach Amazon Redshift zu konvertieren.
## Rechte für Snowflake als Quelldatenbank
Sie können eine Rolle mit Rechten erstellen und dieser Rolle den Namen eines Benutzers zuweisen, indem Sie die `SECURITYADMIN` Rolle und den `SECURITYADMIN` Sitzungskontext verwenden.
Das folgende Beispiel erstellt minimale Rechte und gewährt sie dem `min_privs` Benutzer.
```
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;
```
Ersetzen Sie im vorherigen Beispiel die Platzhalter wie folgt:
+ *`role_name`*Ersetzen Sie ihn durch den Namen einer Rolle mit schreibgeschützten Rechten.
+ Durch `db_name` den Namen der Quelldatenbank ersetzen.
+ `schema_name`Ersetzen Sie durch den Namen des Quellschemas.
+ *`datawarehousename`*Ersetzen Sie es durch den Namen eines erforderlichen Data Warehouse.
+ `min_privs`Ersetzen Sie es durch den Namen eines Benutzers mit minimalen Rechten.
Die `DEFAULT_WAREHOUSE` Parameter `DEFAULT_ROLE` und sind schlüsselabhängig.
## Konfiguration des sicheren Zugriffs auf Amazon S3
Sicherheits- und Zugriffsverwaltungsrichtlinien für einen Amazon S3 S3-Bucket ermöglichen Snowflake den Zugriff auf den S3-Bucket, das Lesen von Daten und das Schreiben von Daten in den S3-Bucket. Sie können den sicheren Zugriff auf einen privaten Amazon S3 S3-Bucket mithilfe des `STORAGE INTEGRATION` Snowflake-Objekttyps konfigurieren. Ein Snowflake-Speicherintegrationsobjekt delegiert die Verantwortung für die Authentifizierung an eine Snowflake-Identitäts- und Zugriffsverwaltungseinheit.
Weitere Informationen finden Sie unter [Konfiguration einer Snowflake-Speicherintegration für den Zugriff auf Amazon S3](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html) in der Snowflake-Dokumentation.
## Verbindung zu Snowflake als Quelle herstellen
Gehen Sie wie folgt vor, um mit dem eine Verbindung zu Ihrer Quelldatenbank herzustellen. AWS Schema Conversion Tool
**So stellen Sie eine Verbindung zu einer Snowflake-Quelldatenbank her**
1. Wählen Sie in der die Option AWS Schema Conversion Tool Quelle **hinzufügen** aus.
1. **Wählen Sie **Snowflake** und dann Weiter.**
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen für das Snowflake-Quell-Data Warehouse manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Snowflake.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einschränkungen für Snowflake als Quelle
Im Folgenden finden Sie Einschränkungen bei der Verwendung von Snowflake als Quelle für: AWS SCT
+ Objektkennungen müssen im Kontext des Objekttyps und des übergeordneten Objekts eindeutig sein:
**Datenbank**
Schema-IDs müssen innerhalb einer Datenbank eindeutig sein.
**Schemata**
Objektbezeichner, z. B. für Tabellen und Ansichten, müssen innerhalb eines Schemas eindeutig sein.
**Tabellen/Ansichten**
Spaltenbezeichner müssen innerhalb einer Tabelle eindeutig sein.
+ Die maximale Anzahl von Tabellen für große und extragroße Cluster-Knotentypen beträgt 9.900. Bei Cluster-Knotentypen vom Typ 8xlarge beträgt die maximale Anzahl von Tabellen 100.000. Das Limit umfasst temporäre Tabellen, sowohl benutzerdefinierte Tabellen als auch Tabellen, die von Amazon Redshift während der Abfrageverarbeitung oder Systemwartung erstellt wurden. Weitere Informationen finden Sie unter [Amazon Redshift quotas](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) (Amazon-Redshift-Kontingente) im *Amazon-Redshift-Clusterverwaltungshandbuch*.
+ Für gespeicherte Prozeduren beträgt die maximale Anzahl von Eingabe- und Ausgabeargumenten 32.
## Quelldatentypen für Snowflake
Im Folgenden finden Sie die Snowflake-Quelldatentypen, die bei der Verwendung unterstützt werden, AWS SCT und die Standardzuordnung zu einem Amazon Redshift Redshift-Ziel.
| Snowflake-Datentypen | Amazon-Redshift-Datentypen |
| --- | --- |
| NUMBER | NUMERISCH (38) |
| NUMBER(p) | Wenn p =< 4 ist, dann SMALLINT Wenn p => 5 und =< 9 ist, dann INTEGER Wenn p => 10 und =< 18 ist, dann BIGINT Wenn p => 19 ist, dann NUMERIC (p) |
| ZAHL (p, 0) | Wenn p =< 4 ist, dann SMALLINT Wenn p => 5 und =< 9 ist, dann INTEGER Wenn p => 10 und =< 18 ist, dann BIGINT Wenn p => 19 ist, dann: NUMERIC (p,0) |
| ZAHL (p, s) | Wenn p => 1 und =< 38 ist und wenn s => 1 und =< 37 ist, dann NUMERIC (p,s) |
| FLOAT | FLOAT |
| TEXT Unicode-Zeichen bis zu 16.777.216 Byte; bis zu 4 Byte pro Zeichen. | VARCHAR(MAX) |
| TEXT (p) Unicode-Zeichen bis zu 65.535 Byte; bis zu 4 Byte pro Zeichen. | Wenn p =< 65.535 ist, dann ist VARCHAR (p) |
| TEXT (p) Unicode-Zeichen bis zu 16.777.216 Byte; bis zu 4 Byte pro Zeichen. | Wenn p => 65.535 und =< 16.777.216 ist, dann ist VARCHAR (MAX) |
| BINARY Einzelbyte-Zeichen bis zu 8.388.608 Byte; 1 Byte pro Zeichen. | VARCHAR(MAX) |
| BINÄR (p) Einzelbyte-Zeichen bis zu 65.535 Byte; 1 Byte pro Zeichen. | VARCHAR (p) |
| BINÄR (p) Einzelbyte-Zeichen bis zu 8.388.608 Byte; 1 Byte pro Zeichen. | VARCHAR(MAX) |
| BOOLEAN | BOOLEAN |
| DATE | DATE |
| TIME Zeitwerte zwischen 00:00:00 und 23:59:59.999 999999. | VARCHAR(18) |
| ZEIT (f) Zeitwerte zwischen 00:00:00 und 23:59:59.9 (f). | VARCHAR (n) — 9 \$1 dt-attr-1 |
| TIMESTAMP\$1NTZ | TIMESTAMP (ZEITSTEMPEL) |
| ZEITSTEMPEL\$1TZ | TIMESTAMPTZ |
## Einstellungen für die Konvertierung von Snowflake nach Amazon Redshift
**Um die Konvertierungseinstellungen von Snowflake nach Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen aus.** Wählen Sie in der oberen Liste **Snowflake** und dann **Snowflake — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Snowflake zu Amazon Redshift an.
Die Konvertierungseinstellungen von Snowflake zu Amazon Redshift AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Einstellungen für die Optimierung der Konvertierung von Snowflake zu Amazon Redshift
**Um die Einstellungen für die Konversionsoptimierung von Snowflake zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen aus.** Wählen Sie in der oberen Liste **Snowflake** und dann **Snowflake — Amazon Redshift** aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Snowflake zu Amazon Redshift an.
Die Einstellungen zur Optimierung der Konvertierung von Snowflake zu Amazon Redshift AWS SCT beinhalten Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Herstellen einer Verbindung zu einem SQL Server Data Warehouse mit dem AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Microsoft SQL Server DW nach Amazon Redshift oder Amazon Redshift zu konvertieren und in Kombination zu AWS Glue verwenden.
## Rechte für Microsoft SQL Server Data Warehouse als Quelle
Die folgenden Rechte sind erforderlich, um Microsoft SQL Server Data Warehouse als Quelle zu verwenden:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
+ WÄHLEN SIE EIN SCHEMA AUS: **
Ersetzen Sie im vorherigen Beispiel den ** Platzhalter durch den Namen der Quelle source\$1schema.
Gewähren Sie die erforderlichen Berechtigungen für alle Datenbanken, deren Schemata Sie konvertieren.
Gewähren Sie darüber hinaus folgende Berechtigungen für die Master-Datenbank:
+ VIEW SERVER STATE
## Einschränkungen für SQL Server Data Warehouse als Quelle
Die Verwendung von Microsoft SQL Server Parallel Data Warehouse (PDW) als Quelle wird derzeit nicht unterstützt.
## Eine Verbindung zu SQL Server Data Warehouse als Quelle herstellen
Verwenden Sie das folgende Verfahren, um eine Verbindung zu Ihrer SQL Server Data Warehouse-Quelldatenbank mit dem herzustellen AWS Schema Conversion Tool.
**So stellen Sie eine Verbindung zu einer SQL Server Data Warehouse-Quelldatenbank her**
1. Wählen Sie in der die AWS Schema Conversion Tool Option **Quelle hinzufügen** aus.
1. Wählen Sie **Microsoft SQL Server** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Microsoft SQL Server-Quell-Data Warehouse-Verbindungsinformationen manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServerDW.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einstellungen für die Konvertierung von SQL Server Data Warehouse nach Amazon Redshift
Um die Konvertierungseinstellungen von SQL Server Data Warehouse zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Microsoft SQL Server** und dann **Microsoft SQL Server — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von SQL Server Data Warehouse zu Amazon Redshift an.
Die Konvertierungseinstellungen von SQL Server Data Warehouse zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Optimierungseinstellungen für die Konvertierung von SQL Server Data Warehouse nach Amazon Redshift
Um die Einstellungen für die Konvertierungsoptimierung von SQL Server Data Warehouse in Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Microsoft SQL Server** und dann **Microsoft SQL Server — Amazon Redshift** aus. Wählen Sie im linken Bereich **Optimierungsstrategien** aus. AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von SQL Server Data Warehouse zu Amazon Redshift an.
Die Einstellungen für die Optimierung der Konvertierung von SQL Server Data Warehouse nach Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Herstellen einer Verbindung zu einem Teradata Data Warehouse mit dem AWS Schema Conversion Tool
Sie können AWS SCT es verwenden, um Schemas, Codeobjekte und Anwendungscode von Teradata nach Amazon Redshift oder Amazon Redshift zu konvertieren und in Kombination zu verwenden. AWS Glue
## Rechte für Teradata als Quelle
Für die Verwendung von Teradata als Quelle sind die folgenden Rechte erforderlich:
+ SELECT ON DBC
+ WÄHLEN SIE AUF SYSUDTLIB
+ WÄHLEN SIE AUF SYSLIB
+ WÄHLEN SIE EIN **
+ PROZEDUR ERSTELLEN AM **
Ersetzen Sie im vorherigen Beispiel den ** Platzhalter durch den Namen der Quelldatenbank.
AWS SCT erfordert das CREATE PROCEDURE-Privileg, um HELP PROCEDURE für alle Prozeduren in der Quelldatenbank auszuführen. AWS SCT verwendet dieses Recht nicht, um neue Objekte in Ihrer Teradata-Quelldatenbank zu erstellen.
## Verbindung zu Teradata als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit dem AWS Schema Conversion Tool eine Verbindung zu Ihrer Teradata-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer Teradata-Quelldatenbank her**
1. Wählen Sie im die Option AWS Schema Conversion Tool Quelle **hinzufügen** aus.
1. **Wählen Sie **Teradata** und dann Weiter.**
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen zur Teradata-Quelldatenbank manuell einzugeben:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
### Verwenden der LDAP-Authentifizierung mit einer Teradata-Quelle
Gehen Sie wie folgt vor, um eine Lightweight Directory Access Protocol (LDAP)-Authentifizierung für Teradata-Benutzer einzurichten, die Microsoft Active Directory in Windows verwenden.
Im folgenden Verfahren ist die Active Directory-Domäne. `test.local.com` Der Windows-Server ist es`DC`, und er ist mit Standardeinstellungen konfiguriert. Das folgende Skript erstellt das `test_ldap` Active Directory-Konto, und dieses Konto verwendet das `test_ldap` Passwort.
**So richten Sie die LDAP-Authentifizierung für Teradata-Benutzer ein, die Microsoft Active Directory in Windows ausführen**
1. Bearbeiten Sie im Verzeichnis `/opt/teradata/tdat/tdgss/site` die Datei `TdgssUserConfigFile.xml`. Ändern Sie den LDAP-Abschnitt wie folgt.
```
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. Übernehmen Sie die Änderungen, indem Sie die Konfiguration wie folgt ausführen.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Testen Sie die Konfiguration, indem Sie den folgenden Befehl ausführen.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen.
```
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. Starten Sie TPA mit dem folgenden Befehl neu.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Erstellen Sie, wie im Folgenden gezeigt, denselben Benutzer in der Teradata-Datenbank wie in Active Directory.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Wenn Sie das Benutzerkennwort in Active Directory für Ihren LDAP-Benutzer ändern, geben Sie dieses neue Passwort bei der Verbindung zu Teradata im LDAP-Modus an. Im DEFAULT-Modus stellen Sie mithilfe des LDAP-Benutzernamens und eines beliebigen Kennworts eine Verbindung zu Teradata her.
## Konfiguration der Statistikerfassung in Ihrem Teradata-Quell-Data Warehouse
Um Ihr Teradata-Quell-Data Warehouse zu konvertieren, AWS SCT verwendet Statistiken, um Ihr konvertiertes Amazon Redshift Redshift-Data Warehouse zu optimieren. Sie können Statistiken in der Statistikdatei sammeln AWS SCT oder diese hochladen. Weitere Informationen finden Sie unter [Statistiken sammeln oder hochladen](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Um sicherzustellen, dass Statistiken aus Ihrem Data Warehouse erfasst werden AWS SCT können, müssen Sie die folgenden erforderlichen Aufgaben ausführen.
**Um Statistiken aus Ihrem Teradata Data Warehouse zu sammeln**
1. Führen Sie die folgende Abfrage aus, um Statistiken für alle Tabellen in Ihrem Data Warehouse abzurufen.
```
collect summary statistics on table_name;
```
Ersetzen Sie im vorherigen Beispiel durch *table\$1name* den Namen Ihrer Quelltabelle. Wiederholen Sie die Abfrage für jede Tabelle, die Sie konvertieren.
1. Führen Sie die folgende Abfrage aus, um die Kontozeichenfolge für den Benutzer zu ermitteln, mit der Sie Ihr Data Warehouse konvertieren.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Aktivieren Sie die Abfrageprotokollierung für einen bestimmten Benutzer mithilfe der Kontozeichenfolge aus dem vorherigen Beispiel.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
Alternativ können Sie die Abfrageprotokollierung für alle Datenbankbenutzer aktivieren.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Nachdem Sie die Erfassung der Data Warehouse-Statistiken abgeschlossen haben, deaktivieren Sie die Abfrageprotokollierung. Dazu können Sie das folgende Codebeispiel verwenden.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Sammeln von Statistiken im Offline-Modus aus Ihrem Teradata-Quell-Data Warehouse
Nachdem Sie die Statistikerfassung in Ihrem Teradata Data Warehouse konfiguriert haben, können Sie Statistiken in Ihrem AWS SCT Projekt sammeln. Alternativ können Sie Basic Teradata Query-Skripts (BTEQ) verwenden, um Statistiken im Offline-Modus zu sammeln. Anschließend können Sie die Dateien mit den gesammelten Statistiken in Ihr Projekt hochladen. AWS SCT Weitere Informationen finden Sie unter [Statistiken sammeln oder hochladen](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Um Statistiken aus Ihrem Teradata Data Warehouse im Offline-Modus zu sammeln**
1. Erstellen Sie das `off-line_stats.bteq` Skript mit dem folgenden Inhalt.
```
.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. Erstellen Sie die `td_run_bteq.bat` Datei, die das BTEQ-Skript ausführt, das Sie im vorherigen Schritt erstellt haben. Verwenden Sie den folgenden Inhalt für diese Datei.
```
@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. Erstellen Sie die `runme.bat` Datei, in der die Batch-Datei ausgeführt wird, die Sie im vorherigen Schritt erstellt haben. Verwenden Sie den folgenden Inhalt für diese Datei.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
Ersetzen Sie in der `runme.bat` Datei *ServerName**UserName*, und *DatabaseName* durch Ihre zutreffenden Werte.
Führen Sie dann die `runme.bat` Datei aus. Wiederholen Sie diesen Schritt für jedes Data Warehouse, das Sie in Amazon Redshift konvertieren.
Nachdem Sie dieses Skript ausgeführt haben, erhalten Sie drei Dateien mit Statistiken für jede Datenbank. Sie können diese Dateien in Ihr AWS SCT Projekt hochladen. Wählen Sie dazu im linken Bereich Ihres Projekts Ihr Data Warehouse aus und öffnen Sie das Kontextmenü (Rechtsklick). Wählen Sie **Statistik hochladen**.
## Einstellungen für die Konvertierung von Teradata nach Amazon Redshift
**Um die Konvertierungseinstellungen von Teradata nach Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen aus.** Wählen Sie in der oberen Liste **Teradata** und dann **Teradata — Amazon Redshift** aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Teradata zu Amazon Redshift an.
Die Konvertierungseinstellungen von Teradata nach Amazon Redshift AWS SCT enthalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
+ Um eine explizite Liste von Spalten im konvertierten Code für `SELECT *` Anweisungen zu verwenden, wählen Sie **Explizite Spaltendeklaration verwenden** aus.
+ Um das Verhalten von Primär- und Einzelschlüsseln in Ihrem Amazon Redshift Redshift-Cluster zu emulieren, wählen Sie **Das Verhalten von Primär- und Einzelschlüsseln emulieren** aus.
Amazon Redshift erzwingt keine eindeutigen und primären Schlüssel und verwendet sie nur zu Informationszwecken. Wenn Sie diese Einschränkungen in Ihrem Code verwenden, stellen Sie sicher, dass ihr Verhalten im konvertierten Code AWS SCT emuliert wird.
+ Um die Einzigartigkeit der Daten in den Amazon Redshift Redshift-Zieltabellen sicherzustellen. Wählen Sie dazu das **Verhalten von SET-Tabellen emulieren aus**.
Teradata erstellt Tabellen mit dem `SET` Syntaxelement als Standardoption. Sie können einer `SET` Tabelle keine doppelten Zeilen hinzufügen. Wenn Ihr Quellcode diese Eindeutigkeitsbeschränkung nicht verwendet, deaktivieren Sie diese Option. In diesem Fall arbeitet der konvertierte Code schneller.
Wenn Ihr Quellcode die `SET` Option in Tabellen als Eindeutigkeitsbeschränkung verwendet, aktivieren Sie diese Option. In diesem Fall werden die `INSERT..SELECT` Anweisungen im konvertierten Code AWS SCT neu geschrieben, um das Verhalten Ihrer Quelldatenbank zu emulieren.
## Einstellungen zur Optimierung der Konvertierung von Teradata nach Amazon Redshift
**Um die Einstellungen für die Konversionsoptimierung von Teradata in Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann Konvertierungseinstellungen aus.** Wählen Sie in der oberen Liste **Teradata** und dann **Teradata — Amazon Redshift** aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Teradata zu Amazon Redshift an.
Die Einstellungen für die Optimierung der Konvertierung von Teradata zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
# Verbindung der mit den AWS Schema Conversion Tool Vertica-Datenbanken herstellen
Sie können AWS SCT damit Schemas, Codeobjekte und Anwendungscode von Vertica nach Amazon Redshift konvertieren.
## Rechte für Vertica als Quelle
Für die Verwendung von Vertica als Quelle sind die folgenden Rechte erforderlich:
+ VERWENDUNG AUF SCHEMA **
+ USAGE ON SCHEMA PUBLIC
+ WÄHLEN SIE FÜR ALLE TABELLEN IM SCHEMA AUS **
+ WÄHLEN SIE ALLE SEQUENZEN IM SCHEMA AUS **
+ FÜR ALLE FUNKTIONEN IM SCHEMA AUSFÜHREN **
+ BEI DER PROZEDUR AUSFÜHREN **
Ersetzen Sie im vorherigen Beispiel die Platzhalter wie folgt:
+ *schema\$1name*Ersetzen Sie durch den Namen des Quellschemas.
+ Durch *procedure\$1name* den Namen einer Quellprozedur ersetzen. Wiederholen Sie den Zuschuss für jedes Verfahren, das Sie konvertieren.
+ Ersetzen Sie es *procedure\$1signature* durch die kommagetrennte Liste der Argumenttypen von Prozeduren.
## Verbindung zu Vertica als Quelle herstellen
Gehen Sie wie nachfolgend beschrieben vor, um mit dem AWS Schema Conversion Tool eine Verbindung zu Ihrer Vertica-Quelldatenbank herzustellen.
**So stellen Sie eine Verbindung zu einer Vertica-Quelldatenbank her**
1. Wählen Sie im AWS Schema Conversion Tool die Option **Quelle hinzufügen**.
1. Wählen Sie **Vertica** und dann **Weiter**.
Das Dialogfeld „**Quelle hinzufügen**“ wird angezeigt.
1. Geben Sie **unter Verbindungsname** einen Namen für Ihre Datenbank ein. AWS SCT zeigt diesen Namen in der Baumstruktur im linken Bereich an.
1. Verwenden Sie die Datenbankanmeldedaten von AWS Secrets Manager oder geben Sie sie manuell ein:
+ Gehen Sie wie folgt vor, um Datenbankanmeldedaten von Secrets Manager zu verwenden:
1. Wählen Sie für **AWS Secret** den Namen des Secrets aus.
1. Wählen Sie **Auffüllen**, um alle Werte im Datenbankverbindungsdialogfeld von Secrets Manager automatisch auszufüllen.
Hinweise zur Verwendung von Datenbankanmeldedaten von Secrets Manager finden Sie unter[Konfiguration AWS Secrets Manager in der AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Gehen Sie wie folgt vor, um die Verbindungsinformationen zur Vertica-Quelldatenbank manuell einzugeben:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/SchemaConversionTool/latest/userguide/CHAP_Source.Vertica.html)
1. Wählen Sie **Verbindung testen**, um zu überprüfen, ob eine Verbindung zu Ihrer Quelldatenbank hergestellt werden AWS SCT kann.
1. Wählen Sie **Connect**, um eine Verbindung zu Ihrer Quelldatenbank herzustellen.
## Einstellungen für die Konvertierung von Vertica nach Amazon Redshift
Um die Konvertierungseinstellungen von Vertica in Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen**. Wählen Sie in der oberen Liste **Vertica** und dann **Vertica — Amazon** Redshift aus. AWS SCT zeigt alle verfügbaren Einstellungen für die Konvertierung von Vertica zu Amazon Redshift an.
Die Konvertierungseinstellungen von Vertica zu Amazon Redshift AWS SCT beinhalten Optionen für Folgendes:
+ Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.
Wählen **Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem** Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.
Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie **Nur Fehler** aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie **Alle Nachrichten** aus.
+ Um die maximale Anzahl von Tabellen festzulegen, die für Ihren Amazon Redshift Redshift-Zielcluster gelten AWS SCT können.
Wählen Sie **unter Die maximale Anzahl von Tabellen für den Amazon Redshift Redshift-Zielcluster** die Anzahl der Tabellen aus, die für Ihren Amazon Redshift Redshift-Cluster gelten AWS SCT können.
Amazon Redshift verfügt über Kontingente, die die Verwendungstabellen für verschiedene Cluster-Knotentypen einschränken. Wenn Sie **Auto** wählen, AWS SCT bestimmt die Anzahl der Tabellen, die auf Ihren Amazon Redshift Redshift-Zielcluster angewendet werden sollen, je nach Knotentyp. Wählen Sie den Wert optional manuell aus. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
AWS SCT konvertiert all Ihre Quelltabellen, auch wenn das mehr ist, als Ihr Amazon Redshift Redshift-Cluster speichern kann. AWS SCT speichert den konvertierten Code in Ihrem Projekt und wendet ihn nicht auf die Zieldatenbank an. Wenn Sie beim Anwenden des konvertierten Codes das Amazon Redshift Redshift-Clusterkontingent für die Tabellen erreichen, wird eine Warnmeldung AWS SCT angezeigt. AWS SCT Wendet außerdem Tabellen auf Ihren Amazon Redshift Redshift-Zielcluster an, bis die Anzahl der Tabellen das Limit erreicht.
+ Um Partitionen der Quelltabelle in separate Tabellen in Amazon Redshift zu migrieren. Wählen Sie dazu **Use the UNION ALL-Ansicht** aus und geben Sie die maximale Anzahl von Zieltabellen ein, die für eine einzelne Quelltabelle erstellt werden AWS SCT können.
Amazon Redshift unterstützt nicht die Tabellenpartitionierung. Um dieses Verhalten zu emulieren und Abfragen schneller ausführen zu lassen, AWS SCT können Sie jede Partition Ihrer Quelltabelle in eine separate Tabelle in Amazon Redshift migrieren. AWS SCT Erstellt dann eine Ansicht, die Daten aus all diesen Tabellen enthält.
AWS SCT bestimmt automatisch die Anzahl der Partitionen in Ihrer Quelltabelle. Je nach Art der Quelltabellenpartitionierung kann diese Zahl das Kontingent für die Tabellen überschreiten, das Sie auf Ihren Amazon-Redshift-Cluster anwenden können. Um zu verhindern, dass dieses Kontingent erreicht wird, geben Sie die maximale Anzahl von Zieltabellen ein, die für Partitionen einer einzelnen Quelltabelle erstellt werden AWS SCT können. Die Standardoption ist 368 Tabellen, was einer Partition für 366 Tage im Jahr und zwei Tabellen für `NO RANGE` und `UNKNOWN` -Partitionen entspricht.
+ Um die Komprimierung auf Amazon Redshift Redshift-Tabellenspalten anzuwenden. Wählen Sie dazu **Kompressionskodierung verwenden** aus.
AWS SCT weist Spalten mithilfe des standardmäßigen Amazon Redshift Redshift-Algorithmus automatisch eine Komprimierungskodierung zu. Weitere Informationen finden Sie unter [Kompressionskodierungen](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) im *Amazon Redshift Database Developer Guide*.
Standardmäßig wendet Amazon Redshift keine Komprimierung auf Spalten an, die als Sortier- und Verteilungsschlüssel definiert sind. Sie können dieses Verhalten ändern und die Komprimierung auf diese Spalten anwenden. Wählen Sie dazu die Option **Komprimierungskodierung für KEY-Spalten verwenden** aus. Sie können diese Option nur auswählen, wenn Sie die Option **Komprimierungskodierung verwenden** auswählen.
## Einstellungen für die Optimierung der Konvertierung von Vertica nach Amazon Redshift
Um die Einstellungen für die Konvertierungsoptimierung von Vertica zu Amazon Redshift zu bearbeiten, wählen Sie **Einstellungen** in AWS SCT und dann **Konvertierungseinstellungen** aus. Wählen Sie in der oberen Liste **Vertica** und dann **Vertica — Amazon** Redshift aus. **Wählen Sie im linken Bereich Optimierungsstrategien aus.** AWS SCT zeigt Einstellungen zur Konvertierungsoptimierung für die Konvertierung von Vertica zu Amazon Redshift an.
Die Einstellungen zur Optimierung der Konvertierung von Vertica zu Amazon Redshift AWS SCT umfassen Optionen für Folgendes:
+ Um mit der automatischen Tabellenoptimierung zu arbeiten. Wählen Sie dazu **Automatische Tabellenoptimierung von Amazon Redshift verwenden** aus.
Die automatische Tabellenoptimierung ist ein sich selbst optimierender Prozess in Amazon Redshift, der das Design von Tabellen automatisch optimiert. Weitere Informationen finden Sie unter [Arbeiten mit automatischer Tabellenoptimierung](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) im *Amazon Redshift Database Developer Guide*.
Wenn Sie sich nur auf die automatische Tabellenoptimierung verlassen möchten, wählen Sie „**Keine**“ als **Strategie für die anfängliche Schlüsselauswahl**.
+ Um Sortier- und Verteilungsschlüssel anhand Ihrer Strategie auszuwählen.
Sie können Sortier- und Verteilungsschlüssel mithilfe von Amazon Redshift Redshift-Metadaten, statistischen Informationen oder beiden Optionen auswählen. Wählen Sie für **Strategie zur ersten Schlüsselauswahl** auf der Registerkarte **Optimierungsstrategien** eine der folgenden Optionen:
+ Verwenden Sie Metadaten, ignorieren Sie statistische Informationen
+ Ignorieren Sie Metadaten, verwenden Sie statistische Informationen
+ Verwenden Sie Metadaten und statistische Informationen
Je nachdem, welche Option Sie wählen, können Sie Optimierungsstrategien auswählen. Geben Sie dann für jede Strategie den Wert (0—100) ein. Diese Werte definieren das Gewicht jeder Strategie. Anhand dieser Gewichtungswerte AWS SCT wird definiert, wie sich jede Regel auf die Wahl der Verteilungs- und Sortierschlüssel auswirkt. Die Standardwerte basieren auf den bewährten Methoden für die AWS Migration.
Sie können die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu definieren. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.
+ Um Strategiedetails zu konfigurieren.
Sie können nicht nur die Gewichtung für jede Optimierungsstrategie definieren, sondern auch die Optimierungseinstellungen konfigurieren. Wählen Sie dazu **Konversionsoptimierung** aus.
+ Geben Sie unter **Limit für Sortierschlüsselspalten** die maximale Anzahl von Spalten im Sortierschlüssel ein.
+ Geben Sie für **Schrägschwellenwert** den Prozentsatz (0—100) eines schiefen Werts für eine Spalte ein. AWS SCT schließt Spalten, bei denen der Schrägwert größer als der Schwellenwert ist, aus der Kandidatenliste für den Verteilungsschlüssel aus. AWS SCT definiert den schiefen Wert für eine Spalte als das prozentuale Verhältnis der Anzahl der Vorkommen des am häufigsten vorkommenden Werts zur Gesamtzahl der Datensätze.
+ Geben Sie für die **Top N-Abfragen aus der Tabelle mit dem Abfrageverlauf** die Anzahl (1—100) der am häufigsten zu analysierenden Abfragen ein.
+ **Wählen Sie unter Statistikbenutzer** auswählen den Datenbankbenutzer aus, für den Sie die Abfragestatistiken analysieren möchten.
Außerdem können Sie auf der Registerkarte **Optimierungsstrategien** die Größe kleiner Tabellen für die Strategie „**Kleine Tabellen suchen**“ definieren. Geben Sie für **Min. Tabellenzeilenanzahl** und **Max. Tabellenzeilenanzahl** die Mindest- und Höchstanzahl von Zeilen in einer Tabelle ein, um sie als kleine Tabelle zu betrachten. AWS SCT wendet den `ALL` Verteilungsstil auf kleine Tabellen an. In diesem Fall wird eine Kopie der gesamten Tabelle an jeden Knoten verteilt.