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.
# 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'
);
```