As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Conectando-se a um data warehouse da Teradata com o AWS Schema Conversion Tool
Você pode usar AWS SCT para converter esquemas, objetos de código e código de aplicativo da Teradata para o Amazon Redshift ou Amazon Redshift e usá-los em combinação. AWS Glue
## Privilégios do Teradata como origem
Os privilégios obrigatórios para Teradata como origem são listados a seguir:
+ SELECT ON DBC
+ SELECT ON SYSUDTLIB
+ SELECT ON SYSLIB
+ SELECIONE ATIVADO **
+ CRIAR PROCEDIMENTO EM **
No exemplo anterior, substitua o espaço reservado ** pelo nome do banco de dados de origem.
AWS SCT requer o privilégio CREATE PROCEDURE para executar HELP PROCEDURE em todos os procedimentos no banco de dados de origem. AWS SCT não usa esse privilégio para criar novos objetos no banco de dados Teradata de origem.
## Como se conectar ao Teradata como origem
Use o procedimento a seguir para conectar seu banco de dados de origem do Teradata com a AWS Schema Conversion Tool.
**Para conectar-se a um banco de dados de origem Teradata**
1. No AWS Schema Conversion Tool, escolha **Adicionar fonte**.
1. Escolha **Teradata** e, em seguida, escolha **Avançar**.
A caixa de diálogo **Adicionar origem** é exibida.
1. Em **Nome da conexão**, insira um nome para o banco de dados. A AWS SCT exibe esse nome na árvore no painel esquerdo.
1. Use as credenciais do banco de dados AWS Secrets Manager ou insira-as manualmente:
+ Para usar as credenciais do banco de dados do Secrets Manager, use as instruções a seguir:
1. Em **Segredo da AWS **, escolha o nome do seu segredo.
1. Escolha **Preencher** para preencher automaticamente todos os valores na caixa de diálogo de conexão do banco de dados do Secrets Manager.
Para obter informações sobre o uso de credenciais de banco de dados do Secrets Manager, consulte a [Configurando AWS Secrets Manager no AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Para inserir manualmente as informações de conexão do banco de dados do Teradata de origem, use as instruções a seguir:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Escolha **Testar conexão** para verificar se AWS SCT pode se conectar ao seu banco de dados de origem.
1. Escolha **Conectar** para se conectar ao banco de dados de origem.
### Usar autenticação LDAP com um Teradata de origem
Para configurar a autenticação Lightweight Directory Access Protocol (LDAP) para usuários Teradata que executam o Microsoft Active Directory no Windows, use o procedimento a seguir.
No procedimento a seguir, o domínio do Active Directory é `test.local.com`. O servidor do Windows é `DC` e está configurado com as configurações padrão. O script a seguir cria a conta no Active Directory `test_ldap` e essa conta usa a senha `test_ldap`.
**Para configurar a autenticação LDAP para usuários do Teradata que executam o Microsoft Active Directory no Windows**
1. No diretório `/opt/teradata/tdat/tdgss/site`, edite o arquivo `TdgssUserConfigFile.xml`. Altere a seção LDAP para o seguinte:
```
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. Aplique as alterações executando a configuração a seguir.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Teste a configuração executando o comando a seguir.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
A saída deve ser semelhante a esta.
```
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. Reinicie o TPA usando o comando a seguir.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Crie o mesmo usuário no banco de dados Teradata como no Active Directory, conforme mostrado a seguir.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Se você alterar a senha de usuário no Active Directory do seu usuário LDAP, especifique essa nova senha durante a conexão ao Teradata em modo LDAP. No modo PADRÃO, você se conecta ao Teradata usando o nome de usuário LDAP e qualquer senha.
## Como configurar a coleta de estatísticas em seu data warehouse do Teradata de origem
Para converter seu armazém de dados Teradata de origem, AWS SCT usa estatísticas para otimizar seu armazém de dados convertido do Amazon Redshift. Você pode coletar estatísticas em AWS SCT ou fazer o upload do arquivo de estatísticas. Para obter mais informações, consulte [Como coletar ou carregar as estatísticas](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Para garantir que AWS SCT possa coletar estatísticas do seu data warehouse, conclua as seguintes tarefas de pré-requisito.
**Para coletar estatísticas do seu data warehouse do Teradata**
1. Execute a consulta a seguir para recuperar as estatísticas de todas as tabelas em seu data warehouse.
```
collect summary statistics on table_name;
```
No exemplo anterior, *table\$1name* substitua pelo nome da tabela de origem. Repita a consulta para cada tabela que você converter.
1. Execute a consulta a seguir para determinar a string da conta do usuário, que você usa para converter seu data warehouse.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Ative o registro de consultas para um usuário específico usando a string da conta do exemplo anterior.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
Como alternativa, ative o registro de consultas para todos os usuários do banco de dados.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Depois de concluir a coleta das estatísticas do data warehouse, desative o registro de consultas. Para fazer isso, você pode usar o exemplo de código a seguir.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Como coletar estatísticas em modo off-line do seu data warehouse do Teradata de origem
Depois de configurar a coleta de estatísticas em seu data warehouse Teradata, você pode coletar estatísticas em seu AWS SCT projeto. Como alternativa, você pode usar scripts Basic Teradata Query (BTEQ) para coletar estatísticas em um modo off-line. Em seguida, você pode fazer o upload dos arquivos com as estatísticas coletadas para o seu projeto da AWS SCT . Para obter mais informações, consulte [Como coletar ou carregar as estatísticas](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Para coletar estatísticas do seu data warehouse do Teradata em um modo off-line**
1. Crie o script `off-line_stats.bteq` com o conteúdo a seguir.
```
.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. Crie o arquivo `td_run_bteq.bat` que executa o script BTEQ que você criou na etapa anterior. Use o conteúdo a seguir para esse arquivo.
```
@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. Crie o arquivo `runme.bat` que executa o arquivo de lote que você criou na etapa anterior. Use o conteúdo a seguir para esse arquivo.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
No `runme.bat` arquivo, substitua *ServerName**UserName*, e *DatabaseName* pelos valores aplicáveis.
Em seguida, execute o arquivo `runme.bat`. Repita essa etapa para cada data warehouse que você converter para o Amazon Redshift.
Depois de executar esse script, você recebe três arquivos com estatísticas para cada banco de dados. Você pode fazer o upload desses arquivos para o seu AWS SCT projeto. Para fazer isso, escolha seu data warehouse no painel esquerdo do projeto e abra o menu contextual (clique com o botão direito do mouse). Escolha **Fazer upload estatísticas**.
## Configurações de conversão do Teradata para o Amazon Redshift
**Para editar as configurações de conversão do Teradata para o Amazon Redshift, escolha Configurações em e, AWS SCT em seguida, **escolha** Configurações de conversão.** Na lista superior, escolha **Teradata** e, em seguida, escolha **Teradata — Amazon Redshift**. AWS SCT exibe todas as configurações disponíveis para conversão de Teradata para Amazon Redshift.
As configurações AWS SCT de conversão de Teradata para Amazon Redshift incluem opções para o seguinte:
+ Para limitar o número de comentários com itens de ação no código convertido.
Em **Adicionar comentários no código convertido para os itens de ação de severidade selecionada e superior**, escolha a severidade dos itens de ação. AWS SCT adiciona comentários no código convertido para itens de ação da severidade selecionada e superior.
Por exemplo, para minimizar o número de comentários em seu código convertido, escolha **Somente erros**. Para incluir comentários para todos os itens de ação em seu código convertido, escolha **Todas as mensagens**.
+ Para definir o número máximo de tabelas que AWS SCT podem ser aplicadas ao seu cluster de destino do Amazon Redshift.
Em **O número máximo de tabelas para o cluster de destino do Amazon Redshift**, escolha o número de tabelas que AWS SCT podem ser aplicadas ao seu cluster do Amazon Redshift.
O Amazon Redshift tem cotas que limitam as tabelas de uso para diferentes tipos de nós de cluster. Se você escolher **Auto**, AWS SCT determinará o número de tabelas a serem aplicadas ao seu cluster de destino do Amazon Redshift, dependendo do tipo de nó. Opcionalmente, escolha o valor manualmente. Para obter mais informações, consulte “[Cotas e limites no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html)” no *Guia de gerenciamento de clusters do Amazon Redshift*.
AWS SCT converte todas as suas tabelas de origem, mesmo que isso seja mais do que o seu cluster do Amazon Redshift pode armazenar. AWS SCT armazena o código convertido em seu projeto e não o aplica ao banco de dados de destino. Se você atingir a cota de cluster do Amazon Redshift para as tabelas ao aplicar o código convertido, a AWS SCT exibirá uma mensagem de aviso. Além disso, AWS SCT aplica tabelas ao seu cluster de destino do Amazon Redshift até que o número de tabelas atinja o limite.
+ Para migrar partições da tabela de origem para tabelas separadas no Amazon Redshift. Para fazer isso, selecione **Usar a exibição UNION ALL** e insira o número máximo de tabelas de destino que a AWS SCT pode criar para uma única tabela de origem.
O Amazon Redshift não oferece suporte ao particionamento de tabelas. Para emular esse comportamento e acelerar a execução das consultas, AWS SCT você pode migrar cada partição da sua tabela de origem para uma tabela separada no Amazon Redshift. Em seguida, AWS SCT cria uma exibição que inclui dados de todas essas tabelas.
AWS SCT determina automaticamente o número de partições na tabela de origem. Dependendo do tipo de particionamento da tabela de origem, esse número pode exceder a cota das tabelas que você pode aplicar ao seu cluster do Amazon Redshift. Para evitar atingir essa cota, insira o número máximo de tabelas de destino que AWS SCT podem ser criadas para partições de uma única tabela de origem. A opção padrão é 368 tabelas, que representam uma partição para 366 dias do ano e duas tabelas para partições `NO RANGE` e `UNKNOWN`.
+ Para aplicar compactação às colunas da tabela do Amazon Redshift. Para fazer isso, selecione **Usar codificação de compressão**.
AWS SCT atribui a codificação de compactação às colunas automaticamente usando o algoritmo padrão do Amazon Redshift. Para obter mais informações, consulte [Codificações de compactação](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Por padrão, o Amazon Redshift não aplica compactação a colunas definidas como chaves de classificação e distribuição. É possível alterar esse comportamento e aplicar compactação a essas colunas. Para fazer isso, selecione **Usar codificação de compactação para colunas KEY**. Você pode selecionar essa opção somente ao selecionar a opção **Usar codificação de compactação**.
+ Para usar uma lista explícita de colunas no código convertido para as instruções `SELECT *`, selecione **Usar instrução de coluna explícita**.
+ Para emular o comportamento das chaves primárias e exclusivas em seu cluster do Amazon Redshift, selecione **Emular o comportamento das chaves primárias e exclusivas**.
O Amazon Redshift não impõe chaves exclusivas e primárias e as usa apenas para fins informativos. Se você usar essas restrições em seu código, certifique-se de que AWS SCT emula o comportamento delas no código convertido.
+ Para garantir a exclusividade dos dados nas tabelas do Amazon Redshift de destino. Para fazer isso, selecione **Emular o comportamento das tabelas SET**.
O Teradata cria tabelas usando o elemento de sintaxe `SET` como opção padrão. Você não pode adicionar linhas duplicadas em uma tabela `SET`. Se o código-fonte não usar essa restrição de exclusividade, desative essa opção. Nesse caso, o código convertido funciona mais rápido.
Se o código-fonte usa a opção `SET` em tabelas como uma restrição de exclusividade, ative essa opção. Nesse caso, AWS SCT reescreve `INSERT..SELECT` as instruções no código convertido para emular o comportamento do seu banco de dados de origem.
## Configurações de otimização de conversão do Teradata para o Amazon Redshift
**Para editar as configurações de otimização de conversão do Teradata para o Amazon Redshift, escolha Configurações em e, AWS SCT em seguida, **escolha** Configurações de conversão.** Na lista superior, escolha **Teradata** e, em seguida, escolha **Teradata: Amazon Redshift**. No painel esquerdo, escolha **Estratégias de otimização**. AWS SCT exibe as configurações de otimização de conversão para conversão de Teradata para Amazon Redshift.
As configurações AWS SCT de otimização de conversão do Teradata para o Amazon Redshift incluem opções para o seguinte:
+ Para trabalhar com otimização automática de tabelas. Para fazer isso, selecione **Usar o ajuste automático da tabela do Amazon Redshift**.
A otimização automática de tabelas é um processo de autoajuste no Amazon Redshift que otimiza automaticamente o design de tabelas. Para obter mais informações, consulte [Como trabalhar com a otimização automática de tabelas](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) no *Guia do desenvolvedor do banco de dados Amazon Redshift*.
Para confiar somente na otimização automática da tabela, escolha **Nenhuma** para a **Estratégia inicial de seleção de chave**.
+ Para escolher chaves de classificação e distribuição usando sua estratégia.
Você pode escolher chaves de classificação e distribuição usando metadados, informações estatísticas ou ambas as opções do Amazon Redshift. Para **Estratégia inicial de seleção de chave** na guia **Estratégias de otimização**, escolha uma das seguintes opções:
+ Use metadados, ignore informações estatísticas
+ Ignore metadados, use informações estatísticas
+ Use metadados e informações estatísticas
Dependendo da opção escolhida, você pode selecionar estratégias de otimização. Em seguida, para cada estratégia, insira o valor (0-100). Esses valores definem o peso de cada estratégia. Usando esses valores de peso, a AWS SCT define como cada regra influencia na escolha das chaves de distribuição e classificação. Os valores padrão são baseados nas melhores práticas de AWS migração.
Você pode definir o tamanho de tabelas pequenas para a estratégia **Localizar tabelas pequenas**. Em Contagem **mínima de linhas da tabela e Contagem** **máxima de linhas** da tabela, insira o número mínimo e máximo de linhas em uma tabela para defini-la como uma tabela pequena. AWS SCT aplica o estilo `ALL` de distribuição a tabelas pequenas. Nesse caso, uma cópia de toda a tabela é distribuída para cada nó.
+ Para configurar os detalhes da estratégia.
Além de definir o peso de cada estratégia de otimização, você pode definir as configurações de otimização. Para fazer isso, escolha **Otimização de conversões**.
+ Em **Limite de colunas da chave de classificação**, insira o número máximo de colunas na chave de classificação.
+ Em **Valor limite distorcido**, insira a porcentagem (0—100) de um valor distorcido para uma coluna. AWS SCT exclui colunas com o valor de inclinação maior que o limite da lista de candidatos para a chave de distribuição. AWS SCT define o valor distorcido de uma coluna como a proporção percentual entre o número de ocorrências do valor mais comum e o número total de registros.
+ Para as **N principais consultas da tabela do histórico de consultas**, insira o número (1-100) das consultas usadas com mais frequência para análise.
+ Em **Selecionar usuário de estatísticas**, escolha o usuário do banco de dados para o qual você deseja analisar as estatísticas de consulta.
Além disso, na guia **Estratégias de otimização**, você pode definir o tamanho das tabelas pequenas para a estratégia **Localizar tabelas pequenas**. Em Contagem **mínima de linhas da tabela e Contagem** **máxima de linhas** da tabela, insira o número mínimo e máximo de linhas em uma tabela para considerá-la como uma tabela pequena. AWS SCT aplica o estilo `ALL` de distribuição a tabelas pequenas. Nesse caso, uma cópia de toda a tabela é distribuída para cada nó.