Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# 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.