Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Connexion à un entrepôt de données Teradata à l'aide du AWS Schema Conversion Tool
Vous pouvez les utiliser AWS SCT pour convertir des schémas, des objets de code et du code d'application de Teradata vers Amazon Redshift ou Amazon Redshift et les utiliser en combinaison. AWS Glue
## Privilèges accordés à Teradata en tant que source
Les privilèges suivants sont requis pour utiliser Teradata en tant que source :
+ SELECT ON DBC
+ SÉLECTIONNEZ SUR SYSUDTLIB
+ SÉLECTIONNER SUR SYSLIB
+ SÉLECTIONNEZ SUR **
+ CRÉER UNE PROCÉDURE SUR **
Dans l'exemple précédent, remplacez l'**espace réservé par le nom de la base de données source.
AWS SCT nécessite le privilège CREATE PROCEDURE pour exécuter HELP PROCEDURE sur toutes les procédures de la base de données source. AWS SCT n'utilise pas ce privilège pour créer de nouveaux objets dans votre base de données Teradata source.
## Connexion à Teradata en tant que source
Utilisez la procédure suivante pour vous connecter à votre base de données source Teradata avec AWS Schema Conversion Tool.
**Pour vous connecter à une base de données source Teradata**
1. Dans le AWS Schema Conversion Tool, choisissez **Ajouter une source**.
1. Choisissez **Teradata**, puis **Next**.
La boîte de dialogue **Ajouter une source** apparaît.
1. Dans **Nom de connexion**, entrez le nom de votre base de données. AWS SCT affiche ce nom dans l'arborescence du panneau de gauche.
1. Utilisez les informations d'identification de la base de données AWS Secrets Manager ou saisissez-les manuellement :
+ Pour utiliser les informations d'identification de base de données issues de Secrets Manager, suivez les instructions suivantes :
1. Pour **AWS Secret**, choisissez le nom du secret.
1. Choisissez **Populer pour renseigner** automatiquement toutes les valeurs dans la boîte de dialogue de connexion à la base de données depuis Secrets Manager.
Pour plus d'informations sur l'utilisation des informations d'identification de base de données depuis Secrets Manager, consultez[Configuration AWS Secrets Manager dans AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Pour saisir manuellement les informations de connexion à la base de données source Teradata, suivez les instructions suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Choisissez **Tester la connexion** pour vérifier que AWS SCT vous pouvez vous connecter à votre base de données source.
1. Choisissez **Connect pour vous** connecter à votre base de données source.
### Utilisation de l'authentification LDAP avec une source Teradata
Pour configurer l'authentification LDAP (Lightweight Directory Access Protocol) pour les utilisateurs Teradata qui exécutent Microsoft Active Directory sous Windows, utilisez la procédure suivante.
Dans la procédure suivante, le domaine Active Directory est`test.local.com`. Le serveur Windows l'est`DC`, et il est configuré avec les paramètres par défaut. Le script suivant crée le compte `test_ldap` Active Directory, qui utilise le `test_ldap` mot de passe.
**Pour configurer l'authentification LDAP pour les utilisateurs de Teradata qui exécutent Microsoft Active Directory sous Windows**
1. Dans le répertoire `/opt/teradata/tdat/tdgss/site`, modifiez le fichier `TdgssUserConfigFile.xml`. Modifiez la section LDAP comme suit.
```
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. Appliquez les modifications en exécutant la configuration comme suit.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Testez la configuration en exécutant la commande suivante.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
La sortie doit ressembler à ce qui suit.
```
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. Redémarrez TPA à l'aide de la commande suivante.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Créez le même utilisateur dans la base de données Teradata que dans Active Directory, comme indiqué ci-dessous.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Si vous modifiez le mot de passe utilisateur dans Active Directory pour votre utilisateur LDAP, spécifiez ce nouveau mot de passe lors de la connexion à Teradata en mode LDAP. En mode DEFAULT, vous vous connectez à Teradata en utilisant le nom d'utilisateur LDAP et n'importe quel mot de passe.
## Configuration de la collecte de statistiques dans votre entrepôt de données Teradata source
Pour convertir votre entrepôt de données Teradata source, utilisez AWS SCT des statistiques pour optimiser votre entrepôt de données Amazon Redshift converti. Vous pouvez collecter des statistiques dans le fichier de statistiques AWS SCT ou le télécharger. Pour de plus amples informations, veuillez consulter [Collecte ou téléchargement de statistiques](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Pour être sûr de AWS SCT pouvoir collecter des statistiques à partir de votre entrepôt de données, effectuez les tâches préalables suivantes.
**Pour collecter des statistiques à partir de votre entrepôt de données Teradata**
1. Exécutez la requête suivante pour recueillir les statistiques de toutes les tables de votre entrepôt de données.
```
collect summary statistics on table_name;
```
Dans l'exemple précédent, remplacez *table\$1name* par le nom de votre table source. Répétez la requête pour chaque table que vous convertissez.
1. Exécutez la requête suivante pour déterminer la chaîne de compte de l'utilisateur, que vous utiliserez pour convertir votre entrepôt de données.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Activez la journalisation des requêtes pour un utilisateur spécifique à l'aide de la chaîne de compte de l'exemple précédent.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
Vous pouvez également activer la journalisation des requêtes pour tous les utilisateurs de la base de données.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Une fois que vous avez terminé de collecter les statistiques de l'entrepôt de données, désactivez l'enregistrement des requêtes. Pour ce faire, vous pouvez utiliser l'exemple de code suivant.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Collecte de statistiques en mode hors ligne à partir de votre entrepôt de données Teradata source
Après avoir configuré la collecte de statistiques dans votre entrepôt de données Teradata, vous pouvez collecter des statistiques dans votre AWS SCT projet. Vous pouvez également utiliser des scripts BTEQ (Basic Teradata Query) pour collecter des statistiques en mode hors ligne. Vous pouvez ensuite télécharger les fichiers contenant les statistiques collectées dans votre AWS SCT projet. Pour de plus amples informations, veuillez consulter [Collecte ou téléchargement de statistiques](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Pour collecter des statistiques à partir de votre entrepôt de données Teradata en mode hors ligne**
1. Créez le `off-line_stats.bteq` script avec le contenu suivant.
```
.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. Créez le `td_run_bteq.bat` fichier qui exécute le script BTEQ que vous avez créé à l'étape précédente. Utilisez le contenu suivant pour ce fichier.
```
@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. Créez le `runme.bat` fichier qui exécute le fichier batch que vous avez créé à l'étape précédente. Utilisez le contenu suivant pour ce fichier.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
Dans le `runme.bat` fichier, remplacez *ServerName**UserName*, et *DatabaseName* par les valeurs applicables.
Exécutez ensuite le `runme.bat` fichier. Répétez cette étape pour chaque entrepôt de données que vous convertissez en Amazon Redshift.
Après avoir exécuté ce script, vous recevez trois fichiers contenant des statistiques pour chaque base de données. Vous pouvez télécharger ces fichiers dans votre AWS SCT projet. Pour ce faire, choisissez votre entrepôt de données dans le panneau de gauche de votre projet et ouvrez le menu contextuel (clic droit). Choisissez **Upload Statistics**.
## Paramètres de conversion de Teradata vers Amazon Redshift
**Pour modifier les paramètres de conversion de Teradata vers Amazon Redshift, **choisissez** Paramètres AWS SCT dans, puis sélectionnez Paramètres de conversion.** Dans la liste supérieure, choisissez **Teradata**, puis **Teradata — Amazon Redshift**. AWS SCT affiche tous les paramètres disponibles pour la conversion de Teradata vers Amazon Redshift.
Les paramètres de conversion de Teradata vers Amazon Redshift incluent des options pour AWS SCT les éléments suivants :
+ Pour limiter le nombre de commentaires contenant des actions dans le code converti.
Pour **Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure**, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la sévérité est sélectionnée ou supérieure.
Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez **Erreurs uniquement**. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez **Tous les messages**.
+ Pour définir le nombre maximum de tables AWS SCT pouvant s'appliquer à votre cluster Amazon Redshift cible.
Pour **le nombre maximum de tables pour le cluster Amazon Redshift cible**, choisissez le nombre de tables qui AWS SCT peuvent s'appliquer à votre cluster Amazon Redshift.
Amazon Redshift dispose de quotas qui limitent l’utilisation des tables pour différents types de nœud de cluster. Si vous choisissez **Auto**, AWS SCT détermine le nombre de tables à appliquer à votre cluster Amazon Redshift cible en fonction du type de nœud. Vous pouvez éventuellement choisir la valeur manuellement. Pour plus d’informations, consultez [Quotas et limites dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dans le *Guide de gestion Amazon Redshift*.
AWS SCT convertit toutes vos tables sources, même si c'est plus que ce que votre cluster Amazon Redshift peut stocker. AWS SCT stocke le code converti dans votre projet et ne l'applique pas à la base de données cible. Si vous atteignez le quota de cluster Amazon Redshift pour les tables lorsque vous appliquez le code converti, un message d'avertissement s' AWS SCT affiche. AWS SCT Applique également des tables à votre cluster Amazon Redshift cible jusqu'à ce que le nombre de tables atteigne la limite.
+ Pour migrer des partitions de la table source vers des tables séparées dans Amazon Redshift. Pour ce faire, sélectionnez **Utiliser la vue UNION ALL** et entrez le nombre maximum de tables cibles AWS SCT pouvant être créées pour une seule table source.
Amazon Redshift ne prend pas en charge le partitionnement des tables. Pour imiter ce comportement et accélérer l'exécution des requêtes, AWS SCT vous pouvez migrer chaque partition de votre table source vers une table distincte dans Amazon Redshift. AWS SCT Crée ensuite une vue qui inclut les données de toutes ces tables.
AWS SCT détermine automatiquement le nombre de partitions de votre table source. Selon le type de partitionnement de votre table source, ce nombre peut dépasser le quota de tables que vous pouvez appliquer à votre cluster Amazon Redshift. Pour éviter d'atteindre ce quota, entrez le nombre maximum de tables cibles AWS SCT pouvant être créées pour les partitions d'une seule table source. L'option par défaut est 368 tables, ce qui représente une partition pendant 366 jours par an et deux tables pour `NO RANGE` et `UNKNOWN` partitions.
+ Pour appliquer une compression aux colonnes d'un tableau Amazon Redshift. Pour ce faire, sélectionnez **Utiliser le codage par compression**.
AWS SCT attribue automatiquement un codage de compression aux colonnes à l'aide de l'algorithme Amazon Redshift par défaut. Pour plus d'informations, consultez la section [Encodages de compression](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) dans le manuel *Amazon Redshift Database* Developer Guide.
Par défaut, Amazon Redshift n'applique pas de compression aux colonnes définies comme clés de tri et de distribution. Vous pouvez modifier ce comportement et appliquer une compression à ces colonnes. Pour ce faire, sélectionnez **Utiliser le codage de compression pour les colonnes KEY**. Vous ne pouvez sélectionner cette option que lorsque vous sélectionnez l'option **Utiliser le codage par compression**.
+ Pour utiliser une liste explicite de colonnes dans le code converti pour les `SELECT *` instructions, sélectionnez **Utiliser une déclaration de colonne explicite**.
+ Pour émuler le comportement des clés primaires et uniques dans votre cluster Amazon Redshift, **sélectionnez Émuler le comportement des clés primaires** et uniques.
Amazon Redshift n'applique pas les clés uniques et primaires et ne les utilise qu'à des fins d'information. Si vous utilisez ces contraintes dans votre code, assurez-vous qu'elles AWS SCT imitent leur comportement dans le code converti.
+ Pour garantir l'unicité des données dans les tables Amazon Redshift cibles. Pour ce faire, sélectionnez **Émuler le comportement des tables SET**.
Teradata crée des tables en utilisant l'élément de `SET` syntaxe comme option par défaut. Vous ne pouvez pas ajouter de lignes dupliquées dans un `SET` tableau. Si votre code source n'utilise pas cette contrainte d'unicité, désactivez cette option. Dans ce cas, le code converti fonctionne plus rapidement.
Si votre code source utilise l'`SET`option dans les tables comme contrainte d'unicité, activez cette option. Dans ce cas, AWS SCT réécrit `INSERT..SELECT` les instructions dans le code converti pour imiter le comportement de votre base de données source.
## Paramètres d'optimisation de la conversion entre Teradata et Amazon Redshift
**Pour modifier les paramètres d'optimisation de conversion de Teradata vers Amazon Redshift, **choisissez** Paramètres AWS SCT dans, puis sélectionnez Paramètres de conversion.** Dans la liste supérieure, choisissez **Teradata**, puis **Teradata — Amazon Redshift**. Dans le volet de gauche, sélectionnez **Stratégies d'optimisation**. AWS SCT affiche les paramètres d'optimisation de conversion pour la conversion de Teradata vers Amazon Redshift.
Les paramètres AWS SCT d'optimisation de la conversion de Teradata vers Amazon Redshift incluent des options pour les éléments suivants :
+ Pour travailler avec l'optimisation automatique des tables. Pour ce faire, sélectionnez **Utiliser le réglage automatique des tables Amazon Redshift**.
L'optimisation automatique des tables est un processus de réglage automatique dans Amazon Redshift qui optimise automatiquement la conception des tables. Pour plus d'informations, consultez la section [Utilisation de l'optimisation automatique des tables](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) dans le manuel *Amazon Redshift Database Developer Guide*.
Pour vous fier uniquement à l'optimisation automatique des tables, choisissez **Aucune** pour la **stratégie initiale de sélection des clés**.
+ Pour choisir les clés de tri et de distribution selon votre stratégie.
Vous pouvez choisir des clés de tri et de distribution à l'aide des métadonnées Amazon Redshift, des informations statistiques ou des deux options. Pour **Stratégie initiale de sélection des clés** dans l'onglet **Stratégies d'optimisation**, choisissez l'une des options suivantes :
+ Utiliser des métadonnées, ignorer les informations statistiques
+ Ignorer les métadonnées, utiliser des informations statistiques
+ Utiliser des métadonnées et des informations statistiques
Selon l'option que vous choisissez, vous pouvez sélectionner des stratégies d'optimisation. Entrez ensuite la valeur (0 à 100) pour chaque stratégie. Ces valeurs définissent le poids de chaque stratégie. À l'aide de ces valeurs de pondération, AWS SCT définit l'influence de chaque règle sur le choix des clés de distribution et de tri. Les valeurs par défaut sont basées sur les meilleures pratiques de AWS migration.
Vous pouvez définir la taille des petites tables dans le cadre de la stratégie **Find small tables**. Pour Nombre **minimum de lignes de tableau et Nombre** **maximum de lignes** de tableau, entrez le nombre minimum et maximum de lignes dans un tableau pour le définir comme un petit tableau. AWS SCT applique le style `ALL` de distribution aux petites tables. Dans ce cas, une copie de la table complète est distribuée à chaque nœud.
+ Pour configurer les détails de la stratégie.
Outre la définition du poids pour chaque stratégie d'optimisation, vous pouvez configurer les paramètres d'optimisation. Pour ce faire, choisissez **Optimisation des conversions**.
+ Pour le **champ Limite des colonnes clés de tri**, entrez le nombre maximum de colonnes dans la clé de tri.
+ Pour une **valeur de seuil asymétrique**, entrez le pourcentage (0 à 100) d'une valeur asymétrique pour une colonne. AWS SCT exclut les colonnes dont la valeur d'inclinaison est supérieure au seuil de la liste des candidats pour la clé de distribution. AWS SCT définit la valeur asymétrique d'une colonne comme le pourcentage entre le nombre d'occurrences de la valeur la plus courante et le nombre total d'enregistrements.
+ Pour les **N principales requêtes de la table d'historique** des requêtes, entrez le nombre (1 à 100) des requêtes les plus fréquemment utilisées à analyser.
+ Pour **Sélectionner un utilisateur de statistiques**, choisissez l'utilisateur de base de données pour lequel vous souhaitez analyser les statistiques de requête.
Dans l'onglet **Stratégies d'optimisation**, vous pouvez également définir la taille des petites tables pour la stratégie **Rechercher de petites tables**. Pour Nombre **minimal de lignes de tableau et Nombre** **maximal de lignes** de tableau, entrez le nombre minimum et maximum de lignes dans un tableau pour le considérer comme un petit tableau. AWS SCT applique le style `ALL` de distribution aux petites tables. Dans ce cas, une copie de la table complète est distribuée à chaque nœud.