Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Connessione a un Data Warehouse Teradata con AWS Schema Conversion Tool
È possibile utilizzarli AWS SCT per convertire schemi, oggetti di codice e codice applicativo da Teradata ad Amazon Redshift o Amazon Redshift e utilizzarli in combinazione. AWS Glue
## Privilegi per Teradata come fonte
I seguenti privilegi sono necessari per utilizzare Teradata come fonte:
+ SELECT ON DBC
+ SELEZIONA SU SYSUDTLIB
+ SELEZIONA SU SYSLIB
+ SELEZIONA ON **
+ CREA PROCEDURA SU **
Nell'esempio precedente, sostituite il ** segnaposto con il nome del database di origine.
AWS SCT richiede il privilegio CREATE PROCEDURE per eseguire HELP PROCEDURE su tutte le procedure nel database di origine. AWS SCT non utilizza questo privilegio per creare nuovi oggetti nel database Teradata di origine.
## Connessione a Teradata come fonte
Utilizza la seguente procedura per connetterti al database di origine Teradata con AWS Schema Conversion Tool.
**Per connetterti a un database di origine Teradata**
1. Nel AWS Schema Conversion Tool, scegli **Aggiungi** fonte.
1. **Scegli **Teradata**, quindi scegli Avanti.**
Viene visualizzata la finestra **di dialogo Aggiungi sorgente**.
1. Per **Nome della connessione**, inserisci un nome per il tuo database. AWS SCT visualizza questo nome nell'albero nel pannello di sinistra.
1. Usa le credenziali del database da Gestione dei segreti AWS o inseriscile manualmente:
+ Per utilizzare le credenziali del database di Secrets Manager, utilizzare le seguenti istruzioni:
1. Per **AWS Segreto**, scegli il nome del segreto.
1. Scegli **Popola** per inserire automaticamente tutti i valori nella finestra di dialogo di connessione al database di Secrets Manager.
Per informazioni sull'utilizzo delle credenziali del database da Secrets Manager, vedere[Configurazione in Gestione dei segreti AWS AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Per inserire manualmente le informazioni di connessione al database di origine Teradata, utilizzare le seguenti istruzioni:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Scegli **Test Connection** per verificare che sia AWS SCT possibile connettersi al database di origine.
1. Scegli **Connect** per connetterti al tuo database di origine.
### Utilizzo dell'autenticazione LDAP con una fonte Teradata
Per configurare l'autenticazione del Lightweight Directory Access Protocol (LDAP) per gli utenti Teradata che eseguono Microsoft Active Directory in Windows, utilizza la seguente procedura.
Nella procedura seguente, il dominio Active Directory è. `test.local.com` Il server Windows è `DC` configurato con le impostazioni predefinite. Lo script seguente crea l'account `test_ldap` Active Directory e questo account utilizza la `test_ldap` password.
**Per configurare l'autenticazione LDAP per gli utenti Teradata che eseguono Microsoft Active Directory in Windows**
1. Nella directory `/opt/teradata/tdat/tdgss/site`, modifica il file `TdgssUserConfigFile.xml` . Modifica la sezione LDAP come indicato di seguito.
```
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. Applica le modifiche eseguendo la configurazione come indicato di seguito.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Testa la configurazione eseguendo il seguente comando.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
L’output visualizzato dovrebbe essere simile al seguente.
```
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. Riavvia TPA utilizzando il seguente comando.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Crea lo stesso utente nel database Teradata e in Active Directory, come illustrato di seguito.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Se si modifica la password utente in Active Directory per il proprio utente LDAP, specificare questa nuova password durante la connessione a Teradata in modalità LDAP. In modalità DEFAULT, ci si connette a Teradata utilizzando il nome utente LDAP e qualsiasi password.
## Configurazione della raccolta di statistiche nel data warehouse Teradata di origine
Per convertire il data warehouse Teradata di origine, AWS SCT utilizza le statistiche per ottimizzare il data warehouse Amazon Redshift convertito. Puoi raccogliere statistiche AWS SCT o caricare il file delle statistiche. Per ulteriori informazioni, consulta [Raccolta o caricamento di statistiche](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Per assicurarti che sia AWS SCT possibile raccogliere statistiche dal tuo data warehouse, completa le seguenti attività preliminari.
**Per raccogliere statistiche dal tuo data warehouse Teradata**
1. Esegui la seguente query per raccogliere le statistiche per tutte le tabelle del tuo data warehouse.
```
collect summary statistics on table_name;
```
Nell'esempio precedente, sostituiscilo *table\$1name* con il nome della tabella di origine. Ripeti l'interrogazione per ogni tabella che converti.
1. Esegui la seguente query per determinare la stringa dell'account per l'utente, da utilizzare per convertire il data warehouse.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Attiva la registrazione delle query per un utente specifico utilizzando la stringa dell'account dell'esempio precedente.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
In alternativa, attiva la registrazione delle query per tutti gli utenti del database.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Dopo aver completato la raccolta delle statistiche del data warehouse, disattiva la registrazione delle query. A tale scopo, è possibile utilizzare il seguente esempio di codice.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Raccolta di statistiche in modalità offline dal data warehouse Teradata di origine
Dopo aver configurato la raccolta delle statistiche nel data warehouse Teradata, puoi raccogliere statistiche nel tuo AWS SCT progetto. In alternativa, è possibile utilizzare gli script Basic Teradata Query (BTEQ) per raccogliere statistiche in modalità offline. Quindi, puoi caricare i file con le statistiche raccolte nel tuo progetto. AWS SCT Per ulteriori informazioni, consulta [Raccolta o caricamento di statistiche](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Per raccogliere statistiche dal data warehouse Teradata in modalità offline**
1. Crea lo `off-line_stats.bteq` script con il seguente contenuto.
```
.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. Create il `td_run_bteq.bat` file che esegue lo script BTEQ creato nel passaggio precedente. Utilizza il seguente contenuto per questo file.
```
@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. Crea il `runme.bat` file che esegue il file batch creato nel passaggio precedente. Utilizza il seguente contenuto per questo file.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
Nel `runme.bat` file *ServerName**UserName*, sostituisci e *DatabaseName* con i valori applicabili.
Quindi, esegui il `runme.bat` file. Ripeti questo passaggio per ogni data warehouse convertito in Amazon Redshift.
Dopo aver eseguito questo script, ricevi tre file con statistiche per ogni database. Puoi caricare questi file nel tuo AWS SCT progetto. Per farlo, scegli il tuo data warehouse dal pannello di sinistra del progetto e apri il menu contestuale (fai clic con il pulsante destro del mouse). Scegli **Statistiche di caricamento**.
## Impostazioni di conversione da Teradata ad Amazon Redshift
**Per modificare le impostazioni di conversione da Teradata ad Amazon Redshift, **scegli Impostazioni AWS SCT in, quindi scegli** Impostazioni di conversione.** Dall'elenco in alto, scegli **Teradata**, quindi scegli **Teradata — Amazon** Redshift. AWS SCT mostra tutte le impostazioni disponibili per la conversione da Teradata ad Amazon Redshift.
Le impostazioni AWS SCT di conversione da Teradata ad Amazon Redshift includono opzioni per quanto segue:
+ Per limitare il numero di commenti con azioni nel codice convertito.
Per **Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore**, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.
Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli **Solo errori**. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli **Tutti i messaggi**.
+ Per impostare il numero massimo di tabelle che AWS SCT possono essere applicate al cluster Amazon Redshift di destinazione.
Per **Il numero massimo di tabelle per il cluster Amazon Redshift di destinazione**, scegli il numero di tabelle da AWS SCT applicare al tuo cluster Amazon Redshift.
Amazon Redshift dispone di quote che limitano l'utilizzo delle tabelle per diversi tipi di nodo cluster. Se scegli **Auto**, AWS SCT determina il numero di tabelle da applicare al cluster Amazon Redshift di destinazione in base al tipo di nodo. Facoltativamente, scegli il valore manualmente. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
AWS SCT converte tutte le tabelle di origine, anche se è superiore a quella che il cluster Amazon Redshift può archiviare. AWS SCT memorizza il codice convertito nel progetto e non lo applica al database di destinazione. Se raggiungi la quota del cluster Amazon Redshift per le tabelle quando applichi il codice convertito, viene AWS SCT visualizzato un messaggio di avviso. Inoltre, AWS SCT applica le tabelle al cluster Amazon Redshift di destinazione fino a quando il numero di tabelle raggiunge il limite.
+ Per migrare le partizioni della tabella di origine in tabelle separate in Amazon Redshift. A tale scopo, seleziona **Usa la vista UNION ALL** e inserisci il numero massimo di tabelle di destinazione che AWS SCT puoi creare per una singola tabella di origine.
Amazon Redshift non supporta il partizionamento della tabella. Per emulare questo comportamento e velocizzare l'esecuzione delle query, AWS SCT puoi migrare ogni partizione della tabella di origine in una tabella separata in Amazon Redshift. Quindi, AWS SCT crea una vista che include i dati di tutte queste tabelle.
AWS SCT determina automaticamente il numero di partizioni nella tabella di origine. A seconda del tipo di partizionamento della tabella di origine, questo numero può superare la quota delle tabelle che puoi applicare al cluster Amazon Redshift. Per evitare di raggiungere questa quota, inserite il numero massimo di tabelle di destinazione che è AWS SCT possibile creare per le partizioni di una singola tabella di origine. L'opzione predefinita è 368 tabelle, che rappresenta una partizione per 366 giorni all'anno e due tabelle per e partizioni. `NO RANGE` `UNKNOWN`
+ Per applicare la compressione alle colonne delle tabelle di Amazon Redshift. Per farlo, seleziona **Usa la codifica di compressione.**
AWS SCT assegna automaticamente la codifica di compressione alle colonne utilizzando l'algoritmo Amazon Redshift predefinito. Per ulteriori informazioni, consulta le [codifiche di compressione](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) nella *Amazon Redshift Database* Developer Guide.
Per impostazione predefinita, Amazon Redshift non applica la compressione alle colonne definite come chiavi di ordinamento e distribuzione. Puoi modificare questo comportamento e applicare la compressione a queste colonne. Per farlo, seleziona **Usa la codifica di compressione per le colonne KEY**. È possibile selezionare questa opzione solo quando si seleziona l'opzione **Usa codifica di compressione**.
+ Per utilizzare un elenco esplicito di colonne nel codice convertito per le `SELECT *` istruzioni, seleziona **Usa dichiarazione esplicita** di colonna.
+ Per emulare il comportamento delle chiavi primarie e univoche nel tuo cluster Amazon Redshift, **seleziona Emula il comportamento delle chiavi primarie** e uniche.
Amazon Redshift non impone chiavi uniche e primarie e le utilizza solo a scopo informativo. Se utilizzi questi vincoli nel codice, assicurati che il loro comportamento venga AWS SCT emulato nel codice convertito.
+ Per garantire l'unicità dei dati nelle tabelle Amazon Redshift di destinazione. Per farlo, seleziona **Emula il comportamento delle tabelle SET**.
Teradata crea tabelle utilizzando l'elemento di `SET` sintassi come opzione predefinita. Non è possibile aggiungere righe duplicate in una tabella. `SET` Se il codice sorgente non utilizza questo vincolo di unicità, disattiva questa opzione. In questo caso, il codice convertito funziona più velocemente.
Se il codice sorgente utilizza l'`SET`opzione nelle tabelle come vincolo di unicità, attiva questa opzione. In questo caso, AWS SCT riscrive `INSERT..SELECT` le istruzioni nel codice convertito per emulare il comportamento del database di origine.
## Impostazioni di ottimizzazione della conversione da Teradata ad Amazon Redshift
**Per modificare le impostazioni di ottimizzazione delle conversioni da Teradata ad Amazon Redshift, **scegli** Impostazioni AWS SCT in, quindi scegli Impostazioni di conversione.** Dall'elenco in alto, scegli **Teradata**, quindi scegli **Teradata — Amazon** Redshift. **Nel riquadro di sinistra, scegli Strategie di ottimizzazione.** AWS SCT visualizza le impostazioni di ottimizzazione della conversione per la conversione da Teradata ad Amazon Redshift.
Le impostazioni AWS SCT di ottimizzazione della conversione da Teradata ad Amazon Redshift includono opzioni per quanto segue:
+ Per utilizzare l'ottimizzazione automatica delle tabelle. A tale scopo, seleziona **Usa l'ottimizzazione automatica delle tabelle di Amazon Redshift**.
L'ottimizzazione automatica delle tabelle è un processo di ottimizzazione automatica in Amazon Redshift che ottimizza automaticamente la progettazione delle tabelle. Per ulteriori informazioni, consulta [Lavorare con l'ottimizzazione automatica delle tabelle](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) nella *Amazon Redshift Database Developer Guide*.
Per fare affidamento solo sull'ottimizzazione automatica delle tabelle, scegli **Nessuno** per la **strategia iniziale di selezione delle chiavi**.
+ Per scegliere le chiavi di ordinamento e distribuzione utilizzando la tua strategia.
Puoi scegliere le chiavi di ordinamento e distribuzione utilizzando i metadati di Amazon Redshift, le informazioni statistiche o entrambe le opzioni. Per la **strategia di selezione delle chiavi iniziale** nella scheda **Strategie di ottimizzazione**, scegli una delle seguenti opzioni:
+ Usa i metadati, ignora le informazioni statistiche
+ Ignora i metadati, usa le informazioni statistiche
+ Usa metadati e informazioni statistiche
A seconda dell'opzione scelta, puoi selezionare strategie di ottimizzazione. Quindi, per ogni strategia, inserisci il valore (0—100). Questi valori definiscono il peso di ogni strategia. L'utilizzo di questi valori di peso AWS SCT definisce in che modo ciascuna regola influisce sulla scelta delle chiavi di distribuzione e ordinamento. I valori predefiniti si basano sulle best practice di AWS migrazione.
È possibile definire la dimensione delle tabelle piccole per la strategia **Find small tables**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per definirla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione alle tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.
+ Per configurare i dettagli della strategia.
Oltre a definire il peso per ogni strategia di ottimizzazione, puoi configurare le impostazioni di ottimizzazione. Per farlo, scegli **Ottimizzazione delle conversioni**.
+ Per il **limite delle colonne chiave di ordinamento**, inserisci il numero massimo di colonne nella chiave di ordinamento.
+ Per **Valore di soglia asimmetrico**, inserite la percentuale (0—100) di un valore distorto per una colonna. AWS SCT esclude le colonne con un valore di inclinazione superiore alla soglia dall'elenco dei candidati per la chiave di distribuzione. AWS SCT definisce il valore inclinato di una colonna come rapporto percentuale tra il numero di occorrenze del valore più comune e il numero totale di record.
+ Per le **prime N interrogazioni della tabella della cronologia delle interrogazioni, immettete il numero (da** 1 a 100) delle query più utilizzate da analizzare.
+ Per **Seleziona utente statistico**, scegli l'utente del database per il quale desideri analizzare le statistiche delle query.
Inoltre, nella scheda **Strategie di ottimizzazione**, puoi definire la dimensione delle piccole tabelle per la strategia **Trova tabelle piccole**. Per Numero **minimo di righe nella tabella e Numero** **massimo di righe** nella tabella, inserisci il numero minimo e massimo di righe in una tabella per considerarla come una tabella piccola. AWS SCT applica lo stile `ALL` di distribuzione a tabelle di piccole dimensioni. In questo caso, una copia dell'intera tabella viene distribuita su ogni nodo.