Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# 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.