Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Conexión a un almacén de datos de Teradata con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Teradata a Amazon Redshift o Amazon Redshift y usarlos en combinación. AWS Glue
## Privilegios para Teradata como origen
Los privilegios necesarios para Teradata como origen se enumeran a continuación:
+ SELECT ON DBC
+ SELECT ON SYSUDTLIB
+ SELECT ON SYSLIB
+ SELECCIONE UNA **
+ CREAR PROCEDIMIENTO EN **
En el ejemplo anterior, sustituya el marcador de posición ** por el nombre de la base de datos de origen.
AWS SCT requiere el privilegio CREATE PROCEDURE para ejecutar HELP PROCEDURE en todos los procedimientos de la base de datos de origen. AWS SCT no utiliza este privilegio para crear ningún objeto nuevo en la base de datos Teradata de origen.
## Conexión a Teradata como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Teradata con AWS Schema Conversion Tool.
**Para conectarse a su base de datos Teradata de origen**
1. En AWS Schema Conversion Tool, elija **Agregar** fuente.
1. Elija **Teradata** y, a continuación, elija **Siguiente**.
Se abrirá el cuadro de diálogo **Agregar origen**.
1. En **Nombre de conexión**, escriba un nombre para su base de datos. AWS SCT muestra este nombre en el árbol del panel izquierdo.
1. Utilice las credenciales de la base de datos de AWS Secrets Manager o introdúzcalas manualmente:
+ Para usar las credenciales de base de datos de Secrets Manager, siga las instrucciones siguientes:
1. En **Secreto de AWS **, elija el nombre del secreto.
1. Seleccione **Rellenar** para rellenar automáticamente todos los valores del cuadro de diálogo de conexión a la base de datos de Secrets Manager.
Para obtener información sobre el uso de las credenciales de bases de datos de Secrets Manager, consulte[Configurando AWS Secrets Manager en el AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Para introducir manualmente la información de conexión a la base de datos fuente de Teradata, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Elija **Probar conexión** para comprobar que se AWS SCT puede conectar a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
### Uso de la autenticación LDAP con un origen Teradata
Para configurar la autenticación LDAP (Lightweight Directory Access Protocol) para los usuarios de Teradata que ejecutan Microsoft Active Directory en Windows, use el siguiente procedimiento.
En el siguiente procedimiento, el dominio de Active Directory es `test.local.com`. El servidor de Windows es `DC` y está configurado con la configuración predeterminada. El script de usuario creada en la cuenta de Active Directory `test_ldap` y la cuenta utiliza la contraseña `test_ldap`.
**Para configurar la autenticación LDAP para los usuarios de Teradata que ejecutan Microsoft Active Directory en Windows**
1. En el directorio `/opt/teradata/tdat/tdgss/site`, edite el archivo `TdgssUserConfigFile.xml`. Cambie la sección LDAP a lo siguiente.
```
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 los cambios ejecutando la configuración como se indica a continuación.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Pruebe la configuración mediante el siguiente comando.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
El resultado debería ser similar al siguiente.
```
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 TPA utilizando el siguiente comando.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Cree el mismo usuario en la base de datos de Teradata que en Active Directory, tal y como se muestra a continuación.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Si cambia la contraseña de usuario en Active Directory para su usuario LDAP, especifique esta nueva contraseña durante la conexión a Teradata en modo LDAP. En el modo DEFAULT, para conectarse a Teradata se utilizan el nombre de usuario y una contraseña de LDAP.
## Configurar la recopilación de estadísticas en el almacenamiento de datos de Teradata de origen
Para convertir el almacén de datos de Teradata de origen, AWS SCT utiliza las estadísticas para optimizar el almacén de datos convertido de Amazon Redshift. Puede recopilar estadísticas en AWS SCT o cargar el archivo de estadísticas. Para obtener más información, consulte [Recopilación o carga de estadísticas](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Para asegurarse de que AWS SCT puede recopilar estadísticas de su almacén de datos, complete las siguientes tareas previas.
**Para recopilar estadísticas del almacenamiento de datos de Teradata**
1. Ejecute la siguiente consulta para recopilar las estadísticas de todas las tablas del almacenamiento de datos.
```
collect summary statistics on table_name;
```
En el ejemplo anterior, *table\$1name* sustitúyalo por el nombre de la tabla de origen. Repita la consulta para cada tabla que convierta.
1. Ejecute la siguiente consulta para determinar la cadena de cuenta del usuario, que utilizará para convertir el almacenamiento de datos.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Active el registro de consultas para un usuario específico mediante la cadena de cuenta del ejemplo anterior.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
También puede activar el registro de consultas para todos los usuarios de la base de datos.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Cuando termine de recopilar las estadísticas del almacenamiento de datos, desactive el registro de consultas. Para ello, puede usar el siguiente ejemplo de código.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Recopilar estadísticas en modo offline desde su almacenamiento de datos de Teradata de origen
Después de configurar la recopilación de estadísticas en su almacén de datos de Teradata, podrá recopilar estadísticas en su AWS SCT proyecto. Como alternativa, puede utilizar los scripts Basic Teradata Query (BTEQ) para recopilar estadísticas en modo offline. A continuación, puede cargar los archivos con las estadísticas recopiladas en su proyecto de AWS SCT . Para obtener más información, consulte [Recopilación o carga de estadísticas](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Para recopilar estadísticas en modo offline desde el almacenamiento de datos de Teradata de origen**
1. Cree el script `off-line_stats.bteq` con el siguiente contenido.
```
.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. Cree el archivo `td_run_bteq.bat` que ejecuta el script de BTEQ que creó en el paso anterior. Utilice el siguiente contenido para este archivo.
```
@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. Cree el archivo `runme.bat` que ejecuta el archivo de procesamiento por lotes que creó en el paso anterior. Utilice el siguiente contenido para este archivo.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
En el `runme.bat` archivo *ServerName**UserName*, sustituya y por *DatabaseName* los valores aplicables.
A continuación, ejecute el archivo de `runme.bat`. Repita este paso para cada almacenamiento de datos que convierta en Amazon Redshift.
Tras ejecutar este script, recibirá tres archivos con estadísticas para cada base de datos. Puede cargar estos archivos en su AWS SCT proyecto. Para ello, elija el almacenamiento de datos en el panel izquierdo del proyecto y, a continuación, abra el menú contextual (clic secundario). Seleccione **Cargar estadísticas**.
## Configuración de conversión de Teradata a Amazon Redshift
**Para editar la configuración de conversión de Teradata a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Teradata** y, a continuación, **Teradata — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Teradata a Amazon Redshift.
La configuración AWS SCT de conversión de Teradata a Amazon Redshift incluye opciones para lo siguiente:
+ Limitar el número de comentarios con elementos de acción en el código convertido.
En **Añadir comentarios en el código convertido para los elementos de acción de la gravedad seleccionada o superior, elija la gravedad** de los elementos de acción. AWS SCT añade comentarios en el código convertido para los elementos de acción de la gravedad seleccionada o superior.
Por ejemplo, para minimizar el número de comentarios en el código convertido, seleccione **Solo errores**. Para incluir comentarios para todos los elementos de acción del código convertido, seleccione **Todos los mensajes**.
+ Para establecer el número máximo de tablas que AWS SCT se pueden aplicar a su clúster de Amazon Redshift de destino.
En **El número máximo de tablas para el clúster de Amazon Redshift de destino**, elija el número de tablas que se AWS SCT pueden aplicar a su clúster de Amazon Redshift.
Amazon Redshift tiene cuotas que limitan las tablas de uso para los distintos tipos de nodos de clúster. Si elige **Auto**, AWS SCT determina el número de tablas que se van a aplicar al clúster de Amazon Redshift de destino en función del tipo de nodo. Si lo desea, elija el valor manualmente. Para obtener más información, consulte [Cuotas y límites de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) en la *Guía de administración de Amazon Redshift*.
AWS SCT convierte todas las tablas de origen, incluso si son más de las que puede almacenar el clúster de Amazon Redshift. AWS SCT almacena el código convertido en su proyecto y no lo aplica a la base de datos de destino. Si alcanza la cuota de clústeres de Amazon Redshift para las tablas al aplicar el código convertido, AWS SCT mostrará un mensaje de advertencia. Además, AWS SCT aplica tablas al clúster de Amazon Redshift de destino hasta que el número de tablas alcance el límite.
+ Migrar particiones de la tabla de origen a tablas independientes en Amazon Redshift. Para ello, seleccione **Usar la vista UNION ALL** e introduzca el número máximo de tablas de destino que AWS SCT puede crear para una sola tabla de origen.
Amazon Redshift no admite particionamiento de tablas. Para emular este comportamiento y hacer que las consultas se ejecuten más rápido, AWS SCT puede migrar cada partición de la tabla de origen a una tabla independiente en Amazon Redshift. A continuación, AWS SCT crea una vista que incluye los datos de todas estas tablas.
AWS SCT determina automáticamente el número de particiones de la tabla de origen. Según el tipo de particionamiento de la tabla de origen, este número puede superar la cuota de tablas que puede aplicar a su clúster de Amazon Redshift. Para evitar alcanzar esta cuota, introduzca el número máximo de tablas de destino que AWS SCT se pueden crear para las particiones de una sola tabla de origen. La opción predeterminada es 368 tablas, lo que representa una partición para 366 días de un año y dos tablas para las particiones `NO RANGE` y `UNKNOWN`.
+ Aplicar compresión a las columnas de la tabla de Amazon Redshift. Para ello, seleccione **Usar codificación de compresión**.
AWS SCT asigna automáticamente la codificación de compresión a las columnas mediante el algoritmo Amazon Redshift predeterminado. Para obtener más información, consulte [Codificaciones de compresión](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
De forma predeterminada, Amazon Redshift no aplica compresión a las columnas definidas como claves de clasificación y distribución. Puede cambiar este comportamiento y aplicar compresión a estas columnas. Para ello, seleccione **Usar codificación de compresión para columnas KEY**. Puede seleccionar esta opción solo si selecciona la opción **Usar codificación de compresión**.
+ Para usar una lista explícita de columnas en el código convertido para las instrucciones `SELECT *`, seleccione **Usar instrucción de columna explícita**.
+ Para simular el comportamiento de las claves principales y únicas del clúster de Amazon Redshift, seleccione **Simular el comportamiento de claves principales y únicas**.
Amazon Redshift no exige claves únicas y principales y las utiliza únicamente con fines informativos. Si utiliza estas restricciones en el código, asegúrese de que AWS SCT emulan su comportamiento en el código convertido.
+ Garantizar la exclusividad de los datos en las tablas de Amazon Redshift de destino. Para ello, seleccione **Simular el comportamiento de las tablas SET**.
Teradata crea tablas utilizando el elemento de sintaxis `SET` como opción predeterminada. No puede agregar filas duplicadas en una tabla `SET`. Si su código fuente no usa esta restricción de exclusividad, desactive esta opción. En este caso, el código convertido funciona más rápido.
Si su código fuente usa la opción `SET` de las tablas como una restricción de exclusividad, active esta opción. En este caso, AWS SCT reescribe `INSERT..SELECT` las sentencias en el código convertido para emular el comportamiento de la base de datos fuente.
## Configuración de optimización de la conversión de Teradata a Amazon Redshift
**Para editar la configuración de optimización de conversiones de Teradata a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Teradata** y, a continuación, **Teradata — Amazon Redshift**. **En el panel izquierdo, elija Estrategias de optimización.** AWS SCT muestra la configuración de optimización de conversiones para la conversión de Teradata a Amazon Redshift.
La configuración AWS SCT de optimización de conversiones de Teradata a Amazon Redshift incluye opciones para lo siguiente:
+ Trabajar con optimización automática de tablas. Para ello, seleccione **Utilizar el ajuste automático de tablas de Amazon Redshift**.
La optimización automática de tablas es una capacidad de autoajuste presente en Amazon Redshift que optimiza automáticamente el diseño de tablas. Para obtener más información, consulte [Trabajo con optimización automática de tablas](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Para confiar únicamente en la optimización automática de las tablas, elija **Ninguna** en **Estrategia inicial de selección de claves**.
+ Elegir las claves de clasificación y distribución según su estrategia.
Puede elegir las claves de clasificación y distribución utilizando metadatos de Amazon Redshift, información estadística o ambas opciones. En **estrategia inicial de selección de claves**, en la pestaña **Estrategias de optimización**, elija una de las siguientes opciones:
+ Utilizar metadatos e ignorar la información estadística
+ Ignorar los metadatos, utilizar información estadística
+ Utilizar metadatos e información estadística
En función de la opción que elija, puede seleccionar estrategias de optimización. A continuación, introduzca el valor (0—100) para cada estrategia. Estos valores definen la ponderación de cada estrategia. Con estos valores de ponderación, AWS SCT define cómo influye cada regla en la elección de las claves de distribución y clasificación. Los valores predeterminados se basan en las prácticas recomendadas de AWS migración.
Puede definir el tamaño de las tablas pequeñas para la estrategia **Buscar tablas pequeñas**. **En Recuento mínimo de filas** de la **tabla y Recuento máximo de filas** de la tabla, introduzca el número mínimo y máximo de filas de una tabla para definirla como una tabla pequeña. AWS SCT aplica el estilo `ALL` de distribución a las tablas pequeñas. En este caso, se distribuye una copia de toda la tabla a cada nodo.
+ Configurar los detalles de la estrategia.
Además de definir la ponderación de cada estrategia de optimización, puede configurar los ajustes de optimización. Para ello, elija **Optimización de la conversión**.
+ En **Límite de columnas de clave de clasificación**, introduzca el número máximo de columnas en la clave de clasificación.
+ En el **caso del valor umbral** asimétrico, introduzca el porcentaje (0—100) de un valor asimétrico para una columna. AWS SCT excluye de la lista de candidatos a la clave de distribución las columnas con un valor de sesgo superior al umbral. AWS SCT define el valor asimétrico de una columna como la relación porcentual entre el número de apariciones del valor más común y el número total de registros.
+ En **Consultas N principales de la tabla del historial de consultas**, introduzca el número (1–100) de las consultas que se van a analizar con más frecuencia.
+ En **Seleccionar usuario de estadísticas**, elija el usuario de la base de datos cuyas estadísticas de consulta desee analizar.
Además, en la pestaña **Estrategias de optimización**, puede definir el tamaño de las tablas pequeñas para la estrategia **Buscar tablas pequeñas**. **En Recuento mínimo de filas** de la **tabla y Recuento máximo de filas** de la tabla, introduzca el número mínimo y máximo de filas de una tabla para considerarla una tabla pequeña. AWS SCT aplica el estilo `ALL` de distribución a las tablas pequeñas. En este caso, se distribuye una copia de toda la tabla a cada nodo.