`.
Puede encontrar ejemplos en la siguiente tabla.
| Instrucción de Oracle | Instrucción de MySQL |
| --- | --- |
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01
(p_state IN NUMBER)
AS
l_dept_id NUMBER := 1;
BEGIN
FOR cur IN
(WITH dept_empl(id, name, surname,
lastname, state, dept_id)
AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = p_state AND
dept_id = l_dept_id)
SELECT id,state
FROM dept_empl
ORDER BY id) LOOP
NULL;
END LOOP;
| CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 1;
DECLARE var$id VARCHAR (8000);
DECLARE var$state VARCHAR (8000);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
ID, STATE
FROM (SELECT
ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl
ORDER BY ID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$id, var$state;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01
AS
BEGIN
FOR cur IN (
WITH dept_empl AS
(
SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1),
dept AS
(SELECT id deptid, parent_id,
name deptname
FROM test_ora_pg.department
)
SELECT dept_empl.*,dept.*
FROM dept_empl, dept
WHERE dept_empl.dept_id = dept.deptid
) LOOP
NULL;
END LOOP;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT id, name, surname, lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE state = 1);
CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
`(deptid, parent_id,deptname)
AS
(SELECT id deptid, parent_id, name deptname
FROM test_ora_pg.department);
CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
BEGIN
DECLARE var$ID DOUBLE;
DECLARE var$NAME VARCHAR (30);
DECLARE var$SURNAME VARCHAR (30);
DECLARE var$LASTNAME VARCHAR (30);
DECLARE var$STATE DOUBLE;
DECLARE var$DEPT_ID DOUBLE;
DECLARE var$deptid DOUBLE;
DECLARE var$PARENT_ID DOUBLE;
DECLARE var$deptname VARCHAR (200);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
dept_empl.*, dept.*
FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
` AS dept_empl,
TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
` AS dept
WHERE dept_empl.DEPT_ID = dept.DEPTID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID, var$NAME, var$SURNAME,
var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid,
var$PARENT_ID, var$deptname;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
|
| CREATE PROCEDURE
TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)
AS
l_dept_id NUMBER := 10;
BEGIN
FOR cur IN (
WITH emp AS
(SELECT id, name, surname,
lastname, state, dept_id
FROM test_ora_pg.dept_employees
WHERE dept_id > 10
),
active_emp AS
(
SELECT id
FROM emp
WHERE emp.state = p_state
)
SELECT *
FROM active_emp
) LOOP
NULL;
END LOOP;
END;
| CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp
`(id, name, surname, lastname, state, dept_id)
AS
(SELECT
id, name, surname, lastname,
state, dept_id
FROM TEST_ORA_PG.DEPT_EMPLOYEES
WHERE DEPT_ID > 10);
CREATE PROCEDURE
test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)
BEGIN
DECLARE var_l_dept_id DOUBLE DEFAULT 10;
DECLARE var$ID DOUBLE;
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT *
FROM (SELECT
ID
FROM
TEST_ORA_PG.
`P_WITH_SELECT_VAR_CROSS_01$emp` AS emp
WHERE emp.STATE = par_p_state)
AS active_emp;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
|
# Migración de Oracle Database a Amazon RDS for Oracle con AWS Schema Conversion Tool
Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema y un código de Oracle a Amazon RDS para Oracle:
+ AWS SCT puede añadir objetos de directorio al árbol de objetos. Los *objetos de directorio* son estructuras lógicas, cada una de las cuales representa un directorio físico del sistema de archivos del servidor. Puede utilizar objetos de directorio con paquetes como DBMS\$1LOB, UTL\$1FILE, DBMS\$1FILE\$1TRANSFER, la utilidad DATAPUMP, etc.
+ AWS SCT admite la conversión de tablespaces de Oracle en una instancia de base de datos de Amazon RDS for Oracle. Oracle almacena los datos de forma lógica en espacios de tabla y físicamente en archivos de datos asociados con el espacio de tabla correspondiente. En Oracle, puede crear un espacio de tabla con nombres de archivos de datos. Amazon RDS solo admite Oracle Managed Files (OMF) para archivos de datos, archivos de registro y archivos de control. AWS SCT crea los archivos de datos necesarios durante la conversión.
+ AWS SCT puede convertir funciones y privilegios a nivel de servidor. El motor de base de datos Oracle utiliza la seguridad basada en roles. Una función es un conjunto de privilegios que se pueden conceder a un usuario o que se pueden revocar. Una función predefinida de Amazon RDS llamada DBA normalmente admite todos los privilegios administrativos de un motor de base de datos de Oracle. Los privilegios siguientes no están disponibles para el rol DBA en una instancia de base de datos de Amazon RDS que utiliza el motor Oracle:
+ Alter database
+ Alter system
+ Create any directory
+ Grant any privilege
+ Grant any role
+ Create external job
Puede conceder todos los demás privilegios a una función de usuario de Amazon RDS for Oracle, incluidos los de filtrado avanzado y de columnas.
+ AWS SCT admite la conversión de trabajos de Oracle en trabajos que se puedan ejecutar en Amazon RDS for Oracle. Existen algunas limitaciones en la conversión, entre las que se incluyen las siguientes:
+ No se admiten los trabajos ejecutables.
+ No se admiten los trabajos de programación que usan el tipo de datos ANYDATA como un argumento.
+ Oracle Real Application Clusters (RAC) One Node es una opción de Oracle Database Enterprise Edition que se introdujo con Oracle Database 11g versión 2. Amazon RDS for Oracle no admite la característica RAC. Para obtener una alta disponibilidad, utilice Multi-AZ de Amazon RDS.
En una implementación multi-AZ, Amazon RDS aprovisiona y mantiene automáticamente una réplica en espera sincrónica dentro de una zona de disponibilidad diferente. La instancia de base de datos principal se replica sincrónicamente en las zonas de disponibilidad en una réplica en espera. Esta funcionalidad proporciona redundancia de datos, elimina los I/O bloqueos y minimiza los picos de latencia durante las copias de seguridad del sistema.
+ Oracle Spatial proporciona un esquema y funciones SQL que facilitan el almacenamiento, la recuperación, la actualización y la consulta de colecciones de datos espaciales en una base de datos de Oracle. Oracle Locator proporciona capacidades que suelen ser necesarias para admitir aplicaciones basadas en servicio de Internet e inalámbricas y soluciones de Sistemas de información geográfica (SIG) basadas en el partner. Oracle Locator es una subred limitada de Oracle Spatial.
Para utilizar las características de Oracle Spatial u Oracle Locator, agregue la opción SPATIAL o la opción LOCATOR (mutuamente excluyentes) al grupo de opciones de la instancia de base de datos.
Existen algunas requisitos previos que debe cumplir para poder usar Oracle Spatial u Oracle Locator en una instancia de base de datos de Amazon RDS for Oracle:
+ La instancia debe usar Oracle Enterprise Edition versión 12.1.0.2.v6 o posterior o la versión 11.2.0.4.v10 o posterior.
+ La instancia debe estar dentro de una nube virtual privada (VPC).
+ La instancia debe usar la clase de instancia de base de datos que es compatible con la característica de Oracle. Por ejemplo, Oracle Spatial no se admite para las clases de instancia de base de datos db.m1.small, db.t1.micro, db.t2.micro o db.t2.small. Para obtener más información, consulte [Compatibilidad de clases de instancias de bases de datos con Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html#Oracle.Concepts.InstanceClasses).
+ La instancia debe tener habilitada la opción Auto Minor Version Upgrade (Actualización automática de versiones menores). Amazon RDS actualiza automáticamente su instancia de base de datos a la versión más reciente de Oracle PSU si hay vulnerabilidades de seguridad con una puntuación de CVSS superior a 9 u otras vulnerabilidades de seguridad anunciadas. Para obtener más información, consulte
[ Configuración de las instancias de base de datos de Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ModifyInstance.Oracle.html#USER_ModifyInstance.Oracle.Settings).
+ Si la versión de su instancia de base de datos es la 11.2.0.4.v10 o posterior, debe instalar la opción XMLDB. Para obtener más información, consulte
[Oracle XML DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.XMLDB.html).
+ Debe tener una licencia de Oracle Spatial de Oracle. Para obtener más información, consulte [Oracle Spatial and Graph](https://shop.oracle.com/apex/product?p1=OracleSpatialandGraph) en la documentación de Oracle.
+ Data Guard se incluye con Oracle Database Enterprise Edition. Para obtener una alta disponibilidad, utilice la característica Multi-AZ de Amazon RDS.
En una implementación multi-AZ, Amazon RDS aprovisiona y mantiene automáticamente una réplica en espera sincrónica dentro de una zona de disponibilidad diferente. La instancia de base de datos principal se replica sincrónicamente en las zonas de disponibilidad en una réplica en espera. Esta funcionalidad proporciona redundancia de datos, elimina las I/O congelaciones y minimiza los picos de latencia durante las copias de seguridad del sistema.
+ AWS SCT admite la conversión de objetos DBMS\$1SCHEDULER de Oracle al migrar a Amazon RDS for Oracle. El informe de AWS SCT evaluación indica si un objeto de programación se puede convertir. Para obtener más información acerca del uso de objetos de programación con Amazon RDS, consulte la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.System.html#Appendix.Oracle.CommonDBATasks.ModifyScheduler).
+ En el caso de conversiones de Oracle a Amazon RDS for Oracle, se admiten los enlaces de base de datos. Un enlace de base de datos es un objeto de esquema en una base de datos que le permite obtener acceso a los objetos de otra base de datos. No es necesario que la otra base de datos sea de Oracle. Sin embargo, para obtener acceso a las bases de datos que no son de Oracle, debe utilizar Oracle Heterogeneous Services.
Una vez creado un enlace a una base de datos, puede usarlo en las sentencias SQL para hacer referencia a tablas, vistas y PL/SQL objetos de la otra base de datos. Para usar un enlace de base de datos, `@dblink` añádalo al nombre de la tabla, vista o PL/SQL objeto. Puede consultar una tabla o una vista de la otra base de datos con la instrucción SELECT. Para obtener más información acerca del uso de enlaces de base de datos de Oracle, consulte la [documentación de Oracle](https://docs.oracle.com/cd/B28359_01/server.111/b28310/ds_concepts002.htm#ADMIN12083).
Para obtener más información acerca del uso de enlaces de base de datos con Amazon RDS, consulte la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Database.html#Appendix.Oracle.CommonDBATasks.DBLinks).
+ El informe AWS SCT de evaluación proporciona las métricas del servidor para la conversión. Estas métricas acerca de la instancia de Oracle incluyen:
+ Capacidad de memoria y computación de la instancia de base de datos de destino.
+ Características de Oracle, como Real Application Clusters no compatibles que Amazon RDS no admite.
+ Carga de lectura-escritura en disco.
+ Rendimiento de disco medio total
+ Información del servidor, como nombre de servidor, sistema operativo, alojamiento, nombre y conjunto de caracteres.
## Privilegios para RDS para Oracle como destino
Para migrar a Amazon RDS para Oracle, cree un usuario de base de datos privilegiado. Puede utilizar el siguiente código de ejemplo.
```
CREATE USER user_name IDENTIFIED BY your_password;
-- System privileges
GRANT DROP ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE TO user_name;
GRANT CREATE ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY ASSEMBLY TO user_name;
GRANT ALTER ANY RULE TO user_name;
GRANT SELECT ANY DICTIONARY TO user_name;
GRANT ALTER ANY DIMENSION TO user_name;
GRANT CREATE ANY DIMENSION TO user_name;
GRANT ALTER ANY TYPE TO user_name;
GRANT DROP ANY TRIGGER TO user_name;
GRANT CREATE ANY VIEW TO user_name;
GRANT ALTER ANY CUBE BUILD PROCESS TO user_name;
GRANT CREATE ANY CREDENTIAL TO user_name;
GRANT DROP ANY CUBE DIMENSION TO user_name;
GRANT DROP ANY ASSEMBLY TO user_name;
GRANT DROP ANY PROCEDURE TO user_name;
GRANT ALTER ANY PROCEDURE TO user_name;
GRANT ALTER ANY SQL TRANSLATION PROFILE TO user_name;
GRANT DROP ANY MEASURE FOLDER TO user_name;
GRANT CREATE ANY MEASURE FOLDER TO user_name;
GRANT DROP ANY CUBE TO user_name;
GRANT DROP ANY MINING MODEL TO user_name;
GRANT CREATE ANY MINING MODEL TO user_name;
GRANT DROP ANY EDITION TO user_name;
GRANT CREATE ANY EVALUATION CONTEXT TO user_name;
GRANT DROP ANY DIMENSION TO user_name;
GRANT ALTER ANY INDEXTYPE TO user_name;
GRANT DROP ANY TYPE TO user_name;
GRANT CREATE ANY PROCEDURE TO user_name;
GRANT CREATE ANY SQL TRANSLATION PROFILE TO user_name;
GRANT CREATE ANY CUBE TO user_name;
GRANT COMMENT ANY MINING MODEL TO user_name;
GRANT ALTER ANY MINING MODEL TO user_name;
GRANT DROP ANY SQL PROFILE TO user_name;
GRANT CREATE ANY JOB TO user_name;
GRANT DROP ANY EVALUATION CONTEXT TO user_name;
GRANT ALTER ANY EVALUATION CONTEXT TO user_name;
GRANT CREATE ANY INDEXTYPE TO user_name;
GRANT CREATE ANY OPERATOR TO user_name;
GRANT CREATE ANY TRIGGER TO user_name;
GRANT DROP ANY ROLE TO user_name;
GRANT DROP ANY SEQUENCE TO user_name;
GRANT DROP ANY CLUSTER TO user_name;
GRANT DROP ANY SQL TRANSLATION PROFILE TO user_name;
GRANT ALTER ANY ASSEMBLY TO user_name;
GRANT CREATE ANY RULE SET TO user_name;
GRANT ALTER ANY OUTLINE TO user_name;
GRANT UNDER ANY TYPE TO user_name;
GRANT CREATE ANY TYPE TO user_name;
GRANT DROP ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY ROLE TO user_name;
GRANT DROP ANY VIEW TO user_name;
GRANT ALTER ANY INDEX TO user_name;
GRANT COMMENT ANY TABLE TO user_name;
GRANT CREATE ANY TABLE TO user_name;
GRANT CREATE USER TO user_name;
GRANT DROP ANY RULE SET TO user_name;
GRANT CREATE ANY CONTEXT TO user_name;
GRANT DROP ANY INDEXTYPE TO user_name;
GRANT ALTER ANY OPERATOR TO user_name;
GRANT CREATE ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY SEQUENCE TO user_name;
GRANT DROP ANY SYNONYM TO user_name;
GRANT CREATE ANY SYNONYM TO user_name;
GRANT DROP USER TO user_name;
GRANT ALTER ANY MEASURE FOLDER TO user_name;
GRANT ALTER ANY EDITION TO user_name;
GRANT DROP ANY RULE TO user_name;
GRANT CREATE ANY RULE TO user_name;
GRANT ALTER ANY RULE SET TO user_name;
GRANT CREATE ANY OUTLINE TO user_name;
GRANT UNDER ANY TABLE TO user_name;
GRANT UNDER ANY VIEW TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
GRANT ALTER ANY CLUSTER TO user_name;
GRANT CREATE ANY CLUSTER TO user_name;
GRANT ALTER ANY TABLE TO user_name;
GRANT CREATE ANY CUBE BUILD PROCESS TO user_name;
GRANT ALTER ANY CUBE DIMENSION TO user_name;
GRANT CREATE ANY EDITION TO user_name;
GRANT CREATE ANY SQL PROFILE TO user_name;
GRANT ALTER ANY SQL PROFILE TO user_name;
GRANT DROP ANY OUTLINE TO user_name;
GRANT DROP ANY CONTEXT TO user_name;
GRANT DROP ANY OPERATOR TO user_name;
GRANT DROP ANY LIBRARY TO user_name;
GRANT ALTER ANY LIBRARY TO user_name;
GRANT CREATE ANY LIBRARY TO user_name;
GRANT ALTER ANY MATERIALIZED VIEW TO user_name;
GRANT ALTER ANY TRIGGER TO user_name;
GRANT CREATE ANY SEQUENCE TO user_name;
GRANT DROP ANY INDEX TO user_name;
GRANT CREATE ANY INDEX TO user_name;
GRANT DROP ANY TABLE TO user_name;
GRANT SELECT_CATALOG_ROLE TO user_name;
GRANT SELECT ANY SEQUENCE TO user_name;
-- Database Links
GRANT CREATE DATABASE LINK TO user_name;
GRANT CREATE PUBLIC DATABASE LINK TO user_name;
GRANT DROP PUBLIC DATABASE LINK TO user_name;
-- Server Level Objects (directory)
GRANT CREATE ANY DIRECTORY TO user_name;
GRANT DROP ANY DIRECTORY TO user_name;
-- (for RDS only)
GRANT EXECUTE ON RDSADMIN.RDSADMIN_UTIL TO user_name;
-- Server Level Objects (tablespace)
GRANT CREATE TABLESPACE TO user_name;
GRANT DROP TABLESPACE TO user_name;
-- Server Level Objects (user roles)
/* (grant source privileges with admin option or convert roles/privs as DBA) */
-- Queues
grant execute on DBMS_AQADM to user_name;
grant aq_administrator_role to user_name;
-- for Materialized View Logs creation
GRANT SELECT ANY TABLE TO user_name;
-- Roles
GRANT RESOURCE TO user_name;
GRANT CONNECT TO user_name;
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *your\$1password* sustitúyala por una contraseña segura.
## Limitaciones al convertir de Oracle a Amazon RDS para Oracle
Hay que tener en cuenta algunas limitaciones al migrar un esquema y un código de Oracle a Amazon RDS para Oracle:
+ Una función predefinida de Amazon RDS llamada DBA normalmente admite todos los privilegios administrativos de un motor de base de datos de Oracle. Los privilegios siguientes no están disponibles para el rol DBA en una instancia de base de datos de Amazon RDS que utiliza el motor Oracle:
+ Alter database
+ Alter system
+ Create any directory
+ Grant any privilege
+ Grant any role
+ Create external job
Todos los demás privilegios se pueden conceder a una función de usuario de Oracle RDS.
+ Amazon RDS para Oracle admite las auditorías tradicionales y detalladas mediante el paquete DBMS\$1FGA y Oracle Unified Auditing.
+ Amazon RDS para Oracle no admite la captura de datos de cambios (CDC). Para usar la CDC durante y después de la migración de una base de datos, utilice AWS Database Migration Service.
# Conexión a bases de datos PostgreSQL con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código de bases de datos y código de aplicaciones de PostgreSQL a los siguientes destinos:
+ Amazon RDS para MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS para PostgreSQL
+ Edición de Amazon Aurora compatible con PostgreSQL
Para obtener más información, consulte las siguientes secciones:
**Topics**
+ [Privilegios para PostgreSQL como base de datos de origen](#CHAP_Source.PostgreSQL.Permissions)
+ [Conexión a PostgreSQL como origen](#CHAP_Source.PostgreSQL.Connecting)
+ [Privilegios para MySQL como base de datos de destino](#CHAP_Source.PostgreSQL.ConfigureMySQL)
## Privilegios para PostgreSQL como base de datos de origen
Los privilegios necesarios para PostgreSQL como origen son los siguientes:
+ CONÉCTESE A LA BASE **
+ USO EN EL ESQUEMA **
+ SELECCIONE EN TODAS LAS TABLAS DEL ESQUEMA **
+ SELECCIONE TODAS LAS SECUENCIAS DEL ESQUEMA **
## Conexión a PostgreSQL como origen
Utilice el siguiente procedimiento para conectarse a su base de datos PostgreSQL de origen con la AWS Schema Conversion Tool.
**Para conectarse a una base de datos de PostgreSQL de origen**
1. En AWS Schema Conversion Tool, elija **Agregar fuente**.
1. Elija **PostgreSQL** 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 de origen de PostgreSQL, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.PostgreSQL.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Privilegios para MySQL como base de datos de destino
Los privilegios necesarios para MySQL como destino cuando se migra desde PostgreSQL son los siguientes:
+ CREATE ON \$1.\$1
+ ALTER ON \$1.\$1
+ DROP ON \$1.\$1
+ INDEX ON \$1.\$1
+ REFERENCES ON \$1.\$1
+ SELECT ON \$1.\$1
+ CREATE VIEW ON \$1.\$1
+ SHOW VIEW ON \$1.\$1
+ TRIGGER ON \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERTE Y ACTUALICE EN AWS\$1POSTGRESQL \$1EXT. \$1
+ INSERTAR, ACTUALIZAR Y ELIMINAR EN AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
+ CREA TABLAS TEMPORALES EN AWS\$1POSTGRESQL \$1EXT\$1DATA. \$1
Puede usar el siguiente ejemplo de código para crear un usuario de base de datos y conceder los privilegios.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_POSTGRESQL_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_POSTGRESQL_EXT_DATA.* TO 'user_name';
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *your\$1password* sustitúyala por una contraseña segura.
Para usar Amazon RDS para MySQL o Aurora MySQL como destino, establezca el parámetro `lower_case_table_names` en `1`. Este valor significa que el servidor MySQL gestiona los identificadores de nombres de objetos como tablas, índices, disparadores y bases de datos sin distinguir entre mayúsculas y minúsculas. Si ha activado el registro binario en la instancia de destino, establezca el parámetro `log_bin_trust_function_creators` en `1`. En este caso, no es necesario utilizar las características `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` para crear funciones almacenadas. Para configurar estos parámetros, cree un grupo de parámetros de base de datos nuevo o modifique uno existente.
# Conexión a bases de datos de SAP con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código de bases de datos y código de aplicaciones de SAP (Sybase) Adaptive Server Enterprise (ASE) a los siguientes destinos:
+ Amazon RDS para MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS para MariaDB
+ Amazon RDS para PostgreSQL
+ Edición de Amazon Aurora compatible con PostgreSQL
Para obtener más información, consulte las siguientes secciones:
**Topics**
+ [Privilegios para SAP ASE como base de datos de origen](#CHAP_Source.SAP.Permissions)
+ [Conexión a SAP ASE (Sybase) como origen](#CHAP_Source.SAP.Connecting)
+ [Privilegios para MySQL como base de datos de destino](#CHAP_Source.SAP.ConfigureMySQL)
+ [Configuración de conversión de SAP ASE a MySQL](#CHAP_Source.SAP.MySQLConversionSettings)
+ [Privilegios para PostgreSQL como base de datos de destino](#CHAP_Source.SAP.ConfigurePostgreSQL)
+ [Configuración de conversión de SAP ASE a PostgreSQL](#CHAP_Source.SAP.PostgreSQLConversionSettings)
## Privilegios para SAP ASE como base de datos de origen
Para utilizar una base de datos de SAP ASE como origen, debe crear un usuario de base de datos y conceder permisos. Para ello, siga estos pasos.
**Cree y configure un usuario de base de datos**
1. Conéctese a la base de datos de origen.
1. Cree un usuario de base de datos con los siguientes comandos. Proporcione una contraseña para el usuario nuevo.
```
USE master
CREATE LOGIN min_privs WITH PASSWORD
sp_adduser min_privs
grant select on dbo.spt_values to min_privs
grant select on asehostname to min_privs
```
1. Para cada base de datos que vaya a migrar, otorgue los siguientes privilegios.
```
USE
sp_adduser min_privs
grant select on dbo.sysusers to min_privs
grant select on dbo.sysobjects to min_privs
grant select on dbo.sysindexes to min_privs
grant select on dbo.syscolumns to min_privs
grant select on dbo.sysreferences to min_privs
grant select on dbo.syscomments to min_privs
grant select on dbo.syspartitions to min_privs
grant select on dbo.syspartitionkeys to min_privs
grant select on dbo.sysconstraints to min_privs
grant select on dbo.systypes to min_privs
grant select on dbo.sysqueryplans to min_privs
```
## Conexión a SAP ASE (Sybase) como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de SAP ASE con AWS Schema Conversion Tool.
**Para conectarse a una base de datos de SAP ASE**
1. En AWS Schema Conversion Tool, elija **Agregar** fuente.
1. Elija **SAP ASE**, 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 de origen de SAP ASE, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.SAP.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Privilegios para MySQL como base de datos de destino
Los privilegios necesarios para MySQL como destino se enumeran a continuación:
+ CREATE ON \$1.\$1
+ ALTER ON \$1.\$1
+ DROP ON \$1.\$1
+ INDEX ON \$1.\$1
+ REFERENCES ON \$1.\$1
+ SELECT ON \$1.\$1
+ CREATE VIEW ON \$1.\$1
+ SHOW VIEW ON \$1.\$1
+ TRIGGER ON \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERTE Y ACTUALICE EN AWS\$1SAPASE \$1EXT. \$1
+ CREA TABLAS TEMPORALES EN AWS\$1SAPASE \$1EXT. \$1
Puede usar el siguiente ejemplo de código para crear un usuario de base de datos y conceder los privilegios.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_SAPASE_EXT.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SAPASE_EXT.* TO 'user_name';
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *your\$1password* sustitúyala por una contraseña segura.
Para usar Amazon RDS para MySQL o Aurora MySQL como destino, establezca el parámetro `lower_case_table_names` en `1`. Este valor significa que el servidor MySQL gestiona los identificadores de nombres de objetos como tablas, índices, disparadores y bases de datos sin distinguir entre mayúsculas y minúsculas. Si ha activado el registro binario en la instancia de destino, establezca el parámetro `log_bin_trust_function_creators` en `1`. En este caso, no es necesario utilizar las características `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` para crear funciones almacenadas. Para configurar estos parámetros, cree un grupo de parámetros de base de datos nuevo o modifique uno existente.
## Configuración de conversión de SAP ASE a MySQL
Para editar la configuración de conversión de SAP ASE a MySQL, seleccione **Configuración** y, a continuación, elija **Configuración de conversión**. En la lista superior, elija **SAP ASE** y, a continuación, **SAP ASE - MySQL** o **SAP ASE - Amazon Aurora (compatible con MySQL)**. AWS SCT muestra todas las configuraciones disponibles para la conversión de SAP ASE a PostgreSQL.
La configuración de conversión de SAP ASE a MySQL AWS SCT 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**.
+ Usar los nombres exactos de los objetos de la base de datos de origen en el código convertido.
De forma predeterminada, AWS SCT convierte los nombres de los objetos, variables y parámetros de la base de datos a minúsculas. Para mantener las mayúsculas y minúsculas originales de estos nombres, seleccione **Distinguir entre mayúsculas y minúsculas en los nombres de los objetos de la base de datos de origen**. Elija esta opción si utiliza nombres de objetos que distingan mayúsculas de minúsculas en el servidor de base de datos de SAP ASE de origen.
## Privilegios para PostgreSQL como base de datos de destino
Para usar PostgreSQL como destino AWS SCT , se requiere el privilegio. `CREATE ON DATABASE` Asegúrese de conceder este privilegio a cada base de datos PostgreSQL de destino.
Para usar los sinónimos públicos convertidos, cambie la ruta de búsqueda predeterminada de la base de datos a `"$user", public_synonyms, public`.
Puede usar el siguiente ejemplo de código para crear un usuario de base de datos y conceder los privilegios.
```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *db\$1name* sustitúyalo por el nombre de la base de datos de destino. Por último, *your\$1password* sustitúyala por una contraseña segura.
En PostgreSQL, solo el propietario de un esquema o un `superuser` puede anular un esquema. El propietario puede eliminar un esquema y todos los objetos que incluye este esquema, aunque el propietario del esquema no sea propietario de algunos de los objetos.
Si utiliza distintos usuarios para convertir y aplicar diferentes esquemas a la base de datos de destino, puede aparecer un mensaje de error cuando no AWS SCT puede eliminar un esquema. Para evitar este mensaje de error, utilice el rol de `superuser`.
## Configuración de conversión de SAP ASE a PostgreSQL
Para editar la configuración de conversión de SAP ASE a PostgreSQL, seleccione **Configuración** y, a continuación, elija **Configuración de conversión**. En la lista superior, elija **SAP ASE** y, a continuación, elija **SAP ASE - PostgreSQL** o **SAP ASE - Amazon Aurora (compatible con PostgreSQL)**. AWS SCT muestra todas las configuraciones disponibles para la conversión de SAP ASE a PostgreSQL.
La configuración AWS SCT de conversión de SAP ASE a PostgreSQL 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**.
+ Definir la plantilla que se utilizará para los nombres de los esquemas del código convertido. En **Plantilla de generación de nombres de esquema**, elija una de las siguientes opciones:
+ ****: utiliza el nombre de la base de datos de SAP ASE como nombre de esquema en PostgreSQL.
+ ****: utiliza el nombre del esquema de SAP ASE como nombre de esquema en PostgreSQL.
+ **\$1**: utiliza una combinación de los nombres de la base de datos y del esquema de SAP ASE como nombre de esquema en PostgreSQL.
+ Usar los nombres exactos de los objetos de la base de datos de origen en el código convertido.
De forma predeterminada, AWS SCT convierte los nombres de los objetos, variables y parámetros de la base de datos a minúsculas. Para mantener las mayúsculas y minúsculas originales de estos nombres, seleccione **Distinguir entre mayúsculas y minúsculas en los nombres de los objetos de la base de datos de origen**. Elija esta opción si utiliza nombres de objetos que distingan mayúsculas de minúsculas en el servidor de base de datos de SAP ASE de origen.
En las operaciones que distinguen mayúsculas de minúsculas, AWS SCT puede evitar la conversión de los nombres de los objetos de la base de datos a minúsculas. Para ello, seleccione **Evitar la conversión a minúsculas para las operaciones que distingan entre mayúsculas y minúsculas**.
+ Permitir el uso de índices con el mismo nombre en diferentes tablas de SAP ASE.
En PostgreSQL, todos los nombres de índice que utilice en el esquema deben ser únicos. Para asegurarse de que AWS SCT genera nombres únicos para todos los índices, seleccione **Generar nombres únicos** para los índices.
# Connect Microsoft SQL Servers con AWS Schema Conversion Tool
Puede utilizarla AWS SCT para convertir esquemas, objetos de código de bases de datos y código de aplicaciones de SQL Server a los siguientes destinos:
+ Amazon RDS para MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS para PostgreSQL
+ Edición de Amazon Aurora compatible con PostgreSQL
+ Amazon RDS para SQL Server
+ Amazon RDS para MariaDB
**nota**
AWS SCT no admite el uso de Amazon RDS for SQL Server como fuente.
Puede utilizarlo AWS SCT para crear un informe de evaluación para la migración de esquemas, objetos de código de base de datos y código de aplicación de SQL Server a Babelfish para Aurora PostgreSQL, tal y como se describe a continuación.
**Topics**
+ [Privilegios para Microsoft SQL Server como origen](#CHAP_Source.SQLServer.Permissions)
+ [Uso de la autenticación de Windows al utilizar Microsoft SQL Server como origen](#CHAP_Source.SQLServer.Permissions.WinAuth)
+ [Conexión a SQL Server como origen](#CHAP_Source.SQLServer.Connecting)
+ [Conversión de SQL Server a MySQL](CHAP_Source.SQLServer.ToMySQL.md)
+ [Migración de SQL Server a PostgreSQL con AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToPostgreSQL.md)
+ [Migración de SQL Server a Amazon RDS para SQL Server con AWS Schema Conversion Tool](CHAP_Source.SQLServer.ToRDSSQLServer.md)
## Privilegios para Microsoft SQL Server como origen
Los privilegios necesarios para Microsoft SQL Server como origen son los siguientes:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
El `VIEW DEFINITION` privilegio permite a los usuarios que tienen acceso público ver las definiciones de objetos. AWS SCT utiliza el `VIEW DATABASE STATE` privilegio para comprobar las características de la edición SQL Server Enterprise.
Repita la concesión para cada base de datos cuyo esquema vaya a convertir.
Además, conceda los siguientes privilegios en la base de datos `master`:
+ VIEW SERVER STATE
+ VIEW ANY DEFINITION
AWS SCT utiliza el `VIEW SERVER STATE` privilegio para recopilar los ajustes y la configuración del servidor. Asegúrese de conceder el privilegio `VIEW ANY DEFINITION` para ver los puntos de conexión.
Para leer información sobre Microsoft Analysis Services, ejecute el siguiente comando en la base de datos `master`.
```
EXEC master..sp_addsrvrolemember @loginame = N'', @rolename = N'sysadmin'
```
En el ejemplo anterior, sustituya el marcador de posición `` por el nombre del usuario al que concedió anteriormente los privilegios.
Para leer información sobre el Agente SQL Server, agregue su usuario al rol `SQLAgentUser`. Ejecute el siguiente comando en la base de datos `msdb`.
```
EXEC sp_addrolemember , ;
```
En el ejemplo anterior, sustituya el marcador de posición `` por el nombre del rol del Agente SQL Server. A continuación, sustituya el marcador de posición `` por el nombre del usuario al que concedió anteriormente los privilegios. Para obtener más información, consulte [Añadir un usuario al rol de SQLAgent usuario](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.Agent.html#SQLServerAgent.AddUser) en la *Guía del usuario de Amazon RDS*.
Para detectar el envío de registros, conceda el privilegio `SELECT on dbo.log_shipping_primary_databases` en la base de datos de `msdb`.
Para utilizar el enfoque de notificación de la replicación del DDL, conceda el privilegio `RECEIVE ON .` en las bases de datos de origen. En este ejemplo, sustituya el marcador de posición `` por el nombre del esquema de la base de datos. A continuación, sustituya el marcador de posición `` por el nombre de una tabla de colas.
## Uso de la autenticación de Windows al utilizar Microsoft SQL Server como origen
Si la aplicación se ejecuta en una intranet basada en Windows, es posible que pueda utilizar la autenticación de Windows para el acceso a las bases de datos. La autenticación de Windows utiliza la identidad de Windows actual establecida en el subproceso de sistema operativo para obtener acceso a la base de datos de SQL Server. A continuación, puede mapear la identidad de Windows a una base de datos de SQL Server y sus permisos. Para conectarse a SQL Server con la autenticación de Windows, debe especificar la identidad de Windows que utiliza la aplicación. También debe conceder a la identidad de Windows acceso a la base de datos de SQL Server.
SQL Server tiene dos modos de acceso: autenticación de Windows y mixto. El modo de autenticación de Windows habilita dicha autenticación y deshabilita la de SQL Server. El modo mixto habilita tanto la autenticación de Windows como la de SQL Server. La autenticación de Windows siempre está disponible y no se puede deshabilitar. Para obtener más información acerca de la autenticación de Windows, consulte la documentación de Microsoft Windows.
El ejemplo posible para crear un usuario en TEST\$1DB se muestra a continuación.
```
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
```
### Uso de la autenticación de Windows con una conexión JDBC
El controlador JDBC no admite la autenticación de Windows si dicho controlador se utiliza en sistemas operativos que no son de Windows. Las credenciales de autenticación de Windows, como el nombre de usuario y la contraseña, no se especifican de forma automática al conectarse a SQL Server desde sistemas operativos que no son de Windows. En estos casos, las aplicaciones deben utilizar la autenticación de SQL Server.
En la cadena de conexión de JDBC, debe especificarse el parámetro `integratedSecurity` para conectarse mediante la autenticación de Windows. El controlador JDBC admite la autenticación de Windows integrada para los sistemas operativos de Windows a través del parámetro de cadena de conexión `integratedSecurity`.
Para usar la autenticación integrada
1. Instale el controlador JDBC.
1. Copie el archivo `sqljdbc_auth.dll` en un directorio de la ruta de sistema de Windows en el equipo donde está instalado el controlador JDBC.
Los archivos `sqljdbc_auth.dll` se instalan en la ubicación siguiente:
<*directorio de instalación*>\$1sqljdbc\$1<*versión*>\$1<*idioma*>\$1auth\$1
Cuando intenta establecer una conexión con una base de datos de SQL Server con la autenticación de Windows, es posible que aparezca este error: Este controlador no está configurado para la autenticación integrada. Este problema se puede resolver con las siguientes acciones:
+ Declare dos variables que apunten a la ruta instalada de JDBC:
`variable name: SQLJDBC_HOME; variable value: D:\lib\JDBC4.1\enu` (donde reside su archivo sqljdbc4.jar);
`variable name: SQLJDBC_AUTH_HOME; variable value: D\lib\JDBC4.1\enu\auth\x86` (si está ejecutando un sistema operativo de 32 bits) o `D\lib\JDBC4.1\enu\auth\x64` (si está ejecutando un sistema operativo de 64 bits). Aquí es donde reside su archivo `sqljdbc_auth.dll`.
+ `sqljdbc_auth.dll`Cópielo a la carpeta en la que JDK/JRE se está ejecutando. Puede copiarlo en la carpeta lib, la carpeta bin, etc. Como ejemplo, es posible que copie en la siguiente carpeta.
```
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
```
+ Asegúrese de que en la carpeta de la biblioteca JDBC solo tenga el SQLJDBC4 archivo.jar. Quite otros archivos sqljdbc\$1.jar de esa carpeta (o cópielos en otra carpeta). Si va a añadir el controlador como parte de su programa, asegúrese de añadir únicamente el SQLJDBC4 archivo.jar como controlador que va a utilizar.
+ Copie el archivo sqljdbc\$1auth.dll en la carpeta con su aplicación.
**nota**
Si ejecuta una máquina virtual de Java (JVM) de 32 bits, utilice el archivo sqljdbc\$1auth.dll de la carpeta x86, incluso si la versión del sistema operativo es x64. Si ejecuta una JVM de 64 bits en un procesador x64, utilice el archivo sqljdbc\$1auth.dll de la carpeta x64.
Al conectarse a una base de datos de SQL Server, puede elegir **Autenticación de Windows** o **Autenticación de SQL Server** en la opción **Autenticación**.
## Conexión a SQL Server como origen
Utilice el siguiente procedimiento para conectarse a su base de datos Microsoft SQL Server de origen con la AWS Schema Conversion Tool.
**Para conectarse a una base de datos de Microsoft SQL Server de origen**
1. En AWS Schema Conversion Tool, elija **Agregar fuente**.
1. Elija **Microsoft SQL Server** 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 de origen de Microsoft SQL Server, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
# Conversión de SQL Server a MySQL
Para simular las funciones de la base de datos de Microsoft SQL Server en código MySQL convertido, utilice el paquete de extensión de SQL Server a MySQL en AWS SCT. Para obtener más información acerca de los paquetes de extensión , consulte [Uso de paquetes de extensión con AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Privilegios para MySQL como base de datos de destino](#CHAP_Source.SQLServer.ToMySQL.ConfigureTarget)
+ [Configuración de conversión de SQL Server a MySQL](#CHAP_Source.SQLServer.ToMySQL.ConversionSettings)
+ [Consideraciones sobre la migración](#CHAP_Source.SQLServer.ToMySQL.MigrationConsiderations)
## Privilegios para MySQL como base de datos de destino
Los privilegios necesarios para MySQL como destino se enumeran a continuación:
+ CREATE ON \$1.\$1
+ ALTER ON \$1.\$1
+ DROP ON \$1.\$1
+ INDEX ON \$1.\$1
+ REFERENCES ON \$1.\$1
+ SELECT ON \$1.\$1
+ CREATE VIEW ON \$1.\$1
+ SHOW VIEW ON \$1.\$1
+ TRIGGER ON \$1.\$1
+ CREATE ROUTINE ON \$1.\$1
+ ALTER ROUTINE ON \$1.\$1
+ EXECUTE ON \$1.\$1
+ INSERTE Y ACTUALICE EN AWS\$1SQLSERVER \$1EXT. \$1
+ INSERTAR, ACTUALIZAR Y ELIMINAR EN AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
+ CREA TABLAS TEMPORALES EN AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
Puede usar el siguiente ejemplo de código para crear un usuario de base de datos y conceder los privilegios.
```
CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT INSERT, UPDATE ON AWS_SQLSERVER_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON AWS_SQLSERVER_EXT_DATA.* TO 'user_name';
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *your\$1password* sustitúyala por una contraseña segura.
Si utiliza como destino una base de datos MySQL 5.7 o anterior, ejecute el siguiente comando. Para las bases de datos MySQL versión 8.0 y posterior, este comando está obsoleto.
```
GRANT SELECT ON mysql.proc TO 'user_name';
```
Para usar Amazon RDS para MySQL o Aurora MySQL como destino, establezca el parámetro `lower_case_table_names` en `1`. Este valor significa que el servidor MySQL gestiona los identificadores de nombres de objetos como tablas, índices, disparadores y bases de datos sin distinguir entre mayúsculas y minúsculas. Si ha activado el registro binario en la instancia de destino, establezca el parámetro `log_bin_trust_function_creators` en `1`. En este caso, no es necesario utilizar las características `DETERMINISTIC`, `READS SQL DATA` o `NO SQL` para crear funciones almacenadas. Para configurar estos parámetros, cree un grupo de parámetros de base de datos nuevo o modifique uno existente.
## Configuración de conversión de SQL Server a MySQL
Para editar la configuración de conversión de SQL Server a MySQL, AWS SCT seleccione **Configuración** y, a continuación, elija **Configuración de conversión**. En la lista superior, elija **SQL Server** y, a continuación, **SQL Server — MySQL**. AWS SCT muestra todos los ajustes disponibles para la conversión de SQL Server a MySQL.
La configuración de conversión de SQL Server a MySQL AWS SCT 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**, selecciona 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 permitir que la base de datos de SQL Server de origen almacene los resultados `EXEC` en una tabla. AWS SCT crea tablas temporales y un procedimiento adicional para emular esta función. Para usar esta simulación, seleccione **Crear rutinas adicionales para gestionar conjuntos de datos abiertos**.
## Consideraciones sobre la migración
Tenga en cuenta estos aspectos al migrar un esquema de SQL Server a MySQL:
+ MySQL no admite la instrucción `MERGE`. Sin embargo, AWS SCT puede emular la `MERGE` declaración durante la conversión utilizando la `INSERT ON DUPLICATE KEY` cláusula y las `UPDATE FROM and DELETE FROM` declaraciones.
Para conseguir una simulación correcta con `INSERT ON DUPLICATE KEY`, asegúrese de que existe una restricción o una clave principal únicas en la base de datos MySQL de destino.
+ Puede usar una instrucción `GOTO` y una etiqueta para cambiar el orden en el que se ejecutan las instrucciones. Todas las instrucciones Transact-SQL que van detrás de una instrucción `GOTO` se omiten y el procesamiento continúa en la etiqueta. Puede usar las instrucciones `GOTO` y las etiquetas se pueden utilizar en cualquier lugar de un procedimiento, lote o bloque de instrucciones. También puede anidar instrucciones `GOTO`.
MySQL no utiliza instrucciones `GOTO`. Cuando AWS SCT convierte el código que contiene una `GOTO` sentencia, convierte la sentencia para usar una `LOOP…END LOOP` sentencia `BEGIN…END` o. Puede encontrar ejemplos de cómo se AWS SCT convierten `GOTO` las sentencias en la siguiente tabla.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL no admite funciones con valores de tabla con múltiples sentencias. AWS SCT simula funciones con valores de tabla durante una conversión mediante la creación de tablas temporales y la reescritura de las sentencias para utilizarlas.
# Migración de SQL Server a PostgreSQL con AWS Schema Conversion Tool
Puede usar el paquete de extensión de SQL Server a PostgreSQL en AWS SCT. Este paquete de extensión simula las funciones de la base de datos de SQL Server en el código PostgreSQL convertido. Utilice el paquete de extensión de SQL Server a PostgreSQL para simular las funcionalidades de Agente SQL Server y correo electrónico de base de datos de SQL Server. Para obtener más información acerca de los paquetes de extensión, consulte [Uso de paquetes de extensión con AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [Privilegios para PostgreSQL como base de datos de destino](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [Conversión de SQL Server a PostgreSQL](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [Conversión de particiones de SQL Server en particiones de PostgreSQL versión 10](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [Consideraciones sobre la migración](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [Uso de un paquete AWS SCT de extensión para emular el agente de SQL Server en PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [Uso de un paquete AWS SCT de extensión para emular el correo de bases de datos de SQL Server en PostgreSQL](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## Privilegios para PostgreSQL como base de datos de destino
Para usar PostgreSQL como destino AWS SCT , se requiere el privilegio. `CREATE ON DATABASE` Asegúrese de conceder este privilegio a cada base de datos PostgreSQL de destino.
Para usar los sinónimos públicos convertidos, cambie la ruta de búsqueda predeterminada de la base de datos a `"$user", public_synonyms, public`.
Puede usar el siguiente ejemplo de código para crear un usuario de base de datos y conceder los privilegios.
```
CREATE ROLE user_name LOGIN PASSWORD 'your_password';
GRANT CREATE ON DATABASE db_name TO user_name;
ALTER DATABASE db_name SET SEARCH_PATH = "$user", public_synonyms, public;
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *db\$1name* sustitúyalo por el nombre de la base de datos de destino. Por último, *your\$1password* sustitúyala por una contraseña segura.
En PostgreSQL, solo el propietario de un esquema o un `superuser` puede anular un esquema. El propietario puede eliminar un esquema y todos los objetos que incluye este esquema, aunque el propietario del esquema no sea propietario de algunos de los objetos.
Si utiliza distintos usuarios para convertir y aplicar diferentes esquemas a la base de datos de destino, puede aparecer un mensaje de error cuando no AWS SCT puede eliminar un esquema. Para evitar este mensaje de error, utilice el rol de `superuser`.
## Conversión de SQL Server a PostgreSQL
Para editar la configuración de conversión de SAP ASE a PostgreSQL, seleccione **Configuración** y, a continuación, elija **Configuración de conversión**. En la lista superior, elija **SQL Server** y, a continuación, **SQL Server — PostgreSQL**. AWS SCT muestra todos los ajustes disponibles para la conversión de SQL Server a PostgreSQL.
La configuración AWS SCT de conversión de SQL Server a PostgreSQL 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**.
+ Permitir el uso de índices con el mismo nombre en diferentes tablas de SQL Server.
En PostgreSQL, todos los nombres de índice que utilice en el esquema deben ser únicos. Para asegurarse de que AWS SCT genera nombres únicos para todos los índices, seleccione **Generar nombres únicos para los índices**.
+ Convertir los procedimientos de SQL Server en funciones de PostgreSQL.
La versión 10 y anteriores de PostgreSQL no admiten procedimientos. Para los clientes que no estén familiarizados con el uso de procedimientos en PostgreSQL AWS SCT , pueden convertir los procedimientos en funciones. Para ello, seleccione **Convertir procedimientos en funciones**.
+ Simular la salida de `EXEC` en una tabla.
Su base de datos de SQL Server de origen puede almacenar la salida de `EXEC` en una tabla. AWS SCT crea tablas temporales y un procedimiento adicional para simular esta característica. Para usar esta simulación, seleccione **Crear rutinas adicionales para gestionar conjuntos de datos abiertos**.
+ Definir la plantilla que se utilizará para los nombres de los esquemas del código convertido. En **Plantilla de generación de nombres de esquema**, elija una de las siguientes opciones:
+ ****: utiliza el nombre de la base de datos de SQL Server como nombre de esquema en PostgreSQL.
+ ****: utiliza el nombre del esquema de SQL Server como nombre de esquema en PostgreSQL.
+ **\$1**: utiliza una combinación de los nombres de la base de datos y del esquema de SQL Server como nombre de esquema en PostgreSQL.
+ Mantener las mayúsculas y minúsculas de los nombres de los objetos de origen.
Para evitar la conversión de los nombres de los objetos a minúsculas, seleccione **Evitar la conversión a minúsculas para las operaciones que distingan mayúsculas** y minúsculas. Esta opción solo se aplica cuando se activa la opción de distinguir entre mayúsculas y minúsculas en la base de datos de destino.
+ Conservar los nombres de los parámetros de la base de datos de origen.
Para agregar comillas dobles a los nombres de los parámetros del código convertido, seleccione **Conservar los nombres de los parámetros originales**.
## Conversión de particiones de SQL Server en particiones de PostgreSQL versión 10
Al convertir una base de datos de Microsoft SQL Server en Amazon Aurora PostgreSQL Compatible Edition (Aurora PostgreSQL) o Amazon Relational Database Service para PostgreSQL (Amazon RDS para PostgreSQL), tenga en cuenta lo siguiente.
En SQL Server, debe crear particiones con funciones de partición. Cuando una tabla particionada de SQL Server se convierte en una tabla particionada de PostgreSQL versión 10, debe tenerse en cuenta que pueden producirse algunos problemas:
+ SQL Server le permite particionar una tabla utilizando una columna sin la restricción NOT NULL. En ese caso, todos los valores NULL van a la partición situada más a la izquierda. PostgreSQL no admite valores NULL con particiones RANGE.
+ SQL Server le permite crear claves principales y claves únicas para tablas particionadas. En el caso de PostgreSQL, las claves primarias y las claves únicas se crean directamente para cada partición. Por tanto, la restricción PRIMARY o UNIQUE KEY debe eliminarse de la tabla principal al migrar a PostgreSQL. Los nombres de clave resultantes tienen el formato `_`.
+ SQL Server permite crear restricciones de clave externa que tienen como origen o destino tablas particionadas. PostgreSQL no admite las claves externas que hacen referencia a tablas particionadas. Además, PostgreSQL tampoco admite las referencias de clave externa entre una tabla particionada y otra tabla.
+ SQL Server permite crear índices para las tablas particionadas. En PostgreSQL, los índices deben crearse directamente con cada partición. Por lo tanto, los índices deben eliminarse de sus tablas principales al migrar a PostgreSQL. Los nombres de índice resultantes tienen el formato `_`.
+ PostgreSQL no admite índices particionados.
## Consideraciones sobre la migración
Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema de SQL Server a PostgreSQL:
+ En PostgreSQL, todos los nombres de objeto de un esquema deben ser único, incluidos los índices. Los nombres de los índices deben ser únicos en el esquema de la tabla base. En SQL Server, un nombre de índice puede ser igual en diferentes tablas.
Para garantizar la exclusividad de los nombres de índice, AWS SCT ofrece la opción de generar nombres de índice únicos si sus nombres de índice no son únicos. Para ello, seleccione la opción **Generate unique index names** (Generar nombres de índice únicos) en las propiedades del proyecto. Esta opción está habilitada de forma predeterminada. Si esta opción está habilitada, se crean nombres de índice único con el formato IX\$1nombre\$1tabla\$1nombre\$1índice. Si esta opción está deshabilitada, los nombres de índice no se modifican.
+ Para cambiar el orden en el que se ejecutan las instrucciones, se puede utilizar una instrucción GOTO y una etiqueta. Todas las instrucciones Transact-SQL que van detrás de una instrucción GOTO se omiten y el procesamiento continúa en la etiqueta. Las instrucciones GOTO y las etiquetas se pueden utilizar en cualquier lugar de un procedimiento, lote o bloque de instrucciones. Las instrucciones GOTO también se pueden anidar.
PostgreSQL no utiliza instrucciones GOTO. Al AWS SCT convertir código que contiene una sentencia GOTO, convierte la sentencia para utilizar una sentencia BEGIN... END o LOOP... END LOOP. Puede encontrar ejemplos de cómo se AWS SCT convierten las sentencias GOTO en la siguiente tabla.
**Instrucciones GOTO de SQL Server e instrucciones PostgreSQL convertidas**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL no admite la sentencia MERGE. AWS SCT emula el comportamiento de una sentencia MERGE de las siguientes maneras:
+ Mediante la construcción INSERT ON CONFLICT.
+ Mediante la instrucción UPDATE FROM DML, como MERGE sin la cláusula WHEN NOT MATCHED.
+ Mediante el uso de CURSOR, como con una cláusula MERGE con DELETE o mediante el uso de una instrucción de condición compleja MERGE ON.
+ AWS SCT puede añadir activadores de bases de datos al árbol de objetos cuando Amazon RDS es el objetivo.
+ AWS SCT puede añadir activadores a nivel de servidor al árbol de objetos cuando Amazon RDS es el objetivo.
+ SQL Server crea y administra tablas `deleted` y `inserted` de forma automática. Puede utilizar estas tablas temporales que residen en la memoria para probar los efectos de determinadas modificaciones en los datos y establecer las condiciones para las acciones que activen el DML. AWS SCT puede convertir el uso de estas tablas en sentencias de activación de DML.
+ AWS SCT puede añadir servidores enlazados al árbol de objetos cuando Amazon RDS es el objetivo.
+ Al migrar desde Microsoft SQL Server a PostgreSQL, la función SUSER\$1SNAME integrada se convierte tal y como se indica a continuación:
+ SUSER\$1SNAME: devuelve el nombre de inicio de sesión asociado a un número de identificación de seguridad (SID).
+ SUSER\$1SNAME(): no admitido.
+ SUSER\$1SNAME() CURRENT\$1USER: devuelve el nombre de usuario del contexto de ejecución actual.
+ SUSER\$1SNAME (NULL): devuelve NULL.
+ Se permite la conversión de funciones con valores de tabla. Las funciones con valores de tabla devuelven una tabla y pueden tomar el lugar de una tabla en una consulta.
+ PATINDEX devuelve la posición inicial de la primera coincidencia de un patrón en una expresión especificada en todos los tipos de datos de texto y caracteres válidos. Devuelve ceros si no se encuentra el patrón. Al convertir de SQL Server a Amazon RDS para AWS SCT PostgreSQL, reemplaza el código de la aplicación que usa PATINDEX por aws\$1sqlserver\$1ext.patindex (,).
+ En SQL Server, un tipo de tabla definido por el usuario es un tipo que representa la definición de la estructura de una tabla. Se utiliza un tipo de tabla definido por el usuario para declarar parámetros de valor de tabla para procedimientos o funciones almacenados. También puede usar un tipo de tabla definido por el usuario para declarar las variables de tabla que desee usar en un lote o en el cuerpo de una función o procedimiento almacenado. AWS SCT emuló este tipo en PostgreSQL creando una tabla temporal.
Al convertir de SQL Server a PostgreSQL AWS SCT , convierte los objetos del sistema de SQL Server en objetos reconocibles en PostgreSQL. En la siguiente tabla se muestra cómo se convierten los objetos del sistema.
| Casos de uso de MS SQL Server | Sustitución de PostgreSQL |
| --- | --- |
| SYS.SCHEMAS | AWS\$1SQLSERVER\$1EXT.SYS\$1SCHEMAS |
| SYS.TABLES | AWS\$1SQLSERVER\$1EXT.SYS\$1TABLES |
| SYS.VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1VIEWS |
| SYS.ALL\$1VIEWS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1VIEWS |
| SYS.TYPES | AWS\$1SQLSERVER\$1EXT.SYS\$1TYPES |
| SYS.COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1COLUMNS |
| SYS.ALL\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1COLUMNS |
| SYS.FOREIGN\$1KEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEYS |
| SYS.SYSFOREIGNKEYS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYS FOREIGNKEYS |
| SYS.FOREIGN\$1KEY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1FOREIGN\$1KEY\$1COLUMNS |
| SYS.KEY\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.SYS\$1KEY\$1CONSTRAINTS |
| SYS.IDENTITY\$1COLUMNS | AWS\$1SQLSERVER\$1EXT.SYS\$1IDENTITY\$1COLUMNS |
| SYS.PROCEDURES | AWS\$1SQLSERVER\$1EXT.SYS\$1PROCEDURES |
| SYS.INDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1INDEXES |
| SYS.SYSINDEXES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSINDEXES |
| SYS.OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1OBJECTS |
| SYS.ALL\$1OBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1ALL\$1OBJECTS |
| SYS.SYSOBJECTS | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSOBJECTS |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVER\$1EXT.SYS\$1SQL\$1MODULES |
| SYS.DATABASES | AWS\$1SQLSERVER\$1EXT.SYS\$1DATABASES |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1SCHEMATA |
| INFORMATION\$1SCHEMA.VIEWS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1VIEWS |
| INFORMATION\$1SCHEMA.TABLES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLES |
| INFORMATION\$1SCHEMA.COLUMNS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1COLUMNS |
| INFORMATION\$1SCHEMA.CHECK\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CHECK\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.REFERENTIAL\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1REFERENTIAL\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.TABLE\$1CONSTRAINTS | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1TABLE\$1CONSTRAINTS |
| INFORMATION\$1SCHEMA.KEY\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1KEY\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1TABLE\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1TABLE\$1USAGE |
| INFORMATION\$1SCHEMA.CONSTRAINT\$1COLUMN\$1USAGE | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1CONSTRAINT\$1COLUMN\$1USAGE |
| INFORMATION\$1SCHEMA.ROUTINES | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHEMA\$1ROUTINES |
| SYS.SYSPROCESSES | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSPROCESSES |
| sys.system\$1objects | AWS\$1SQLSERVER\$1EXT.SYS\$1SYSTEM\$1OBJECTS |
# Uso de un paquete AWS SCT de extensión para emular el agente de SQL Server en PostgreSQL
El Agente SQL Server es un servicio de Microsoft Windows que ejecuta trabajos de SQL Server. El Agente SQL Server ejecuta trabajos según una programación, en respuesta a un evento concreto o bajo demanda. Para obtener más información sobre el Agente SQL Server, consulte [Agente SQL Server](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15) en la documentación de Microsoft.
PostgreSQL no incluye un equivalente para el Agente SQL Server. Para emular las funciones del agente SQL Server, AWS SCT crea un paquete de extensión. Este paquete de extensión utiliza AWS Lambda Amazon CloudWatch. AWS Lambda implementa la interfaz que se usa para administrar los horarios y ejecutar los trabajos. Amazon CloudWatch mantiene las reglas de programación.
AWS Lambda y Amazon CloudWatch utilizan un parámetro JSON para interactuar. Este parámetro JSON presenta la siguiente estructura.
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
En el ejemplo anterior, *`mode`* es el tipo de tarea y `list of parameters` es un conjunto de parámetros que dependen del tipo de tarea. Además, `procedure name` es el nombre del procedimiento que se ejecuta una vez finalizada la tarea.
AWS SCT usa una función Lambda para controlar y ejecutar los trabajos. La CloudWatch regla inicia la ejecución del trabajo y proporciona la información necesaria para iniciarlo. Cuando la CloudWatch regla se activa, inicia la función Lambda con los parámetros de la regla.
Para crear un trabajo sencillo que llame a un procedimiento, utilice el siguiente formato.
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
Para crear un trabajo con varios pasos, utilice el siguiente formato.
```
{
"mode": "run_job",
"parameters": {
"job_name": "Job1",
"enabled": "true",
"start_step_id": 1,
"notify_level_email": [0|1|2|3],
"notify_email": email,
"delete_level": [0|1|2|3],
"job_callback": "ProcCallBackJob(job_name, code, message)",
"step_callback": "ProcCallBackStep(job_name, step_id, code, message)"
},
"steps": [
{
"id":1,
"cmd": "ProcStep1",
"cmdexec_success_code": 0,
"on_success_action": [|2|3|4],
"on_success_step_id": 1,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
{
"id":2,
"cmd": "ProcStep2",
"cmdexec_success_code": 0,
"on_success_action": [1|2|3|4],
"on_success_step_id": 0,
"on_fail_action": 0,
"on_fail_step_id": 0,
"retry_attempts": number,
"retry_interval": number
},
...
]
}
```
Para emular el comportamiento del agente SQL Server en PostgreSQL, AWS SCT el paquete de extensiones también crea las siguientes tablas y procedimientos.
## Tablas que simulan el Agente SQL Server en PostgreSQL
Para simular el Agente SQL Server, el paquete de extensión utiliza las siguientes tablas:
**sysjobs**
Almacena la información sobre los trabajos.
**sysjobsteps**
Almacena la información sobre los pasos de un trabajo.
**sysschedules**
Almacena la información sobre las programaciones de los trabajos.
**sysjobschedules**
Almacena la información de programación de los trabajos individuales.
**sysjobhistory**
Almacena la información sobre las ejecuciones de los trabajos programados.
## Procedimientos que simulan el Agente SQL Server en PostgreSQL
Para simular el Agente SQL Server, el paquete de extensión utiliza los siguientes procedimientos:
**sp\$1add\$1job**
Agrega un trabajo nuevo.
**sp\$1add\$1jobstep**
Agrega un paso a un trabajo.
**sp\$1add\$1schedule**
Crea una nueva regla de programación en Amazon CloudWatch. Puede usar esta programación con cualquier número de trabajos.
**sp\$1attach\$1schedule**
Establece una programación para el trabajo seleccionado.
**sp\$1add\$1jobschedule**
Crea una regla de programación para un trabajo en Amazon CloudWatch y establece el objetivo de esta regla.
**sp\$1update\$1job**
Actualiza los atributos del trabajo creado anteriormente.
**sp\$1update\$1jobstep**
Actualiza los atributos del paso de un trabajo.
**sp\$1update\$1schedule**
Actualiza los atributos de una regla de programación en Amazon CloudWatch.
**sp\$1update\$1jobschedule**
Actualiza los atributos de la programación del trabajo especificado.
**sp\$1delete\$1job**
Elimina un trabajo.
**sp\$1delete\$1jobstep**
Elimina un paso de un trabajo.
**sp\$1delete\$1schedule**
Elimina una programación.
**sp\$1delete\$1jobschedule**
Elimina la regla de programación para el trabajo especificado de Amazon CloudWatch.
**sp\$1detach\$1schedule**
Elimina la asociación entre una programación y un trabajo.
**get\$1jobs, update\$1job**
Procedimientos internos con los que interactúan AWS Elastic Beanstalk.
**sp\$1verify\$1job\$1date, sp\$1verify\$1job\$1time, sp\$1verify\$1job, sp\$1verify\$1jobstep, sp\$1verify\$1schedule, sp\$1verify\$1job\$1identifiers, sp\$1verify\$1schedule\$1identifiers**
Procedimientos internos que comprueban la configuración.
## Sintaxis para procedimientos que simulan el Agente SQL Server en PostgreSQL
El procedimiento `aws_sqlserver_ext.sp_add_job` del paquete de extensión simula el procedimiento `msdb.dbo.sp_add_job`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-job-transact-sql?view=sql-server-ver15).
```
par_job_name varchar,
par_enabled smallint = 1,
par_description varchar = NULL::character varying,
par_start_step_id integer = 1,
par_category_name varchar = NULL::character varying,
par_category_id integer = NULL::integer,
par_owner_login_name varchar = NULL::character varying,
par_notify_level_eventlog integer = 2,
par_notify_level_email integer = 0,
par_notify_level_netsend integer = 0,
par_notify_level_page integer = 0,
par_notify_email_operator_name varchar = NULL::character varying,
par_notify_netsend_operator_name varchar = NULL::character varying,
par_notify_page_operator_name varchar = NULL::character varying,
par_delete_level integer = 0,
inout par_job_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_add_jobstep` del paquete de extensión simula el procedimiento `msdb.dbo.sp_add_jobstep`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
par_step_name varchar = NULL::character varying,
par_subsystem varchar = 'TSQL'::bpchar,
par_command text = NULL::text,
par_additional_parameters text = NULL::text,
par_cmdexec_success_code integer = 0,
par_on_success_action smallint = 1,
par_on_success_step_id integer = 0,
par_on_fail_action smallint = 2,
par_on_fail_step_id integer = 0,
par_server varchar = NULL::character varying,
par_database_name varchar = NULL::character varying,
par_database_user_name varchar = NULL::character varying,
par_retry_attempts integer = 0,
par_retry_interval integer = 0,
par_os_run_priority integer = 0,
par_output_file_name varchar = NULL::character varying,
par_flags integer = 0,
par_proxy_id integer = NULL::integer,
par_proxy_name varchar = NULL::character varying,
inout par_step_uid char = NULL::bpchar,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_add_schedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_add_schedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_name varchar,
par_enabled smallint = 1,
par_freq_type integer = 0,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
par_owner_login_name varchar = NULL::character varying,
*inout par_schedule_uid char = NULL::bpchar,*
inout par_schedule_id integer = NULL::integer,
par_originating_server varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_attach_schedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_attach_schedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-attach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_automatic_post smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_add_jobschedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_add_jobschedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-add-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_enabled smallint = 1,
par_freq_type integer = 1,
par_freq_interval integer = 0,
par_freq_subday_type integer = 0,
par_freq_subday_interval integer = 0,
par_freq_relative_interval integer = 0,
par_freq_recurrence_factor integer = 0,
par_active_start_date integer = NULL::integer,
par_active_end_date integer = 99991231,
par_active_start_time integer = 0,
par_active_end_time integer = 235959,
inout par_schedule_id integer = NULL::integer,
par_automatic_post smallint = 1,
inout par_schedule_uid char = NULL::bpchar,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_delete_job` del paquete de extensión simula el procedimiento `msdb.dbo.sp_delete_job`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_originating_server varchar = NULL::character varying,
par_delete_history smallint = 1,
par_delete_unused_schedule smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_delete_jobstep` del paquete de extensión simula el procedimiento `msdb.dbo.sp_delete_jobstep`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobsteplog-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_step_id integer = NULL::integer,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_delete_jobschedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_delete_jobschedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_name varchar = NULL::character varying,
par_keep_schedule integer = 0,
par_automatic_post smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_delete_schedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_delete_schedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-delete-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_force_delete smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_detach_schedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_detach_schedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-detach-schedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer,
par_job_name varchar = NULL::character varying,
par_schedule_id integer = NULL::integer,
par_schedule_name varchar = NULL::character varying,
par_delete_unused_schedule smallint = 0,
par_automatic_post smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_update_job` del paquete de extensión simula el procedimiento `msdb.dbo.sp_update_job`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-job-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_description varchar = NULL::character varying
par_start_step_id integer = NULL::integer
par_category_name varchar = NULL::character varying
par_owner_login_name varchar = NULL::character varying
par_notify_level_eventlog integer = NULL::integer
par_notify_level_email integer = NULL::integer
par_notify_level_netsend integer = NULL::integer
par_notify_level_page integer = NULL::integer
par_notify_email_operator_name varchar = NULL::character varying
par_notify_netsend_operator_name varchar = NULL::character varying
par_notify_page_operator_name varchar = NULL::character varying
par_delete_level integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_update_jobschedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_update_jobschedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobschedule-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_automatic_post smallint = 1
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_update_jobstep` del paquete de extensión simula el procedimiento `msdb.dbo.sp_update_jobstep`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-jobstep-transact-sql?view=sql-server-ver15).
```
par_job_id integer = NULL::integer
par_job_name varchar = NULL::character varying
par_step_id integer = NULL::integer
par_step_name varchar = NULL::character varying
par_subsystem varchar = NULL::character varying
par_command text = NULL::text
par_additional_parameters text = NULL::text
par_cmdexec_success_code integer = NULL::integer
par_on_success_action smallint = NULL::smallint
par_on_success_step_id integer = NULL::integer
par_on_fail_action smallint = NULL::smallint
par_on_fail_step_id integer = NULL::integer
par_server varchar = NULL::character varying
par_database_name varchar = NULL::character varying
par_database_user_name varchar = NULL::character varying
par_retry_attempts integer = NULL::integer
par_retry_interval integer = NULL::integer
par_os_run_priority integer = NULL::integer
par_output_file_name varchar = NULL::character varying
par_flags integer = NULL::integer
par_proxy_id integer = NULL::integer
par_proxy_name varchar = NULL::character varying
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sp_update_schedule` del paquete de extensión simula el procedimiento `msdb.dbo.sp_update_schedule`. Para obtener más información sobre el Agente SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-update-schedule-transact-sql?view=sql-server-ver15).
```
par_schedule_id integer = NULL::integer
par_name varchar = NULL::character varying
par_new_name varchar = NULL::character varying
par_enabled smallint = NULL::smallint
par_freq_type integer = NULL::integer
par_freq_interval integer = NULL::integer
par_freq_subday_type integer = NULL::integer
par_freq_subday_interval integer = NULL::integer
par_freq_relative_interval integer = NULL::integer
par_freq_recurrence_factor integer = NULL::integer
par_active_start_date integer = NULL::integer
par_active_end_date integer = NULL::integer
par_active_start_time integer = NULL::integer
par_active_end_time integer = NULL::integer
par_owner_login_name varchar = NULL::character varying
par_automatic_post smallint = 1
out returncode integer
```
## Ejemplos de uso de procedimientos que simulan el Agente SQL Server en PostgreSQL
Para agregar un trabajo nuevo, utilice el procedimiento `aws_sqlserver_ext.sp_add_job` que se muestra a continuación.
```
SELECT * FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_job',
par_enabled := 1::smallint,
par_start_step_id := 1::integer,
par_category_name := '[Uncategorized (Local)]',
par_owner_login_name := 'sa');
```
Para agregar un paso de trabajo nuevo, utilice el procedimiento `aws_sqlserver_ext.sp_add_jobstep` que se muestra a continuación.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_job',
par_step_id := 1::smallint,
par_step_name := 'test_job_step1',
par_subsystem := 'TSQL',
par_command := 'EXECUTE [dbo].[PROC_TEST_JOB_STEP1];',
par_server := NULL,
par_database_name := 'GOLD_TEST_SS');
```
Para agregar una programación simple, utilice el procedimiento `aws_sqlserver_ext.sp_add_schedule` que se muestra a continuación.
```
SELECT * FROM aws_sqlserver_ext.sp_add_schedule(
par_schedule_name := 'RunOnce',
par_freq_type := 1,
par_active_start_time := 233000);
```
Para establecer una programación para un trabajo, utilice el procedimiento `aws_sqlserver_ext.sp_attach_schedule` que se muestra a continuación.
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
Para agregar una programación para un trabajo, utilice el procedimiento `aws_sqlserver_ext.sp_add_jobschedule` que se muestra a continuación.
```
SELECT * FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_job2',
par_name := 'test_schedule2',
par_enabled := 1::smallint,
par_freq_type := 4,
par_freq_interval := 1,
par_freq_subday_type := 4,
par_freq_subday_interval := 1,
par_freq_relative_interval := 0,
par_freq_recurrence_factor := 0,
par_active_start_date := 20100801,
par_active_end_date := 99991231,
par_active_start_time := 0,
par_active_end_time := 0);
```
## Ejemplos de casos de uso para simular el Agente SQL Server en PostgreSQL
Si el código fuente de la base de datos utiliza el agente de SQL Server para ejecutar los trabajos, puede utilizar el paquete de extensión de SQL Server a PostgreSQL AWS SCT para convertir este código a PostgreSQL. El paquete de extensiones utiliza AWS Lambda funciones para emular el comportamiento del agente SQL Server.
Puede crear una AWS Lambda función nueva o registrar una función existente.
**Para crear una AWS Lambda función nueva**
1. En AWS SCT, en el árbol de la base de datos de destino, abra el menú contextual (haga clic con el botón derecho), elija **Aplicar paquete de extensión para** y, a continuación, elija **PostgreSQL**.
Aparecerá el asistente de paquete de extensión.
1. En la pestaña **Servicio de simulación del Agente SQL Server**, haga lo siguiente:
+ Seleccione **Crear una AWS Lambda función**.
+ En **Iniciar sesión en la base de datos**, introduzca el nombre del usuario de la base de datos de destino.
+ En **Contraseña de la base de datos**, introduzca la contraseña del nombre de usuario que introdujo en el paso anterior.
+ En **carpeta de la biblioteca Python**, introduzca la ruta a la carpeta de la biblioteca de Python.
+ Elija **Crear AWS Lambda función** y, a continuación, elija **Siguiente**.
**Para registrar una AWS Lambda función que implementó anteriormente**
+ Ejecute el siguiente script en la base de datos de destino.
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
En el ejemplo anterior, *`ARN`* es el nombre de recurso de Amazon (ARN) de la función AWS Lambda implementada.
En el siguiente ejemplo se crea una tarea simple que consta de un paso. Cada cinco minutos, esta tarea ejecuta la función `job_example` creada anteriormente. Esta función inserta los registros en la tabla `job_example_table`.
**Para crear esta tarea simple**
1. Cree un trabajo mediante la función `aws_sqlserver_ext.sp_add_job` según se muestra a continuación.
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. Cree un paso de trabajo mediante la función `aws_sqlserver_ext.sp_add_jobstep` según se muestra a continuación.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobstep (
par_job_name := 'test_simple_job',
par_step_name := 'test_simple_job_step1',
par_command := 'PERFORM job_simple_example;');
```
El paso de trabajo especifica lo que hace la función.
1. Cree una programación para el trabajo mediante la función `aws_sqlserver_ext.sp_add_jobschedule` según se muestra a continuación.
```
SELECT
FROM aws_sqlserver_ext.sp_add_jobschedule (
par_job_name := 'test_simple_job',
par_name := 'test_schedule',
par_freq_type := 4, /* Daily */
par_freq_interval := 1, /* frequency_interval is unused */
par_freq_subday_type := 4, /* Minutes */
par_freq_subday_interval := 5 /* 5 minutes */);
```
El paso de trabajo especifica lo que hace la función.
Para eliminar este trabajo, utilice la función `aws_sqlserver_ext.sp_delete_job` según se muestra a continuación.
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# Uso de un paquete AWS SCT de extensión para emular el correo de bases de datos de SQL Server en PostgreSQL
Puede utilizar el correo electrónico de base de datos de SQL Server para enviar mensajes de correo electrónico a los usuarios desde el motor de base de datos de SQL Server o la instancia administrada de Azure SQL. Estos mensajes de correo electrónico pueden contener resultados de consultas o incluir archivos de cualquier recurso de la red. Para obtener más información sobre el correo electrónico de base de datos de SQL Server, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15).
PostgreSQL no incluye un equivalente para el correo electrónico de base de datos de SQL Server. Para simular las funciones del correo electrónico de base de datos de SQL Server, AWS SCT crea un paquete de extensión. Este paquete de extensión utiliza AWS Lambda Amazon Simple Email Service (Amazon SES). AWS Lambda proporciona a los usuarios una interfaz para interactuar con el servicio de envío de correo electrónico Amazon SES. Para configurar esta interacción, agregue el nombre de recurso de Amazon (ARN) de su función de Lambda.
En una nueva cuenta de correo electrónico, utilice el siguiente comando.
```
do
$$
begin
PERFORM sysmail_add_account_sp (
par_account_name :='your_account_name',
par_email_address := 'your_account_email',
par_display_name := 'your_account_display_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
Para agregar el ARN de la función de Lambda a la cuenta de correo electrónico existente, utilice el siguiente comando.
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
En los ejemplos anteriores, *`ARN`* es el ARN de la función de Lambda.
Para simular el comportamiento del correo electrónico de base de datos de SQL Server en PostgreSQL, el paquete de extensión de AWS SCT también crea las siguientes tablas y procedimientos.
## Tablas que simulan el correo electrónico de base de datos de SQL Server en PostgreSQL
Para simular el correo electrónico de base de datos de SQL Server, el paquete de extensión utiliza las siguientes tablas:
**sysmail\$1account**
Almacena la información sobre las cuentas de correo electrónico.
**sysmail\$1profile**
Almacena la información sobre los perfiles de usuario.
**sysmail\$1server**
Almacena la información sobre los servidores de correo electrónico.
**sysmail\$1mailitems**
Almacena la lista de los mensajes de correo electrónico.
**sysmail\$1attachments**
Contiene una fila para cada archivos adjunto de correo electrónico.
**sysmail\$1log**
Almacena la información de servicio sobre el envío de mensajes de correo electrónico.
**sysmail\$1profileaccount**
Almacena la información sobre los perfiles de usuario y las cuentas de correo electrónico.
## Vistas que simulan el correo electrónico de base de datos de SQL Server en PostgreSQL
Para emular SQL Server Database Mail, AWS SCT crea las siguientes vistas en la base de datos PostgreSQL para garantizar la compatibilidad. El paquete de extensión no las usa, pero el código convertido puede consultar estas vistas.
**sysmail\$1allitems**
Incluye una lista de todos los correos electrónicos.
**sysmail\$1faileditems**
Incluye una lista de los correos electrónicos que no se pudieron enviar.
**sysmail\$1sentitems**
Incluye una lista de los correos electrónicos enviados.
**sysmail\$1unsentitems**
Incluye una lista de los correos electrónicos que aún no se han enviado.
**sysmail\$1mailattachments**
Incluye una lista de archivos adjuntos.
## Procedimientos que simulan el correo electrónico de base de datos de SQL Server en PostgreSQL
Para simular el correo electrónico de base de datos de SQL Server, el paquete de extensión utiliza los siguientes procedimientos:
**sp\$1send\$1dbmail**
Envía un correo electrónico a los destinatarios especificados.
**sysmail\$1add\$1profile\$1sp**
Crea un perfil de usuario nuevo.
**sysmail\$1add\$1account\$1sp**
Crea una cuenta de correo electrónico nueva que almacena información como las credenciales del protocolo simple de transferencia de correo (SMTP), etc.
**sysmail\$1add\$1profileaccount\$1sp**
Agrega una cuenta de correo electrónico al perfil de usuario especificado.
**sysmail\$1update\$1profile\$1sp**
Cambia los atributos del perfil de usuario, como la descripción, el nombre, etc.
**sysmail\$1update\$1account\$1sp**
Cambia la información de la cuenta de correo electrónico existente.
**sysmail\$1update\$1profileaccount\$1sp**
Actualiza la información de la cuenta de correo electrónico en el perfil de usuario especificado.
**sysmail\$1delete\$1profileaccount\$1sp**
Elimina una cuenta de correo electrónico del perfil de usuario especificado.
**sysmail\$1delete\$1account\$1sp**
Elimina la cuenta de correo electrónico.
**sysmail\$1delete\$1profile\$1sp**
Elimina el perfil de usuario.
**sysmail\$1delete\$1mailitems\$1sp**
Elimina los correos electrónicos de las tablas internas.
**sysmail\$1help\$1profile\$1sp**
Muestra información sobre el perfil del usuario.
**sysmail\$1help\$1account\$1sp**
Muestra información sobre la cuenta de correo electrónico.
**sysmail\$1help\$1profileaccount\$1sp**
Muestra información sobre las cuentas de correo electrónico asociadas al perfil de usuario.
**sysmail\$1dbmail\$1json**
Procedimiento interno que genera solicitudes de funciones en JSON. AWS Lambda
**sysmail\$1verify\$1profile\$1sp, sysmail\$1verify\$1account\$1sp, sysmail\$1verify\$1addressparams\$1sp**
Procedimientos internos que comprueban la configuración.
**sp\$1get\$1dbmail, sp\$1set\$1dbmail, sysmail\$1dbmail\$1xml**
Procedimientos internos obsoletos.
## Sintaxis para procedimientos que simulan el correo electrónico de base de datos de SQL Server en PostgreSQL
El procedimiento `aws_sqlserver_ext.sp_send_dbmail` del paquete de extensión simula el procedimiento `msdb.dbo.sp_send_dbmail`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar = NULL::character varying,
par_recipients text = NULL::text,
par_copy_recipients text = NULL::text,
par_blind_copy_recipients text = NULL::text,
par_subject varchar = NULL::character varying,
par_body text = NULL::text,
par_body_format varchar = NULL::character varying,
par_importance varchar = 'NORMAL'::character varying,
par_sensitivity varchar = 'NORMAL'::character varying,
par_file_attachments text = NULL::text,
par_query text = NULL::text,
par_execute_query_database varchar = NULL::character varying,
par_attach_query_result_as_file smallint = 0,
par_query_attachment_filename varchar = NULL::character varying,
par_query_result_header smallint = 1,
par_query_result_width integer = 256,
par_query_result_separator VARCHAR = ' '::character varying,
par_exclude_query_output smallint = 0,
par_append_query_error smallint = 0,
par_query_no_truncate smallint = 0,
par_query_result_no_padding smallint = 0,
out par_mailitem_id integer,
par_from_address text = NULL::text,
par_reply_to text = NULL::text,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_delete_mailitems_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_delete_mailitems_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-mailitems-sp-transact-sql?view=sql-server-ver15).
```
par_sent_before timestamp = NULL::timestamp without time zone,
par_sent_status varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_add_profile_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_add_profile_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_name varchar,
par_description varchar = NULL::character varying,
out par_profile_id integer,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_add_account_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_add_account_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_name varchar
par_email_address varchar
par_display_name varchar = NULL::character varying
par_replyto_address varchar = NULL::character varying
par_description varchar = NULL::character varying
par_mailserver_name varchar = NULL::character varying
par_mailserver_type varchar = 'SMTP'::bpchar
par_port integer = 25
par_username varchar = NULL::character varying
par_password varchar = NULL::character varying
par_use_default_credentials smallint = 0
par_enable_ssl smallint = 0
out par_account_id integer
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_add_profileaccount_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_add_profileaccount_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_help_profile_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_help_profile_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_update_profile_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_update_profile_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_description varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_delete_profile_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_delete_profile_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profile-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_force_delete smallint = 1,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_help_account_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_help_account_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_update_account_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_update_account_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_email_address varchar = NULL::character varying,
par_display_name varchar = NULL::character varying,
par_replyto_address varchar = NULL::character varying,
par_description varchar = NULL::character varying,
par_mailserver_name varchar = NULL::character varying,
par_mailserver_type varchar = NULL::character varying,
par_port integer = NULL::integer,
par_username varchar = NULL::character varying,
par_password varchar = NULL::character varying,
par_use_default_credentials smallint = NULL::smallint,
par_enable_ssl smallint = NULL::smallint,
par_timeout integer = NULL::integer,
par_no_credential_change smallint = NULL::smallint,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_delete_account_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_delete_account_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-account-sp-transact-sql?view=sql-server-ver15).
```
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_help_profileaccount_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_help_profileaccount_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_update_profileaccount_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_update_profileaccount_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-update-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
par_sequence_number integer = NULL::integer,
out returncode integer
```
El procedimiento `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` del paquete de extensión simula el procedimiento `msdb.dbo.sysmail_delete_profileaccount_sp`. Para obtener más información sobre el correo electrónico de base de datos de SQL Server de origen, consulte [Documentación técnica de Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-delete-profileaccount-sp-transact-sql?view=sql-server-ver15).
```
par_profile_id integer = NULL::integer,
par_profile_name varchar = NULL::character varying,
par_account_id integer = NULL::integer,
par_account_name varchar = NULL::character varying,
out returncode integer
```
## Ejemplos de uso de procedimientos que simulan el correo electrónico de base de datos de SQL Server en PostgreSQL
Para enviar un correo electrónico, utilice el procedimiento `aws_sqlserver_ext.sp_send_dbmail` que se muestra a continuación.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
El siguiente ejemplo muestra cómo enviar un correo electrónico con resultados de consulta.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Account with id = 1',
par_query := 'SELECT COUNT(*)FROM Account WHERE id = 1'
);
```
En el siguiente ejemplo de código se muestra cómo enviar un correo electrónico con código HTML.
```
DECLARE var_tableHTML TEXT;
SET var_tableHTML := CONCAT(
'Work Order Report
',
'',
'| Work Order ID | Product ID | ',
'Name | Order Qty | Due Date | ',
'Expected Revenue |
|---|
',
'
'
);
PERFORM sp_send_dbmail (
par_recipients := 'hello@rusgl.info',
par_subject := 'Work Order List',
par_body := var_tableHTML,
par_body_format := 'HTML'
);
```
Para eliminar correos electrónicos, utilice el procedimiento `aws_sqlserver_ext.sysmail_delete_mailitems_sp` que se muestra a continuación.
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
En el siguiente ejemplo se muestra cómo se eliminan los correos electrónicos más antiguos.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
En el siguiente ejemplo se muestra cómo se eliminan todos los correos electrónicos que no se pueden enviar.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
Para crear un perfil de usuario nuevo, utilice el procedimiento `aws_sqlserver_ext.sysmail_add_profile_sp` que se muestra a continuación.
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
En el siguiente ejemplo se muestra cómo crear un perfil nuevo y guardar el identificador de perfil único en una variable.
```
DECLARE var_profileId INT;
SELECT par_profile_id
FROM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := ' Profile used for administrative mail.')
INTO var_profileId;
SELECT var_profileId;
```
Para crear una cuenta de correo electrónico nueva, utilice el procedimiento `aws_sqlserver_ext.sysmail_add_account_sp` como se muestra a continuación.
```
PERFORM sysmail_add_account_sp (
par_account_name :='Audit Account',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_description := 'Account for administrative e-mail.',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'arn:aws:lambda:us-west-2:555555555555:function:pg_v3'
);
```
Para agregar una cuenta de correo electrónico al perfil de usuario, utilice el procedimiento `aws_sqlserver_ext.sysmail_add_profileaccount_sp` según se muestra a continuación.
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## Ejemplos de casos de uso para simular el correo electrónico de base de datos de SQL Server en PostgreSQL
Si el código fuente de su base de datos usa SQL Server Database Mail para enviar correos electrónicos, puede usar el paquete de AWS SCT extensión para convertir este código a PostgreSQL.
**Para enviar un correo electrónico desde su base de datos de PostgreSQL**
1. Cree y configure su función. AWS Lambda
1. Aplica el paquete AWS SCT de extensión.
1. Cree un perfil de usuario mediante la función `sysmail_add_profile_sp` según se muestra a continuación.
1. Cree una cuenta de correo electrónico mediante la función `sysmail_add_account_sp` según se muestra a continuación.
1. Agregue esta cuenta de correo electrónico a su perfil de usuario mediante la función `sysmail_add_profileaccount_sp` según se muestra a continuación.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_settings_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sysmail_add_profile_sp(
par_profile_name := 'Administrator',
par_description := 'administrative mail'
);
PERFORM aws_sqlserver_ext.sysmail_add_account_sp(
par_account_name := 'Audit Account',
par_description := 'Account for administrative e-mail.',
par_email_address := 'dba@rusgl.info',
par_display_name := 'Test Automated Mailer',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'your_ARN'
);
PERFORM aws_sqlserver_ext.sysmail_add_profileaccount_sp(
par_profile_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
END;
$BODY$
LANGUAGE plpgsql;
```
1. Envíe un correo electrónico mediante la función `sp_send_dbmail` según se muestra a continuación.
```
CREATE OR REPLACE FUNCTION aws_sqlserver_ext.
proc_dbmail_send_msdb()
RETURNS void
AS
$BODY$
BEGIN
PERFORM aws_sqlserver_ext.sp_send_dbmail(
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_body := 'The stored procedure finished',
par_subject := 'Automated Success Message'
);
END;
$BODY$
LANGUAGE plpgsql;
```
Para ver la información sobre todos los perfiles de usuario, utilice el procedimiento `sysmail_help_profile_sp` que se muestra a continuación.
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
En el siguiente ejemplo se muestra información acerca del perfil de usuario específico.
```
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profile_sp(par_profile_name := 'Administrator');
```
Para ver la información sobre todos las cuentas de correo electrónico, utilice el procedimiento `sysmail_help_account_sp` que se muestra a continuación.
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
En el siguiente ejemplo se muestra información acerca de la cuenta de correo electrónico específica.
```
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_account_sp(par_account_name := 'Audit Account');
```
Para ver la información sobre todas las cuentas de correo electrónico que están asociadas a los perfiles de usuario, utilice el procedimiento `sysmail_help_profileaccount_sp` según se muestra a continuación.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
El siguiente ejemplo filtra los registros por identificador, nombre de perfil o nombre de cuenta.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_id := 1, par_account_id := 1);
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_profile_name := 'Administrator');
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp(par_account_name := 'Audit Account');
```
Para cambiar el nombre o la descripción del perfil de usuario, utilice el procedimiento `sysmail_update_profile_sp` según se muestra a continuación.
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
Para cambiar la configuración de la cuenta de correo electrónico, utilice el procedimiento `ysmail_update_account_sp` según se muestra a continuación.
```
select from aws_sqlserver_ext.sysmail_update_account_sp (
par_account_name := 'Audit Account',
par_mailserver_name := 'arn:aws:lambda:region:XXXXXXXXXXXX:function:func_test',
par_mailserver_type := 'AWSLAMBDA'
);
```
# Migración de SQL Server a Amazon RDS para SQL Server con AWS Schema Conversion Tool
Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema y un código de SQL Server a Amazon RDS para SQL Server:
+ AWS SCT puede convertir el agente de SQL Server para proporcionar horarios, alertas y trabajos en una instancia de base de datos de Amazon RDS for SQL Server. Después de la conversión, puede utilizar una instancia de base de datos de Amazon RDS para SQL Server con SQL Server Reporting Services (SSRS), SQL Server Analysis Services (SSAS) y SQL Server Integration Services (SSIS).
+ Actualmente, Amazon RDS no admite SQL Server Service Broker ni puntos de enlace de T-SQL adicionales que requieran ejecutar el comando CREATE ENDPOINT.
+ Amazon RDS tiene una compatibilidad limitada con los servidores enlazados. Al convertir el código de una aplicación de SQL Server que utiliza servidores enlazados, AWS SCT convierte el código de la aplicación. Sin embargo, asegúrese de revisar el comportamiento de los objetos que utilizan servidores enlazados antes de ejecutar el código convertido.
+ Se usa siempre encendido.
+ El informe AWS SCT de evaluación proporciona las métricas del servidor para la conversión. Estas métricas acerca de la instancia de SQL Server incluyen:
+ Uso de la replicación de datos.
+ Configuración de Trasvase de registros de SQL Server.
+ Uso de un clúster de conmutación por error.
+ Configuración de Correo electrónico de base de datos.
+ Uso de Servicio de búsqueda de texto completo. La búsqueda de texto completo en Amazon RDS para SQL Server es limitada y no admite la búsqueda semántica.
+ Instalación de Data Quality Services (DQS). Amazon RDS no admite DQS. Por consiguiente, recomendamos instalar SQL Server en una instancia Amazon EC2.
## Privilegios para RDS para SQL Server como destino
Para migrar a RDS para SQL Server, cree un usuario de base de datos y, a continuación, otorgue los privilegios necesarios para cada base de datos. Puede utilizar el siguiente código de ejemplo.
```
CREATE LOGIN user_name WITH PASSWORD 'your_password';
USE db_name
CREATE USER user_name FOR LOGIN user_name
GRANT VIEW DEFINITION TO user_name
GRANT VIEW DATABASE STATE TO user_name
GRANT CREATE SCHEMA TO user_name;
GRANT CREATE TABLE TO user_name;
GRANT CREATE VIEW TO user_name;
GRANT CREATE TYPE TO user_name;
GRANT CREATE DEFAULT TO user_name;
GRANT CREATE FUNCTION TO user_name;
GRANT CREATE PROCEDURE TO user_name;
GRANT CREATE ASSEMBLY TO user_name;
GRANT CREATE AGGREGATE TO user_name;
GRANT CREATE FULLTEXT CATALOG TO user_name;
GRANT CREATE SYNONYM TO user_name;
GRANT CREATE XML SCHEMA COLLECTION TO user_name;
```
En el ejemplo anterior, *user\$1name* sustitúyalo por el nombre de tu usuario. A continuación, *db\$1name* sustitúyalo por el nombre de la base de datos de destino. Por último, *your\$1password* sustitúyala por una contraseña segura.
# Fuentes de almacenamiento de datos para AWS Schema Conversion Tool
AWS SCT puede convertir los esquemas de los siguientes almacenes de datos de origen en un destino compatible. Para obtener información sobre los permisos, las conexiones y lo que AWS SCT se puede convertir para su uso con la base de datos o el almacén de datos de destino, consulte los detalles que aparecen a continuación.
**Topics**
+ [Conexión de Amazon Redshift con AWS Schema Conversion Tool](CHAP_Source.Redshift.md)
+ [Conexión de Azure Synapse Analytics con AWS Schema Conversion Tool](CHAP_Source.AzureSynapse.md)
+ [Conectarse a Google BigQuery con AWS Schema Conversion Tool](CHAP_Source.BigQuery.md)
+ [Conectando la base de datos Greenplum con AWS Schema Conversion Tool](CHAP_Source.Greenplum.md)
+ [Conectarse a Netezza con AWS Schema Conversion Tool](CHAP_Source.Netezza.md)
+ [Conectando Oracle Data Warehouse con AWS SCT](CHAP_Source.OracleDW.md)
+ [Conexión a un almacén de datos de Snowflake con AWS Schema Conversion Tool](CHAP_Source.Snowflake.md)
+ [Conexión a un almacén de datos de SQL Server con AWS Schema Conversion Tool](CHAP_Source.SQLServerDW.md)
+ [Conexión a un almacén de datos de Teradata con AWS Schema Conversion Tool](CHAP_Source.Teradata.md)
+ [Conectándolas AWS Schema Conversion Tool a las bases de datos de Vertica](CHAP_Source.Vertica.md)
# Conexión de Amazon Redshift con AWS Schema Conversion Tool
Puede usarlo AWS SCT para optimizar su clúster de Amazon Redshift. AWS SCT le proporciona recomendaciones sobre la selección de claves de distribución y clasificación para su clúster de Amazon Redshift. Puede considerar el proyecto de optimización de Amazon Redshift como un AWS SCT proyecto en el que el origen y el destino apuntan a los distintos clústeres de Amazon Redshift.
## Privilegios para Amazon Redshift como base de datos de origen
Los privilegios necesarios para usar Amazon Redshift como origen se enumeran a continuación:
+ USO EN EL ESQUEMA **
+ SELECCIONE EN TODAS LAS TABLAS DEL ESQUEMA **
+ SELECT ON PG\$1CATALOG.PG\$1STATISTIC
+ SELECT ON SVV\$1TABLE\$1INFO
+ SELECT ON TABLE STV\$1BLOCKLIST
+ SELECT ON TABLE STV\$1TBL\$1PERM
+ SELECT ON SYS\$1SERVERLESS\$1USAGE
+ SELECT ON PG\$1DATABASE\$1INFO
+ SELECT ON PG\$1STATISTIC
En los ejemplos anteriores, sustituya el ** marcador de posición por el nombre del esquema de origen.
Para conocer los privilegios necesarios para Amazon Redshift como destino, consulte [Permisos para Amazon Redshift como destino](CHAP_Converting.DW.md#CHAP_Converting.DW.ConfigureTarget).
## Conexión a Amazon Redshift como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Amazon Redshift con AWS Schema Conversion Tool.
**Para conectarse a una base de datos de Amazon Redshift**
1. En AWS Schema Conversion Tool, elija **Agregar fuente**.
1. Seleccione **Amazon Redshift** 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 la información de conexión de la base de datos de Amazon Redshift de origen, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Redshift.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de optimización de Amazon Redshift
Para editar la configuración de optimización de Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, elija **Amazon Redshift** y, a continuación, **Amazon Redshift — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la optimización de Amazon Redshift.
La configuración de optimización de Amazon Redshift AWS SCT 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 el número de tablas es superior al que el clúster de Amazon Redshift puede almacenar. 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.
+ Para elegir la estrategia de migración.
AWS recomienda utilizar diferentes clústeres como origen y destino para su proyecto de optimización. Antes de iniciar el proceso de optimización de Amazon Redshift, debe crear una copia del clúster de Amazon Redshift de origen. Puede incluir los datos de origen en esta copia o crear un clúster vacío.
En **Estrategia de migración**, elija **Migración a una copia** para incluir los datos del clúster de origen en el clúster de destino.
En **Estrategia de migración**, seleccione **Migración desde cero** para revisar las sugerencias de optimización. Tras aceptar estas sugerencias, migre los datos de origen al clúster de destino.
+ 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 ha seleccionado la opción **Usar codificación de compresión**.
+ Trabajar con optimización automática de tablas.
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 utilizarla únicamente en la optimización automática de tablas, elija **Estrategias de optimización** en el panel izquierdo. A continuación, seleccione **Utilizar el ajuste automático de tablas de Amazon Redshift** y 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 **Valor de umbral descompensado**, introduzca el porcentaje (0—100) de un valor descompensado 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 descompensado 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.
# Conexión de Azure Synapse Analytics con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Azure Synapse Analytics a Amazon Redshift.
## Privilegios para Azure Synapse Analytics como base de datos de origen
Se requieren los siguientes privilegios para usar un almacenamiento de datos de Azure Synapse Analytics como origen:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Aplicar los privilegios para cada base de datos cuyo esquema vaya a convertir.
## Conexión a Azure Synapse Analytics como origen
Siga este procedimiento para conectarse a su almacenamiento de datos de Azure Synapse Analytics con AWS Schema Conversion Tool.
**Para conectarse a un almacenamiento de datos de Azure Synapse Analytics como origen**
1. **En AWS Schema Conversion Tool, elija Agregar fuente.**
1. Elija **Azure Synapse Analytics** 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 del almacenamiento de datos de Azure Synapse Analytics, siga estas instrucciones:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.AzureSynapse.html)
1. Seleccione **Probar la conexión** para verificar que AWS SCT pueda conectarse a su base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de conversión de Azure Synapse Analytics a Amazon Redshift
Para editar la configuración de conversión de Azure Synapse Analytics a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, ****elija**** Configuración de conversión. En la lista superior, elija **Azure Synapse** y, a continuación, **Azure Synapse — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Azure Synapse Analytics a Amazon Redshift.
La configuración AWS SCT de conversión de Azure Synapse Analytics 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**.
## Configuración de optimización de la conversión de Azure Synapse Analytics a Amazon Redshift
Para editar la configuración de optimización de conversiones de Azure Synapse Analytics en Amazon Redshift, **seleccione** Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión. En la lista superior, elija **Azure Synapse** y, a continuación, **Azure Synapse — 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 Azure Synapse Analytics a Amazon Redshift.
La configuración AWS SCT de optimización de conversión de Azure Synapse Analytics 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.
# Conectarse a Google BigQuery con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones BigQuery a Amazon Redshift.
## Privilegios BigQuery como fuente
Para utilizar un almacén de BigQuery datos como fuente en AWS SCT, cree una cuenta de servicio. En Google Cloud, las aplicaciones usan cuentas de servicio para realizar llamadas a la API autorizadas. Las cuentas de servicio son diferentes de las cuentas de usuario. Para obtener más información, consulte [Cuentas de servicio](https://cloud.google.com/iam/docs/service-accounts) en la documentación sobre Google Cloud Identity and Access Management.
Asegúrese de asignar las siguientes funciones a su cuenta de servicio:
+ `BigQuery Admin`
+ `Storage Admin`
El `BigQuery Admin` rol proporciona permisos para administrar todos los recursos del proyecto. AWS SCT utiliza este rol para cargar BigQuery los metadatos en el proyecto de migración.
El rol `Storage Admin` otorga el control total de los objetos y buckets de datos. Puede encontrar este rol en`Cloud Storage`. AWS SCT utiliza esta función para extraer los datos de Amazon Redshift BigQuery y, a continuación, cargarlos en ellos.
**Para crear un archivo de clave de cuenta de servicio**
1. Inicie sesión en la consola de administración de Google Cloud en [https://console.cloud.google.com/](https://console.cloud.google.com/).
1. En la página [BigQuery de la API](https://console.cloud.google.com/apis/library/bigquery.googleapis.com), selecciona **Activar**. Omita este paso si ve **API habilitada**.
1. En la página [Cuentas de servicio](https://console.cloud.google.com/iam-admin/serviceaccounts), seleccione su proyecto y, a continuación, seleccione **Crear cuenta de servicio**.
1. En la página **Detalles de la cuenta de servicio**, introduzca un valor descriptivo para **Nombre de la cuenta de servicio**. Seleccione **Crear y continuar**. Se abre la página **Otorgar a esta cuenta de servicio acceso al proyecto**.
1. En **Seleccione un rol**, elija y **BigQuery**, a continuación, elija **BigQuery Administrador**.
1. Elija **Agregar otro rol**. En **Seleccionar un rol**, seleccione **Cloud Storage** y, a continuación, seleccione **Administrador de almacenamiento**.
1. Elija ** Continuar** y, a continuación, elija **Guardar**.
1. En la página [Cuentas de servicio](https://console.cloud.google.com/iam-admin/serviceaccounts), elija la cuenta de servicio que creó.
1. Seleccione **Claves** y, a continuación, seleccione **Crear clave nueva** para **Agregar clave**.
1. Elija **JSON** y, a continuación, elija **Crear**. Elija la carpeta para guardar su clave privada o seleccione la carpeta predeterminada para las descargas en su navegador.
Para extraer datos de un almacén de BigQuery datos, AWS SCT usa la carpeta bucket de Google Cloud Storage. Cree este bucket antes de iniciar la migración de datos. Introduzca la ruta a la carpeta del bucket de Google Cloud Storage en el cuadro de diálogo **Crear tarea local**. Para obtener más información, consulte [Crear, ejecutar y supervisar una AWS SCT tarea](agents.md#agents.Tasks).
## Conectarse a BigQuery como fuente
Utilice el siguiente procedimiento para conectarse al BigQuery proyecto de origen con el AWS Schema Conversion Tool.
**Para conectarse a un almacén BigQuery de datos de origen**
1. En AWS Schema Conversion Tool, elija **Agregar fuente**.
1. Elige **BigQuery**y, a continuación, selecciona **Siguiente**.
Se abrirá el cuadro de diálogo **Agregar origen**.
1. En **Nombre de conexión**, introduce un nombre para tu BigQuery proyecto. AWS SCT muestra este nombre en el árbol del panel izquierdo.
1. En **Ruta de la clave**, introduzca la ruta al archivo de la clave de la cuenta de servicio. Para obtener más información sobre la creación de este archivo, consulte [Privilegios BigQuery como fuente](#CHAP_Source.BigQuery.Permissions).
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a su BigQuery proyecto de origen.
1. Selecciona **Connect** para conectarte a tu BigQuery proyecto de origen.
## Limitaciones de uso BigQuery como fuente para AWS SCT
Se aplican las siguientes limitaciones cuando se utiliza BigQuery como fuente para AWS SCT:
+ AWS SCT no admite la conversión de subconsultas en funciones analíticas.
+ No se puede usar AWS SCT para convertir sentencias BigQuery `SELECT AS STRUCT`. `SELECT AS VALUE`
+ AWS SCT no admite la conversión de los siguientes tipos de funciones:
+ Approximate aggregate
+ Bit
+ Debugging
+ Federated query
+ Geography
+ Hash
+ Mathematical
+ Net
+ Statistical aggregate
+ UUID
+ AWS SCT proporciona un soporte limitado para la conversión de funciones de cadena.
+ AWS SCT no admite la conversión de `UNNEST` operadores.
+ No puede convertir operaciones de unión correlacionadas en AWS SCT.
+ AWS SCT no admite la conversión de `OFFSET` cláusulas `QUALIFY` `WINDOW``LIMIT`,, y.
+ No se puede utilizar AWS SCT para convertir expresiones de tabla comunes recursivas.
+ AWS SCT no admite la conversión de `INSERT` sentencias con subconsultas dentro `VALUES` de cláusulas.
+ AWS SCT no admite la conversión de `UPDATE` sentencias para campos anidados y registros repetidos.
+ No se puede utilizar AWS SCT para convertir ningún tipo `STRUCT` de `ARRAY` datos.
## BigQuery a la configuración de conversión de Amazon Redshift
Para editar BigQuery la configuración de conversión a Amazon Redshift, seleccione **Configuración** en y, a continuación AWS SCT, elija Configuración de **conversión**. En la lista superior, selecciona **Google** y BigQuery, a continuación, **Google BigQuery — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para BigQuery la conversión a Amazon Redshift.
BigQuery a la configuración de conversión de Amazon Redshift AWS SCT 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.
+ 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**.
## BigQuery a la configuración de optimización de conversiones de Amazon Redshift
BigQuery Para editar la configuración de optimización de conversiones de Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, selecciona **Google** y BigQuery, a continuación, **Google BigQuery — Amazon Redshift**. En el panel izquierdo, selecciona **Estrategias de optimización**. AWS SCT muestra la configuración de optimización de conversiones BigQuery para la conversión a Amazon Redshift.
BigQuery a la configuración de optimización de conversiones de Amazon Redshift, AWS SCT 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.
# Conectando la base de datos Greenplum con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Greenplum Database a Amazon Redshift.
## Privilegios para la base de datos de Greenplum como origen
Los privilegios necesarios para la base de datos de Greenplum como origen se enumeran a continuación:
+ CONÉCTESE A LA BASE **
+ USO EN EL ESQUEMA **
+ SELECCIONE UNA *.*
+ SELECCIONE UNA SECUENCIA *.*
En el ejemplo anterior, sustituya los marcadores de posición del modo que sigue:
+ Sustituya *database\$1name* por el nombre de la base de datos de origen.
+ Sustituya *schema\$1name* por el nombre del esquema de origen.
+ *table\$1name*Sustitúyalo por el nombre de la tabla de origen.
+ *sequence\$1name*Sustitúyalo por el nombre de la secuencia.
## Conexión a la base de datos de Greenplum como origen
Utilice el siguiente procedimiento para conectarse a su base de datos fuente de Greenplum con AWS SCT.
**Para conectarse a una base de datos Greenplum de origen**
1. En AWS Schema Conversion Tool, elija **Agregar fuente**.
1. Elija **SAP ASE**, 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 las credenciales de la base de datos de origen de Greenplum, use las siguientes instrucciones:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Greenplum.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de conversión de Greenplum a Amazon Redshift
Para editar la configuración de conversión de Greenplum a Amazon Redshift, **seleccione** Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión. En la lista superior, elija **Greenplum** y, a continuación, **Greenplum — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Greenplum a Amazon Redshift.
La configuración AWS SCT de conversión de Greenplum 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**.
## Configuración de optimización de la conversión de Greenplum a Amazon Redshift
Para editar la configuración de optimización de conversiones de Greenplum a Amazon Redshift, **seleccione** Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión. En la lista superior, elija **Greenplum** y, a continuación, **Greenplum — 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 Greenplum a Amazon Redshift.
La configuración AWS SCT de optimización de conversiones de Greenplum 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.
# Conectarse a Netezza con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Netezza a Amazon Redshift.
## Privilegios para Netezza como origen
Los privilegios necesarios para Netezza como origen se enumeran a continuación:
+ select on system.definition\$1schema.system view
+ select on system.definition\$1schema.system table
+ select on system.definition\$1schema.management table
+ lista en **
+ lista en **
+ lista en ** .all.table
+ lista en la tabla .all.external **
+ lista en .all.view **
+ lista en la vista materializada de .all. **
+ lista en ** .all.procedure
+ lista en .all.sequence **
+ lista en .all.function **
+ lista en .all.aggregate **
En el ejemplo anterior, sustituya los marcadores de posición del modo que sigue:
+ Sustituya *database\$1name* por el nombre de la base de datos de origen.
+ Sustituya *schema\$1name* por el nombre del esquema de origen.
AWS SCT requiere acceso a las siguientes tablas y vistas del sistema. Puede conceder el acceso a estos objetos en lugar de conceder el acceso a `system.definition_schema.system view` y `system.definition_schema.system tables` en la lista anterior.
+ select on system.definition\$1schema.\$1t\$1aggregate
+ select on system.definition\$1schema.\$1t\$1class
+ select on system.definition\$1schema.\$1t\$1constraint
+ select on system.definition\$1schema.\$1t\$1const\$1relattr
+ select on system.definition\$1schema.\$1t\$1database
+ select on system.definition\$1schema.\$1t\$1grpobj\$1priv
+ select on system.definition\$1schema.\$1t\$1grpusr
+ select on system.definition\$1schema.\$1t\$1hist\$1config
+ select on system.definition\$1schema.\$1t\$1object
+ select on system.definition\$1schema.\$1t\$1object\$1classes
+ select on system.definition\$1schema.\$1t\$1proc
+ select on system.definition\$1schema.\$1t\$1type
+ select on system.definition\$1schema.\$1t\$1user
+ select on system.definition\$1schema.\$1t\$1usrobj\$1priv
+ select on system.definition\$1schema.\$1vt\$1sequence
+ select on system.definition\$1schema.\$1v\$1aggregate
+ select on system.definition\$1schema.\$1v\$1constraint\$1depends
+ select on system.definition\$1schema.\$1v\$1database
+ select on system.definition\$1schema.\$1v\$1datatype
+ select on system.definition\$1schema.\$1v\$1dslice
+ select on system.definition\$1schema.\$1v\$1function
+ select on system.definition\$1schema.\$1v\$1group
+ select on system.definition\$1schema.\$1v\$1obj\$1relation
+ select on system.definition\$1schema.\$1v\$1obj\$1relation\$1xdb
+ select on system.definition\$1schema.\$1v\$1procedure
+ select on system.definition\$1schema.\$1v\$1relation\$1column
+ select on system.definition\$1schema.\$1v\$1relation\$1keydata
+ select on system.definition\$1schema.\$1v\$1relobjclasses
+ select on system.definition\$1schema.\$1v\$1schema\$1xdb
+ select on system.definition\$1schema.\$1v\$1sequence
+ select on system.definition\$1schema.\$1v\$1synonym
+ select on system.definition\$1schema.\$1v\$1system\$1info
+ select on system.definition\$1schema.\$1v\$1sys\$1constraint
+ select on system.definition\$1schema.\$1v\$1sys\$1object\$1dslice\$1info
+ select on system.definition\$1schema.\$1v\$1sys\$1user
+ select on system.definition\$1schema.\$1v\$1table
+ select on system.definition\$1schema.\$1v\$1sys\$1constraint
+ select on system.definition\$1schema.\$1v\$1table
+ select on system.definition\$1schema.\$1v\$1table
+ select on system.definition\$1schema.\$1v\$1table
+ select on system.definition\$1schema.\$1v\$1user
+ select on system.definition\$1schema.\$1v\$1user
+ select on system.information\$1schema.\$1v\$1relation\$1column
+ select on system.information\$1schema.\$1v\$1table
+ select on \$1hist\$1column\$1access\$1\$1
## Conexión a Netezza como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Netezza con AWS Schema Conversion Tool.
**Para conectarse a una base de datos Netezza de origen**
1. En el AWS Schema Conversion Tool, selecciona **Añadir** fuente.
1. Seleccione **Netezza y**, a continuación, seleccione **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 de origen de Netezza, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Netezza.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configurar la replicación continua de datos
Tras convertir los esquemas de base de datos de Netezza y aplicarlos a la base de datos de Amazon Redshift, puede migrar los datos con agentes de extracción de datos. AWS SCT El agente extrae los datos y los carga en el bucket de Amazon S3. A continuación, puede utilizar AWS SCT para copiar los datos de Amazon S3 a Amazon Redshift.
Si los datos de la base de datos de origen cambian durante el proceso de migración, puede capturar los cambios en curso con sus agentes de extracción de AWS SCT datos. Seguidamente, puede replicar estos cambios continuos en la base de datos de destino después de completar la migración de datos inicial. Este proceso se denomina replicación continua o *captura de datos de cambio* (CDC).
**Para configurar la replicación continua de datos para migraciones de Netezza a Amazon Redshift**
1. En la base de datos de origen, cree una base de datos de historial. Puede utilizar el siguiente ejemplo de código en la interfaz de la línea de comandos (CLI) de Netezza.
```
nzhistcreatedb -d history_database_name -t query -v 1 -u load_user -o histdb_owner -p your_password
```
En el ejemplo anterior, *history\$1database\$1name* sustitúyalo por el nombre de la base de datos de historial. A continuación, *load\$1user* sustitúyalo por el nombre del usuario que has definido para cargar los datos del historial en la base de datos. A continuación, *histdb\$1owner* sustitúyalo por el nombre del usuario que haya definido como propietario de la base de datos del historial. Asegúrese de haber creado este usuario y de haberle concedido el permiso `CREATE DATABASE`. Por último, *your\$1password* sustitúyala por una contraseña segura.
1. Configure el registro del historial. Para ello, use el siguiente ejemplo de código.
```
CREATE HISTORY CONFIGURATION history_configuration_name HISTTYPE QUERY
DATABASE history_database_name USER load_user PASSWORD your_password COLLECT PLAN, COLUMN
LOADINTERVAL 1 LOADMINTHRESHOLD 0 LOADMAXTHRESHOLD 0 STORAGELIMIT 25
LOADRETRY 2 VERSION 1;
```
En el ejemplo anterior, sustituya *history\$1configuration\$1name* y por *history\$1database\$1name* los nombres de la configuración del historial y de la base de datos del historial. A continuación, *load\$1user* sustitúyalo por el nombre del usuario que has definido para cargar los datos del historial en la base de datos. A continuación, *your\$1password* sustitúyala por una contraseña segura.
1. Otorgar permisos de lectura para todas las tablas de la base de datos del historial. Puede utilizar el siguiente código de ejemplo para conceder el permiso `SELECT`.
```
GRANT SELECT ON history_database_name.ALL.TABLE TO your_user;
```
En el ejemplo anterior, *history\$1database\$1name* sustitúyalo por el nombre de la base de datos de historial. A continuación, *your\$1user* sustitúyalo por el nombre del usuario con permisos mínimos para trabajar con la base de datos de Netezza. Utiliza las credenciales de este usuario de base de datos en. AWS SCT
1. Recopile las estadísticas de cada tabla del esquema de origen para obtener información sobre la cardinalidad de las columnas. Puede utilizar el siguiente comando para generar estadísticas en la base de datos de historial.
```
GENERATE STATISTICS on "schema_name"."table_name";
```
En el ejemplo anterior, sustituya *schema\$1name* y *table\$1name* por el nombre del esquema y la tabla de la base de datos.
1. Asegúrese de que ha completado los requisitos. Para ello, ejecute la siguiente consulta:
```
SELECT COUNT(*) FROM history_database_name.history_schema_name."$hist_column_access_N";
```
En el ejemplo anterior, sustituya *history\$1database\$1name* y *history\$1schema\$1name* por el nombre de la base de datos y el esquema del historial. A continuación, *N* sustitúyalo por el número de versión de la base de datos de historial. Para obtener más información sobre las versiones de la base de dato del historial, consulte [Documentación de IBM Netezza](https://www.ibm.com/docs/en/netezza?topic=history-database-versions).
1. Instale el agente de extracción de datos. Para obtener más información, consulte [Instalación de agentes de extracción](agents.md#agents.Installing).
Asegúrese de que el parámetro `{working.folder}` del archivo `settings.properties` de todas las instancias del extractor apunte a la misma carpeta. En este caso, sus extractores pueden coordinar la sesión de CDC y utilizar un único punto de transacción para todas las tareas secundarias.
1. Registre su agente de extracción de datos. Para obtener más información, consulte [Registrar los agentes de extracción con el AWS Schema Conversion Tool](agents.md#agents.Using).
1. Cree su tarea de CDC. Para obtener más información, consulte [Crear, ejecutar y supervisar una AWS SCT tarea](agents.md#agents.Tasks).
1. Abra su proyecto en AWS SCT. En el panel izquierdo, elija la tabla de origen. Abra el menú contextual (clic secundario) y seleccione **Crear tarea local**.
1. En **Nombre de la tarea**, introduzca un nombre para la tarea de migración de datos.
1. En **Modo de migración**, seleccione **Extraer, cargar y copiar**.
1. Seleccione **Habilitar CDC**.
1. Elija la pestaña **Configuración de CDC** y defina el ámbito y la programación de las sesiones de CDC.
1. Seleccione **Probar tarea** para comprobar que se puede conectar a su carpeta de trabajo, bucket de Amazon S3 y almacenamiento de datos de Amazon Redshift.
1. Seleccione **Crear** para crear su tarea.
1. Elija la pestaña **Tareas**, seleccione su tarea de la lista y elija **Iniciar**.
1. La AWS SCT tarea mantiene la coherencia transaccional en la base de datos de destino. El agente de extracción de datos replica las transacciones del origen en el orden de los identificadores de transacción.
Si detiene alguna de las sesiones de migración o si se produce un error, el procesamiento de la CDC también se detiene.
## Configuración de conversión de Netezza a Amazon Redshift
**Para editar la configuración de conversión de Netezza a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Netezza** y, a continuación, **Netezza — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Netezza a Amazon Redshift.
La configuración AWS SCT de conversión de Netezza 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.
+ 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**.
## Configuración de optimización de la conversión de Netezza a Amazon Redshift
**Para editar la configuración de optimización de conversiones de Netezza a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Netezza** y, a continuación, **Netezza — 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 Netezza a Amazon Redshift.
La configuración AWS SCT de optimización de conversiones de Netezza 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.
# Conectando Oracle Data Warehouse con AWS SCT
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Oracle Data Warehouse a Amazon Redshift o Amazon Redshift y usarlos en combinación AWS Glue .
## Privilegios para Oracle Data Warehouse como origen
Los privilegios necesarios para Oracle Data Warehouse como origen se enumeran a continuación:
+ connect
+ select\$1catalog\$1role
+ select any dictionary
## Conexión a Oracle Data Warehouse como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de Oracle Data Warehouse de origen con AWS Schema Conversion Tool.
**Para conectarse a una base de datos de Oracle Data Warehouse de origen**
1. **En AWS Schema Conversion Tool, elija Agregar fuente.**
1. Elija **Oracle** 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 al almacenamiento de datos de origen de Oracle, siga las siguientes instrucciones:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.OracleDW.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de conversión de Oracle Data Warehouse a Amazon Redshift
Para editar la configuración de conversión de Oracle Data Warehouse a Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, elija **Oracle** y, a continuación, **Oracle — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Oracle Data Warehouse a Amazon Redshift.
La configuración de conversión de Oracle Data Warehouse a Amazon Redshift AWS SCT 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**, seleccione 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`.
+ Convertir funciones de formato de tipos de datos como `TO_CHAR`, `TO_DATE` y `TO_NUMBER` con elementos de formato de fecha y hora que Amazon Redshift no admite. De forma predeterminada, AWS SCT utiliza las funciones del paquete de extensión para simular el uso de estos elementos de formato no compatibles en el código convertido.
El modelo de formato de fecha y hora de Oracle incluye más elementos en comparación con las cadenas de formato de fecha y hora de Amazon Redshift. Si su código fuente incluye únicamente elementos de formato de fecha y hora compatibles con Amazon Redshift, no necesitará las funciones del paquete de extensión incluidas en el código convertido. Para evitar utilizar las funciones del paquete de extensión en el código convertido, seleccione **Los elementos de formato Datetype que utiliza en el código de Oracle son similares a las cadenas de formato de fecha y hora de Amazon Redshift**. En este caso, el código convertido funciona más rápido.
El modelo de formato numérico de Oracle incluye más elementos en comparación con las cadenas de formato numérico de Amazon Redshift. Si su código fuente incluye únicamente elementos de formato numérico compatibles con Amazon Redshift, no necesitará las funciones del paquete de extensión incluidas en el código convertido. Para evitar utilizar las funciones del paquete de extensión en el código convertido, seleccione **Los elementos de formato numérico que utiliza en el código de Oracle son similares a las cadenas de formato numérico de Amazon Redshift**. En este caso, el código convertido funciona más rápido.
+ Convertir funciones analíticas `LEAD` y `LAG` de Oracle. De forma predeterminada, AWS SCT genera un elemento de acción para cada función `LEAD` y `LAG`.
Si su código fuente no utiliza los valores predeterminados de compensación en estas funciones, AWS SCT puede simular el uso de estas funciones con la función `NVL`. Para ello, seleccione **Utilizar la función NVL para simular el comportamiento de las funciones LEAD y LAG de Oracle**.
+ 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 utilizas estas restricciones en tu código, asegúrate de AWS SCT emular su comportamiento en el código convertido.
+ 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**.
## Configuración de optimización de la conversión de Oracle Data Warehouse a Amazon Redshift
Para editar la configuración de optimización de conversiones de Oracle Data Warehouse a Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, elija **Oracle** y, a continuación, **Oracle — 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 Oracle Data Warehouse a Amazon Redshift.
La configuración de optimización de conversión de Oracle Data Warehouse a Amazon Redshift AWS SCT 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.
# Conexión a un almacén de datos de Snowflake con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Snowflake a Amazon Redshift.
## Privilegios para Snowflake como base de datos de origen
Puede crear un rol con privilegios y asignar a este rol el nombre de un usuario utilizando el rol `SECURITYADMIN` y el contexto de la sesión de `SECURITYADMIN`.
El siguiente ejemplo crea privilegios mínimos y se los concede al usuario `min_privs`.
```
create role role_name;
grant role role_name to role sysadmin;
grant usage on database db_name to role role_name;
grant usage on schema db_name.schema_name to role role_name;
grant usage on warehouse datawarehouse_name to role role_name;
grant monitor on database db_name to role role_name;
grant monitor on warehouse datawarehouse_name to role role_name;
grant select on all tables in schema db_name.schema_name to role role_name;
grant select on future tables in schema db_name.schema_name to role role_name;
grant select on all views in schema db_name.schema_name to role role_name;
grant select on future views in schema db_name.schema_name to role role_name;
grant select on all external tables in schema db_name.schema_name to role role_name;
grant select on future external tables in schema db_name.schema_name to role role_name;
grant usage on all sequences in schema db_name.schema_name to role role_name;
grant usage on future sequences in schema db_name.schema_name to role role_name;
grant usage on all functions in schema db_name.schema_name to role role_name;
grant usage on future functions in schema db_name.schema_name to role role_name;
grant usage on all procedures in schema db_name.schema_name to role role_name;
grant usage on future procedures in schema db_name.schema_name to role role_name;
create user min_privs password='real_user_password'
DEFAULT_ROLE = role_name DEFAULT_WAREHOUSE = 'datawarehouse_name';
grant role role_name to user min_privs;
```
En el ejemplo anterior, sustituya los marcadores de posición del modo que sigue:
+ Sustituya *`role_name`* por el nombre de un rol con privilegios de solo lectura.
+ Sustituya `db_name` por el nombre de la base de datos de origen.
+ Sustituya `schema_name` por el nombre del esquema de origen.
+ Sustituya *`datawarehousename`* por el nombre de un almacenamiento de datos necesario.
+ Sustituya `min_privs` por el nombre de un usuario que tenga privilegios mínimos.
Los parámetros `DEFAULT_ROLE` y `DEFAULT_WAREHOUSE` son sensibles a las claves.
## Configurar el acceso seguro a Amazon S3
Las políticas de seguridad y administración de acceso de un bucket de Amazon S3 permiten a Snowflake acceder, leer y escribir datos en el bucket de S3. Puede configurar el acceso seguro a un bucket privado de Amazon S3 mediante el tipo de objeto `STORAGE INTEGRATION` de Snowflake. Un objeto de integración de almacenamiento de Snowflake delega la responsabilidad de autenticación en una entidad de administración de identidades y accesos de Snowflake.
Para obtener más información, consulte [Configurar una integración de almacenamiento de Snowflake para acceder a Amazon S3](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html) en la documentación de Snowflake.
## Conexión a Snowflake como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen con AWS Schema Conversion Tool.
**Para conectarse a una base de datos de origen de Snowflake**
1. **En, elija Agregar AWS Schema Conversion Tool fuente.**
1. Seleccione **Snowflake** y, a continuación, seleccione **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 del almacenamiento de datos de origen de Snowflake, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Snowflake.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Limitaciones de Snowflake como origen
Las siguientes son limitaciones a la hora de utilizar Snowflake como fuente para: AWS SCT
+ Los identificadores de objeto deben ser únicos en el contexto del tipo de objeto y del objeto principal:
**Base de datos**
Los identificadores de esquema deben ser únicos dentro de una base de datos.
**Esquemas**
Los identificadores de objetos, como los de tablas y vistas, deben ser únicos dentro de un esquema.
**Tablas/Vistas**
Los identificadores de columna deben ser únicos dentro de una tabla.
+ El número máximo de tablas para los tipos de nodos de clúster large y xlarge es de 9 900. El número máximo de tablas para los tipos de nodos de clúster 8xlarge es 100 000. El límite incluye tablas temporales, tanto las definidas por el usuario como las creadas con Amazon Redshift durante el procesamiento de las consultas o el mantenimiento del sistema. Para obtener más información, consulte [Cuotas de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) en la *Guía de administración de clústeres de Amazon Redshift*.
+ Para los procedimientos almacenados, el número máximo de argumentos de entrada y salida es 32.
## Tipos de datos de origen para Snowflake
A continuación, encontrará los tipos de datos de origen de Snowflake que se admiten cuando se utilizan AWS SCT y el mapeo predeterminado a un destino de Amazon Redshift.
| Tipos de datos de Snowflake | Tipos de datos de Amazon Redshift |
| --- | --- |
| NUMBER | NUMERIC(38) |
| NUMBER(p) | Si p es =< 4, entonces SMALLINT Si p es => 5 y =< 9, entonces INTEGER Si p es => 10 y =< 18, entonces BIGINT Si p es => 19 entonces NUMERIC (p) |
| NUMBER(p, 0) | Si p es =< 4, entonces SMALLINT Si p es => 5 y =< 9, entonces INTEGER Si p es => 10 y =< 18, entonces BIGINT Si p es => 19 entonces NUMERIC (p,0) |
| NUMBER(p, s) | Si p es => 1 y =< 38, y si s es => 1 y =< 37, entonces NUMERIC(p,s) |
| FLOAT | FLOAT |
| TEXT Caracteres Unicode de hasta 16 777 216 bytes; hasta 4 bytes por carácter. | VARCHAR(MAX) |
| TEXT(p) Caracteres Unicode de hasta 65 535 bytes; hasta 4 bytes por carácter. | Si p es =< 65 535, entonces, VARCHAR (p) |
| TEXT(p) Caracteres Unicode de hasta 16 777 216 bytes; hasta 4 bytes por carácter. | Si p es => 65 535 y =< 16 777 216, entonces, VARCHAR (MAX) |
| BINARIO Caracteres de un solo byte de hasta 8 388 608 bytes; 1 byte por carácter. | VARCHAR(MAX) |
| BINARY(p) Caracteres de un solo byte de hasta 65 535 bytes; 1 byte por carácter. | VARCHAR(p) |
| BINARY(p) Caracteres de un solo byte de hasta 8 388 608 bytes; 1 byte por carácter. | VARCHAR(MAX) |
| BOOLEAN | BOOLEAN |
| DATE | DATE |
| TIME Valores de hora entre 00:00:00 y 23:59:59,999999999. | VARCHAR(18) |
| TIME(f) Valores de hora entre 00:00:00 y 23:59:59,9(f). | VARCHAR(n) – 9 \$1 dt-attr-1 |
| TIMESTAMP\$1NTZ | TIMESTAMP |
| TIMESTAMP\$1TZ | TIMESTAMPTZ |
## Configuración de conversión de Snowflake a Amazon Redshift
**Para editar la configuración de conversión de Snowflake a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Snowflake** y, a continuación, **Snowflake — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Snowflake a Amazon Redshift.
La configuración AWS SCT de conversión de Snowflake 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.
+ 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**.
## Configuración de optimización de la conversión de Snowflake a Amazon Redshift
**Para editar la configuración de optimización de conversiones de Snowflake a Amazon Redshift, seleccione Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión.** En la lista superior, elija **Snowflake** y, a continuación, **Snowflake — 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 Snowflake a Amazon Redshift.
La configuración AWS SCT de optimización de conversiones de Snowflake 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.
# Conexión a un almacén de datos de SQL Server con AWS Schema Conversion Tool
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Microsoft SQL Server DW a Amazon Redshift o Amazon Redshift y usarlos en combinación AWS Glue .
## Privilegios para Microsoft SQL Server Data Warehouse como origen
Los privilegios necesarios para Microsoft SQL Server Data Warehouse como origen se enumeran a continuación:
+ VIEW DEFINITION
+ VIEW DATABASE STATE
+ SELECCIONE UN ESQUEMA: **
En el ejemplo anterior, sustituya el ** marcador de posición por el nombre de la fuente source\$1schema.
Repita la concesión para cada base de datos cuyo esquema vaya a convertir.
Además, conceda el siguiente privilegio, y ejecute la concesión en la base de datos maestra:
+ VIEW SERVER STATE
## Limitaciones en el uso de SQL Server Data Warehouse como origen
Actualmente no se admite el uso de Microsoft SQL Server Parallel Data Warehouse (PDW) como origen.
## Conexión a SQL Server Data Warehouse como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de SQL Server Data Warehouse con AWS Schema Conversion Tool.
**Para conectarse a una base de datos de origen de Microsoft SQL Server Data Warehouse**
1. **En AWS Schema Conversion Tool, selecciona Añadir fuente.**
1. Elija **Microsoft SQL Server** 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 al almacenamiento de datos de origen de Microsoft SQL Server, siga las instrucciones siguientes:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServerDW.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de conversión de SQL Server Data Warehouse a Amazon Redshift
Para editar la configuración de conversión de SQL Server Data Warehouse a Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, elija **Microsoft SQL Server** y, a continuación, **Microsoft SQL Server — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de SQL Server Data Warehouse a Amazon Redshift.
La configuración de conversión de SQL Server Data Warehouse a Amazon Redshift AWS SCT 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**.
## Configuración de optimización de la conversión de SQL Server Data Warehouse a Amazon Redshift
Para editar la configuración de optimización de conversiones de SQL Server Data Warehouse a Amazon Redshift, seleccione **Configuración** en y AWS SCT, a continuación, elija Configuración de **conversión**. En la lista superior, elija **Microsoft SQL Server** y, a continuación, **Microsoft SQL Server — 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 SQL Server Data Warehouse a Amazon Redshift.
La configuración de optimización de conversión de SQL Server Data Warehouse a Amazon Redshift AWS SCT 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.
# 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.
# Conectándolas AWS Schema Conversion Tool a las bases de datos de Vertica
Puede utilizarlos AWS SCT para convertir esquemas, objetos de código y código de aplicaciones de Vertica a Amazon Redshift.
## Privilegios para Vertica como origen
Los privilegios necesarios para Vertica como origen se enumeran a continuación:
+ USO EN SCHEMA **
+ USAGE ON SCHEMA PUBLIC
+ SELECCIONE EN TODAS LAS TABLAS DEL ESQUEMA **
+ SELECCIONE TODAS LAS SECUENCIAS DEL ESQUEMA **
+ SE EJECUTA EN TODAS LAS FUNCIONES DEL ESQUEMA **
+ EJECUTE SEGÚN EL PROCEDIMIENTO **
En el ejemplo anterior, sustituya los marcadores de posición del modo que sigue:
+ Sustituya *schema\$1name* por el nombre del esquema de origen.
+ *procedure\$1name*Sustitúyalo por el nombre de un procedimiento de origen. Repita la concesión para cada procedimiento que vaya a convertir.
+ *procedure\$1signature*Sustitúyalo por la lista de tipos de argumentos de procedimiento delimitados por comas.
## Conexión a Vertica como origen
Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Vertica con AWS Schema Conversion Tool.
**Para conectarse a su base de datos Vertica de origen**
1. En el AWS Schema Conversion Tool, elige **Agregar fuente**.
1. Seleccione **Vertica** y, a continuación, seleccione **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 Vertica, siga las instrucciones siguientes:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/SchemaConversionTool/latest/userguide/CHAP_Source.Vertica.html)
1. Elija **Probar conexión** para comprobar que AWS SCT puede conectarse a la base de datos de origen.
1. Seleccione **Conectar** para conectarse a su base de datos de origen.
## Configuración de conversión de Vertica a Amazon Redshift
Para editar la configuración de conversión de Vertica a Amazon Redshift, **seleccione** Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión. En la lista superior, elija **Vertica** y, a continuación, **Vertica — Amazon Redshift**. AWS SCT muestra todos los ajustes disponibles para la conversión de Vertica a Amazon Redshift.
La configuración AWS SCT de conversión de Vertica 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**.
## Configuración de optimización de la conversión de Vertica a Amazon Redshift
Para editar la configuración de optimización de conversiones de Vertica a Amazon Redshift, **seleccione** Configuración AWS SCT en y, a continuación, **elija** Configuración de conversión. En la lista superior, elija **Vertica** y, a continuación, **Vertica — 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 Vertica a Amazon Redshift.
La configuración AWS SCT de optimización de conversiones de Vertica 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.