Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Connect Microsoft SQL Server avec AWS Schema Conversion Tool
Vous pouvez l'utiliser AWS SCT pour convertir des schémas, des objets de code de base de données et du code d'application de SQL Server vers les cibles suivantes :
+ Amazon RDS for MySQL
+ Amazon Aurora MySQL-Compatible Edition
+ Amazon RDS pour PostgreSQL
+ Amazon Aurora PostgreSQL-Compatible Edition
+ Amazon RDS for SQL Server
+ Amazon RDS for MariaDB
**Note**
AWS SCT ne prend pas en charge l'utilisation d'Amazon RDS pour SQL Server en tant que source.
Vous pouvez l'utiliser AWS SCT pour créer un rapport d'évaluation pour la migration de schémas, d'objets de code de base de données et de code d'application de SQL Server vers Babelfish pour Aurora PostgreSQL, comme décrit ci-dessous.
**Topics**
+ [
## Privilèges pour Microsoft SQL Server en tant que source
](#CHAP_Source.SQLServer.Permissions)
+ [
## Utilisation de l'authentification Windows lors de l'utilisation de Microsoft SQL Server comme source
](#CHAP_Source.SQLServer.Permissions.WinAuth)
+ [
## Connexion à SQL Server en tant que source
](#CHAP_Source.SQLServer.Connecting)
+ [
# Conversion de SQL Server en MySQL
](CHAP_Source.SQLServer.ToMySQL.md)
+ [
# Migration de SQL Server vers PostgreSQL avec AWS Schema Conversion Tool
](CHAP_Source.SQLServer.ToPostgreSQL.md)
+ [
# Migration de SQL Server vers Amazon RDS for SQL Server avec AWS Schema Conversion Tool
](CHAP_Source.SQLServer.ToRDSSQLServer.md)
## Privilèges pour Microsoft SQL Server en tant que source
Les privilèges requis pour Microsoft SQL Server en tant que source sont les suivants :
+ VIEW DEFINITION
+ VIEW DATABASE STATE
Ce `VIEW DEFINITION` privilège permet aux utilisateurs disposant d'un accès public de consulter les définitions des objets. AWS SCT utilise le `VIEW DATABASE STATE` privilège pour vérifier les fonctionnalités de l'édition Enterprise de SQL Server.
Répétez l'octroi pour chaque base de données dont vous convertissez le schéma.
En outre, accordez les privilèges suivants sur la base de données `master` :
+ VIEW SERVER STATE
+ VIEW ANY DEFINITION
AWS SCT utilise le `VIEW SERVER STATE` privilège pour collecter les paramètres et la configuration du serveur. Assurez-vous d'accorder le `VIEW ANY DEFINITION` privilège d'afficher les points de terminaison.
Pour lire des informations sur Microsoft Analysis Services, exécutez la commande suivante sur la base de données `master`.
```
EXEC master..sp_addsrvrolemember @loginame = N'', @rolename = N'sysadmin'
```
Dans l'exemple précédent, remplacez l'``espace réservé par le nom de l'utilisateur auquel vous avez accordé les privilèges précédents.
Pour lire des informations sur l'agent SQL Server, ajoutez votre utilisateur au `SQLAgentUser` rôle. Exécutez la commande suivante sur la base de données `msdb`.
```
EXEC sp_addrolemember , ;
```
Dans l’exemple précédent, remplacez l’espace réservé `` par le nom du rôle SQL Server Agent. Remplacez ensuite l'``espace réservé par le nom de l'utilisateur auquel vous avez accordé les privilèges précédents. Pour plus d'informations, consultez la section [Ajouter un utilisateur au rôle SQLAgent d'utilisateur](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.Agent.html#SQLServerAgent.AddUser) dans le *guide de l'utilisateur Amazon RDS*.
Pour détecter l’expédition de journaux, accordez le privilège `SELECT on dbo.log_shipping_primary_databases` sur la base de données `msdb`.
Pour utiliser l'approche de notification de la réplication DDL, accordez le `RECEIVE ON .` privilège sur vos bases de données sources. Dans cet exemple, remplacez l’espace réservé `` par le nom du schéma de la base de données. Remplacez ensuite l’espace réservé `` par le nom d’une table de file d’attente.
## Utilisation de l'authentification Windows lors de l'utilisation de Microsoft SQL Server comme source
Si votre application s'exécute sur un intranet Windows, vous pouvez utiliser l'authentification Windows pour accéder à la base de données. L'authentification Windows utilise l'identité Windows actuelle établie sur le thread du système d'exploitation pour accéder à la base de données SQL Server. Vous pouvez ensuite faire correspondre l'identité Windows à une base de données et à des permissions SQL Server. Pour vous connecter à SQL Server à l'aide de l'authentification Windows, vous devez spécifier l'identité Windows qu'utilise votre application. Vous devez également accorder l'accès à l'identité Windows à la base de données SQL Server.
SQL Server possède deux modes d'accès : le mode d'authentification Windows et le mode mixte. Le mode d'authentification Windows active l'authentification Windows et désactive l'authentification SQL Server. Le mode mixte active à la fois l'authentification Windows et l'authentification SQL Server. L'authentification Windows est toujours disponible et ne peut pas être désactivée. Pour plus d'informations sur l'authentification Windows, consultez la documentation Microsoft Windows.
L'exemple ci-dessous illustre un moyen de créer un utilisateur dans TEST\$1DB.
```
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
```
### Utilisation de l'authentification Windows avec une connexion JDBC
Le pilote JDBC ne prend pas en charge l'authentification Windows lorsque le pilote est utilisé sur des systèmes d'exploitation autres que Windows. Les informations d'authentification Windows, telles que le nom d'utilisateur et le mot de passe, ne sont pas spécifiées automatiquement lors de la connexion à SQL Server à partir de systèmes d'exploitation autres que Windows. Dans ce cas, les applications doivent plutôt utiliser l'authentification SQL Server.
Dans la chaîne de connexion JDBC, le paramètre `integratedSecurity` doit être spécifié pour se connecter à l'aide de l'authentification Windows. Le pilote JDBC prend en charge l'authentification Windows intégrée sur les systèmes d'exploitation Windows via le paramètre de chaîne de connexion `integratedSecurity`.
Pour utiliser l'authentification intégrée
1. Installez le pilote JDBC.
1. Copiez le fichier `sqljdbc_auth.dll` dans un répertoire sur le chemin d'accès système Windows sur l'ordinateur où le pilote JDBC est installé.
Les `sqljdbc_auth.dll` fichiers sont installés à l'emplacement suivant :
<*répertoire d'installation*>\$1sqljdbc\$1<*version*>\$1<*language*>\$1auth\$1
Lorsque vous essayez d'établir une connexion à la base de données SQL Server à l'aide de l'authentification Windows, vous pouvez obtenir l'erreur suivante : Ce pilote n'est pas configuré pour l'authentification intégrée. Ce problème peut être résolu à l'aide des actions suivantes :
+ Déclaration de deux variables qui pointent vers le chemin d'accès de votre installation JDBC :
`variable name: SQLJDBC_HOME; variable value: D:\lib\JDBC4.1\enu`(où se trouve votre fichier sqljdbc4.jar) ;
`variable name: SQLJDBC_AUTH_HOME; variable value: D\lib\JDBC4.1\enu\auth\x86`(si vous utilisez un système d'exploitation 32 bits) ou `D\lib\JDBC4.1\enu\auth\x64` (si vous utilisez un système d'exploitation 64 bits). C'est ici que se `sqljdbc_auth.dll` trouve le vôtre.
+ Copiez `sqljdbc_auth.dll` dans le dossier dans lequel vous êtes JDK/JRE en cours d'exécution. Vous pouvez effectuer la copie vers le dossier lib, dans le dossier Bin, etc. Par exemple, vous pouvez copier le fichier dans le dossier suivant.
```
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
```
+ Assurez-vous que le dossier de votre bibliothèque JDBC ne contient que le SQLJDBC4 fichier .jar. Supprimez tous les autres fichiers sqljdbc\$1.jar de ce dossier (ou copiez-les dans un autre dossier). Si vous ajoutez le pilote dans le cadre de votre programme, assurez-vous d'ajouter uniquement SQLJDBC4 .jar comme pilote à utiliser.
+ Copie du fichier sqljdbc\$1auth.dll dans le dossier contenant votre application.
**Note**
Si vous exécutez une machine virtuelle Java (JVM) 32 bits, utilisez le fichier sqljdbc\$1auth.dll situé dans le dossier x86, même si la version du système d'exploitation est x64. Si vous exécutez une machine virtuelle Java 64 bits sur un processeur x64, utilisez le fichier sqljdbc\$1auth.dll dans le dossier x64.
Lorsque vous vous connectez à une base de données SQL Server, vous pouvez choisir l'**authentification Windows** ou l'**authentification SQL Server** comme option d'**authentification**.
## Connexion à SQL Server en tant que source
Utilisez la procédure suivante pour vous connecter à une base de données source Microsoft SQL Server avec le AWS Schema Conversion Tool.
**Pour vous connecter à une base de données source Microsoft SQL Server**
1. Dans le AWS Schema Conversion Tool, choisissez **Ajouter une source**.
1. Choisissez **Microsoft SQL Server**, puis **Next**.
La boîte de dialogue **Ajouter une source** apparaît.
1. Dans **Nom de connexion**, entrez le nom de votre base de données. AWS SCT affiche ce nom dans l'arborescence du panneau de gauche.
1. Utilisez les informations d'identification de la base de données AWS Secrets Manager ou saisissez-les manuellement :
+ Pour utiliser les informations d'identification de base de données issues de Secrets Manager, suivez les instructions suivantes :
1. Pour **AWS Secret**, choisissez le nom du secret.
1. Choisissez **Populer pour renseigner** automatiquement toutes les valeurs dans la boîte de dialogue de connexion à la base de données depuis Secrets Manager.
Pour plus d'informations sur l'utilisation des informations d'identification de base de données depuis Secrets Manager, consultez[Configuration AWS Secrets Manager dans AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md).
+ Pour saisir manuellement les informations de connexion à la base de données source Microsoft SQL Server, suivez les instructions suivantes :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.html)
1. Choisissez **Tester la connexion** pour vérifier que AWS SCT vous pouvez vous connecter à votre base de données source.
1. Choisissez **Connect pour vous** connecter à votre base de données source.
# Conversion de SQL Server en MySQL
Pour émuler les fonctions de base de données Microsoft SQL Server dans votre code MySQL converti, utilisez le pack d'extension SQL Server vers MySQL intégré. AWS SCT Pour plus d’informations sur les packs d’extension, consultez [Utilisation de packs d'extension avec AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [
## Privilèges pour MySQL en tant que base de données cible
](#CHAP_Source.SQLServer.ToMySQL.ConfigureTarget)
+ [
## Paramètres de conversion SQL Server vers MySQL
](#CHAP_Source.SQLServer.ToMySQL.ConversionSettings)
+ [
## Considérations concernant la migration
](#CHAP_Source.SQLServer.ToMySQL.MigrationConsiderations)
## Privilèges pour MySQL en tant que base de données cible
Les privilèges requis pour MySQL en tant que cible sont les suivants :
+ CRÉER SUR\$1 . \$1
+ MODIFIER \$1 . \$1
+ DÉPOSEZ \$1 . \$1
+ INDEX SUR \$1 . \$1
+ RÉFÉRENCES SUR\$1 . \$1
+ SELECT ON \$1.\$1
+ CRÉER UNE VUE SUR \$1 . \$1
+ SHOW VIEW ON \$1.\$1
+ DÉCLENCHEUR ACTIVÉ\$1 . \$1
+ CRÉER UNE ROUTINE SUR\$1 . \$1
+ MODIFIER LA ROUTINE SUR \$1 . \$1
+ EXÉCUTER SUR\$1 . \$1
+ INSÉRER, METTRE À JOUR SUR AWS\$1SQLSERVER \$1EXT. \$1
+ INSÉREZ, METTEZ À JOUR, SUPPRIMEZ SUR AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
+ CRÉEZ DES TABLES TEMPORAIRES SUR AWS\$1SQLSERVER \$1EXT\$1DATA. \$1
Vous pouvez utiliser l’exemple de code suivant pour créer un utilisateur de base de données et accorder les privilèges.
```
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';
```
Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez-le ensuite *your\$1password* par un mot de passe sécurisé.
Si vous utilisez une base de données MySQL version 5.7 ou inférieure comme cible, exécutez la commande suivante. Pour les bases de données MySQL version 8.0 et supérieures, cette commande est obsolète.
```
GRANT SELECT ON mysql.proc TO 'user_name';
```
Pour utiliser Amazon RDS for MySQL ou Aurora MySQL en tant que cible, définissez le paramètre `lower_case_table_names` sur `1`. Cette valeur signifie que le serveur MySQL traite les identifiants des noms d’objets tels que les tables, les index, les déclencheurs et les bases de données sans distinction entre majuscules et minuscules. Si vous avez activé la journalisation binaire dans votre instance cible, définissez le paramètre `log_bin_trust_function_creators` sur `1`. Dans ce cas, vous n’avez pas besoin d’utiliser les caractéristiques `DETERMINISTIC`, `READS SQL DATA` ni `NO SQL` pour créer des fonctions stockées. Pour configurer ces paramètres, créez un nouveau groupe de paramètres de base de données ou modifiez un groupe de paramètres de base de données existant.
## Paramètres de conversion SQL Server vers MySQL
Pour modifier les paramètres de conversion de SQL Server vers MySQL, AWS SCT sélectionnez **Paramètres**, puis sélectionnez **Paramètres de conversion**. Dans la liste supérieure, choisissez **SQL Server**, puis **SQL Server — MySQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion de SQL Server vers MySQL.
Les paramètres de conversion de SQL Server vers MySQL AWS SCT incluent des options pour les éléments suivants :
+ Pour limiter le nombre de commentaires contenant des actions dans le code converti.
Pour **Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure**, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la sévérité est sélectionnée ou supérieure.
Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez **Erreurs uniquement**. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez **Tous les messages**.
+ Pour permettre à votre base de données SQL Server source de stocker le résultat de `EXEC` dans une table. AWS SCT crée des tables temporaires et une procédure supplémentaire pour émuler cette fonctionnalité. Pour utiliser cette émulation, sélectionnez **Créer des routines supplémentaires pour gérer les ensembles de données ouverts**.
## Considérations concernant la migration
Tenez compte des éléments suivants lors de la migration d'un schéma SQL Server vers MySQL :
+ MySQL ne supporte pas `MERGE` cette déclaration. Cependant, AWS SCT vous pouvez émuler l'`MERGE`instruction lors de la conversion en utilisant la `INSERT ON DUPLICATE KEY` clause et les `UPDATE FROM and DELETE FROM` instructions.
Pour une émulation correcte`INSERT ON DUPLICATE KEY`, assurez-vous qu'une contrainte ou une clé primaire unique existe sur la base de données MySQL cible.
+ Vous pouvez utiliser une `GOTO` instruction et une étiquette pour modifier l'ordre dans lequel les instructions sont exécutées. Toutes les instructions Transact-SQL qui suivent une `GOTO` instruction sont ignorées et le traitement se poursuit au niveau de l'étiquette. Vous pouvez utiliser `GOTO` des instructions et des étiquettes n'importe où dans une procédure, un lot ou un bloc d'instructions. Vous pouvez également imbriquer `GOTO` des relevés.
MySQL n'utilise pas d'`GOTO`instructions. Lors de la AWS SCT conversion du code contenant une `GOTO` instruction, il convertit l'instruction pour utiliser une `LOOP…END LOOP` instruction `BEGIN…END` or. Vous trouverez des exemples de AWS SCT conversion d'`GOTO`instructions dans le tableau suivant.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToMySQL.html)
+ MySQL ne prend pas en charge les fonctions multiinstructions à valeur de table. AWS SCT simule des fonctions basées sur des tables lors d'une conversion en créant des tables temporaires et en réécrivant des instructions pour utiliser ces tables temporaires.
# Migration de SQL Server vers PostgreSQL avec AWS Schema Conversion Tool
Vous pouvez utiliser le pack d'extension SQL Server vers PostgreSQL dans. AWS SCT Ce pack d'extension émule les fonctions de base de données SQL Server dans le code PostgreSQL converti. Utilisez le pack d'extension SQL Server vers PostgreSQL pour émuler SQL Server Agent et SQL Server Database Mail. Pour plus d’informations sur les packs d’extension, consultez [Utilisation de packs d'extension avec AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
**Topics**
+ [
## Privilèges pour PostgreSQL en tant que base de données cible
](#CHAP_Source.SQLServer.ToPostgreSQL.ConfigurePostgreSQL)
+ [
## Paramètres de conversion SQL Server vers PostgreSQL
](#CHAP_Source.SQLServer.ToPostgreSQL.ConversionSettings)
+ [
## Conversion de partitions SQL Server en partitions PostgreSQL version 10
](#CHAP_Source.SQLServer.ToPostgreSQL.PG10Partitions)
+ [
## Considérations concernant la migration
](#CHAP_Source.SQLServer.ToPostgreSQL.MigrationConsiderations)
+ [
# Utilisation d'un pack d' AWS SCT extension pour émuler l'agent SQL Server dans PostgreSQL
](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Agent.md)
+ [
# Utilisation d'un pack d' AWS SCT extension pour émuler SQL Server Database Mail dans PostgreSQL
](CHAP_Source.SQLServer.ToPostgreSQL.ExtensionPack.Mail.md)
## Privilèges pour PostgreSQL en tant que base de données cible
Pour utiliser PostgreSQL comme cible AWS SCT , le privilège est requis. `CREATE ON DATABASE` Assurez-vous d'accorder ce privilège à chaque base de données PostgreSQL cible.
Pour utiliser les synonymes publics convertis, remplacez le chemin de recherche par défaut de la base de données par`"$user", public_synonyms, public`.
Vous pouvez utiliser l’exemple de code suivant pour créer un utilisateur de base de données et accorder les privilèges.
```
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;
```
Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez ensuite *db\$1name* par le nom de votre base de données cible. Enfin, remplacez-le *your\$1password* par un mot de passe sécurisé.
Dans PostgreSQL, seul le propriétaire du schéma ou un `superuser` peut supprimer un schéma. Le propriétaire peut supprimer un schéma et tous les objets qu'il inclut même si le propriétaire du schéma ne possède pas certains de ses objets.
Lorsque vous utilisez différents utilisateurs pour convertir et appliquer différents schémas à votre base de données cible, un message d'erreur peut s'afficher lorsque vous ne AWS SCT pouvez pas supprimer un schéma. Pour éviter ce message d’erreur, utilisez le rôle `superuser`.
## Paramètres de conversion SQL Server vers PostgreSQL
**Pour modifier les paramètres de conversion de SQL Server vers PostgreSQL, **choisissez** Paramètres, puis Paramètres de conversion.** Dans la liste supérieure, choisissez **SQL Server**, puis **SQL Server — PostgreSQL**. AWS SCT affiche tous les paramètres disponibles pour la conversion de SQL Server vers PostgreSQL.
Les paramètres de conversion de SQL Server vers PostgreSQL incluent des options pour AWS SCT les éléments suivants :
+ Pour limiter le nombre de commentaires contenant des actions dans le code converti.
Pour **Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure**, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la sévérité est sélectionnée ou supérieure.
Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez **Erreurs uniquement**. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez **Tous les messages**.
+ Permettre d'utiliser des index portant le même nom dans différentes tables de SQL Server.
Dans PostgreSQL, tous les noms d'index que vous utilisez dans le schéma doivent être uniques. Pour vous assurer que cela AWS SCT génère des noms uniques pour tous vos index, sélectionnez **Générer des noms uniques pour les index**.
+ Pour convertir les procédures SQL Server en fonctions PostgreSQL.
Les versions 10 et antérieures de PostgreSQL ne prennent pas en charge les procédures. Les clients qui ne sont pas habitués à utiliser les procédures dans PostgreSQL peuvent les convertir AWS SCT en fonctions. Pour ce faire, sélectionnez **Convertir les procédures en fonctions**.
+ Pour émuler la sortie de `EXEC` dans un tableau.
Votre base de données SQL Server source peut stocker le résultat de `EXEC` dans une table. AWS SCT crée des tables temporaires et une procédure supplémentaire pour émuler cette fonctionnalité. Pour utiliser cette émulation, sélectionnez **Créer des routines supplémentaires pour gérer les ensembles de données ouverts**.
+ Pour définir le modèle à utiliser pour les noms de schéma dans le code converti. Pour **le modèle de génération de nom de schéma**, choisissez l'une des options suivantes :
+ ****— Utilise le nom de base de données SQL Server comme nom de schéma dans PostgreSQL.
+ ****— Utilise le nom du schéma SQL Server comme nom de schéma dans PostgreSQL.
+ **\$1** — Utilise une combinaison de noms de schéma et de base de données SQL Server comme nom de schéma dans PostgreSQL.
+ Pour conserver les noms de vos objets source en majuscules.
Pour éviter de convertir les noms d'objets en minuscules, sélectionnez **Éviter de convertir les noms en minuscules pour les opérations faisant la distinction entre majuscules et minuscules**. Cette option s'applique uniquement lorsque vous activez la distinction majuscules/minuscules dans votre base de données cible.
+ Pour conserver les noms des paramètres dans votre base de données source.
Pour ajouter des guillemets doubles aux noms des paramètres dans le code converti, sélectionnez **Conserver les noms des paramètres d'origine**.
## Conversion de partitions SQL Server en partitions PostgreSQL version 10
Lorsque vous convertissez une base de données Microsoft SQL Server vers Amazon Aurora PostgreSQL Compatible Edition (Aurora PostgreSQL) ou Amazon Relational Database Service for PostgreSQL (Amazon RDS for PostgreSQL), tenez compte des points suivants.
Dans SQL Server, vous créez des partitions avec des fonctions de partition. Lorsque vous convertissez une table SQL Server divisée en portions en une table PostgreSQL version 10 divisée en portions, vous devez être conscient de plusieurs problèmes potentiels :
+ SQL Server vous permet de partitionner une table à l'aide d'une colonne sans contrainte NOT NULL. Dans ce cas, toutes les valeurs NULL sont dirigées vers la partition la plus à gauche. PostgreSQL ne prend pas en charge les valeurs NULL pour le partitionnement RANGE.
+ SQL Server vous permet de créer des clés primaires et uniques pour les tables partitionnées. Pour PostgreSQL, vous créez des clés primaires ou uniques pour chaque partition directement. Par conséquent, la contrainte PRIMARY ou UNIQUE KEY doit être supprimée de la table parent lors de la migration vers PostgreSQL. Les noms de clé qui en résultent prennent le format`_`.
+ SQL Server vous permet de créer une contrainte de clé étrangère à partir de et vers des tables partitionnées. PostgreSQL ne prend pas en charge les clés étrangères qui référencent des tables partitionnées. De plus, PostgreSQL ne prend pas en charge les références de clé étrangère à partir d'une table partitionnée vers une autre table.
+ SQL Server vous permet de créer des index pour les tables partitionnées. Pour PostgreSQL, un index doit être créé pour chaque partition directement. Par conséquent, les index doivent être supprimés des tables parents lors de la migration vers PostgreSQL. Les noms d'index qui en résultent sont au format `_`.
+ PostgreSQL ne prend pas en charge les index partitionnés.
## Considérations concernant la migration
Voici quelques points à prendre en compte lors de la migration d'un schéma SQL Server vers PostgreSQL :
+ Dans PostgreSQL, tous les noms des objets dans un schéma doivent être uniques, y compris les index. Les noms d'index doivent être uniques dans le schéma de la table de base. Dans SQL Server, un nom d'index peut être identique pour différentes tables.
Pour garantir l'unicité des noms d'index, vous AWS SCT donne la possibilité de générer des noms d'index uniques si vos noms d'index ne sont pas uniques. Pour cela, choisissez l'option **Generate unique index names (Générer des noms d'index uniques)** dans les propriétés du projet. Cette option est activée par défaut. Si cette option est activée, les noms d'index uniques sont créés au format IX\$1table\$1name\$1index\$1name. Si cette option est désactivée, les noms d'index ne sont pas modifiés.
+ Une instruction GOTO et une étiquette peuvent être utilisées pour modifier l'ordre dans lequel les instructions sont exécutées. Toutes les instructions Transact-SQL qui suivent une instruction GOTO sont ignorées et le traitement continue au niveau de l'étiquette. Les instructions GOTO et les étiquettes peuvent être utilisées à n'importe quel endroit dans une procédure, un lot ou un bloc d'instructions. Les instructions GOTO peuvent également être imbriquées.
PostgreSQL n'utilise pas les instructions GOTO. Lors de la AWS SCT conversion du code contenant une instruction GOTO, il convertit l'instruction pour utiliser une instruction BEGIN... END ou LOOP... END LOOP. Vous trouverez des exemples de AWS SCT conversion des instructions GOTO dans le tableau suivant.
**Instructions GOTO SQL Server et instructions PostgreSQL converties**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/SchemaConversionTool/latest/userguide/CHAP_Source.SQLServer.ToPostgreSQL.html)
+ PostgreSQL ne prend pas en charge les instructions MERGE. AWS SCT émule le comportement d'une instruction MERGE de la manière suivante :
+ Par une construction INSERT ON CONFLICT.
+ En utilisant l'instruction UPDATE FROM DML, par exemple MERGE sans clause WHEN NOT MATCHED.
+ En utilisant une instruction CURSOR, par exemple avec une clause MERGE avec DELETE ou à l'aide d'une instruction de condition MERGE ON complexe.
+ AWS SCT peut ajouter des déclencheurs de base de données à l'arborescence d'objets lorsque Amazon RDS est la cible.
+ AWS SCT peut ajouter des déclencheurs au niveau du serveur à l'arborescence des objets lorsque Amazon RDS est la cible.
+ SQL Server crée et gère automatiquement `deleted` des `inserted` tables. Vous pouvez utiliser ces tables temporaires résidant en mémoire pour tester les effets de certaines modifications de données et pour définir les conditions des actions de déclenchement DML. AWS SCT peut convertir l'utilisation de ces tables dans des instructions de déclenchement DML.
+ AWS SCT peut ajouter des serveurs liés à l'arborescence des objets lorsque Amazon RDS est la cible.
+ Lors de la migration de Microsoft SQL Server vers PostgreSQL, la fonction SUSER\$1SNAME intégrée est convertie comme suit :
+ SUSER\$1SNAME – Renvoie le nom de connexion associé à un numéro d'identification de sécurité (SID).
+ SUSER\$1SNAME() – Non pris en charge.
+ SUSER\$1SNAME () CURRENT\$1USER – Renvoie le nom d'utilisateur du contexte d'exécution actuel.
+ SUSER\$1SNAME (NULL) - Renvoie NULL.
+ La conversion de fonctions avec valeurs de table est prise en charge. Les fonctions avec valeurs de table renvoient une table et peuvent remplacer une table dans une requête.
+ PATINDEX renvoie la position de départ de la première occurrence d'un modèle dans une expression spécifiée sur tous les types de données texte et caractère. Il renvoie des zéros si le modèle n'est pas trouvé. Lors de la conversion de SQL Server vers Amazon RDS for AWS SCT PostgreSQL, le code d'application qui utilise PATINDEX est remplacé par aws\$1sqlserver\$1ext.patindex (,).
+ Dans SQL Server, un type de table défini par l'utilisateur est un type qui représente la définition d'une structure de table. Vous utilisez un type de table défini par l'utilisateur afin de déclarer les paramètres de valeur de table pour les procédures ou fonctions stockées. Vous pouvez également utiliser un type de table défini par l'utilisateur pour déclarer les variables de table que vous souhaitez utiliser dans un lot ou dans le corps d'une procédure stockée ou d'une fonction. AWS SCT a émulé ce type dans PostgreSQL en créant une table temporaire.
Lors de la conversion de SQL Server vers PostgreSQL AWS SCT , les objets système SQL Server sont convertis en objets reconnaissables dans PostgreSQL. Le tableau suivant montre la façon dont les objets système sont convertis.
| Cas d'utilisation de MS SQL Server | Substitution par 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\$1SQLSERVERCLÉS ÉTRANGÈRES \$1EXT.SYS\$1SYS |
| 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\$1INDEX |
| 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\$1SQLSERVEROBJETS \$1EXT.SYS\$1SYS |
| SYS.SQL\$1MODULES | AWS\$1SQLSERVERMODULES \$1EXT.SYS\$1SQL |
| SYS.DATABASES | AWS\$1SQLSERVERBASES DE DONNÉES \$1EXT.SYS\$1 |
| INFORMATION\$1SCHEMA.SCHEMATA | AWS\$1SQLSERVER\$1EXT.INFORMATION\$1SCHÉMA\$1SCHÉMAS |
| 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\$1CONTRAINTES |
| 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 |
# Utilisation d'un pack d' AWS SCT extension pour émuler l'agent SQL Server dans PostgreSQL
L'agent SQL Server est un service Microsoft Windows qui exécute des tâches SQL Server. L'agent SQL Server exécute les tâches selon un calendrier, en réponse à un événement spécifique ou à la demande. Pour plus d'informations sur SQL Server Agent, consultez la [documentation technique Microsoft](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent?view=sql-server-ver15).
PostgreSQL n'a pas d'équivalent pour SQL Server Agent. Pour émuler les fonctionnalités de l'agent SQL Server, AWS SCT créez un pack d'extension. Ce pack d'extension utilise AWS Lambda Amazon CloudWatch. AWS Lambda implémente l'interface que vous utilisez pour gérer les plannings et exécuter des tâches. Amazon CloudWatch applique les règles de planification.
AWS Lambda et Amazon CloudWatch utilisent un paramètre JSON pour interagir. La structure de ce paramètre JSON est la suivante.
```
{
"mode": mode,
"parameters": {
list of parameters
},
"callback": procedure name
}
```
Dans l'exemple précédent, *`mode`* il s'agit du type de tâche et `list of parameters` d'un ensemble de paramètres qui dépendent du type de tâche. `procedure name`C'est également le nom de la procédure qui s'exécute une fois la tâche terminée.
AWS SCT utilise une fonction Lambda pour contrôler et exécuter des tâches. La CloudWatch règle lance l'exécution de la tâche et fournit les informations nécessaires pour démarrer la tâche. Lorsque la CloudWatch règle se déclenche, elle lance la fonction Lambda en utilisant les paramètres de la règle.
Pour créer une tâche simple qui appelle une procédure, utilisez le format suivant.
```
{
"mode": "run_job",
"parameters": {
"vendor": "mysql",
"cmd": "lambda_db.nightly_job"
}
}
```
Pour créer une tâche en plusieurs étapes, utilisez le format suivant.
```
{
"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
},
...
]
}
```
Pour émuler le comportement de l'agent SQL Server dans PostgreSQL, AWS SCT le pack d'extension crée également les tables et procédures suivantes.
## Tables qui émulent l'agent SQL Server dans PostgreSQL
Pour émuler l'agent SQL Server, le pack d'extension utilise les tableaux suivants :
**sysjobs**
Stocke les informations relatives aux tâches.
**étapes du sysjob**
Stocke les informations relatives aux étapes d'une tâche.
**plannings du système**
Stocke les informations relatives aux plannings de travail.
**plannings de tâches sysjob**
Stocke les informations de planification pour les tâches individuelles.
**sysjobhistory**
Stocke les informations relatives aux exécutions des tâches planifiées.
## Procédures qui émulent l'agent SQL Server dans PostgreSQL
Pour émuler l'agent SQL Server, le pack d'extension utilise les procédures suivantes :
**sp\$1add\$1job**
Ajoute une nouvelle tâche.
**sp\$1add\$1jobstep**
Ajoute une étape à une tâche.
**sp\$1add\$1schedule**
Crée une nouvelle règle de planification dans Amazon CloudWatch. Vous pouvez utiliser ce calendrier avec autant de tâches que vous le souhaitez.
**sp\$1attach\$1schedule**
Définit un calendrier pour le travail sélectionné.
**sp\$1add\$1jobschedule**
Crée une règle de planification pour une tâche sur Amazon CloudWatch et définit l'objectif de cette règle.
**sp\$1update\$1job**
Met à jour les attributs de la tâche créée précédemment.
**sp\$1update\$1jobstep**
Met à jour les attributs de l'étape d'une tâche.
**sp\$1update\$1schedule**
Met à jour les attributs d'une règle de planification dans Amazon CloudWatch.
**sp\$1update\$1jobschedule**
Met à jour les attributs du planning pour la tâche spécifiée.
**sp\$1delete\$1job**
Supprime une tâche.
**sp\$1delete\$1jobstep**
Supprime une étape d'une tâche.
**sp\$1delete\$1planning**
Supprime un planning.
**sp\$1delete\$1jobschedule**
Supprime d'Amazon CloudWatch la règle de planification pour la tâche spécifiée.
**sp\$1detach\$1schedule**
Supprime une association entre un planning et une tâche.
**get\$1jobs, update\$1job**
Procédures internes qui interagissent avec 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**
Procédures internes qui vérifient les paramètres.
## Syntaxe des procédures qui émulent l'agent SQL Server dans PostgreSQL
La `aws_sqlserver_ext.sp_add_job` procédure du pack d'extension émule la `msdb.dbo.sp_add_job` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_add_jobstep` procédure du pack d'extension émule la `msdb.dbo.sp_add_jobstep` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_add_schedule` procédure du pack d'extension émule la `msdb.dbo.sp_add_schedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_attach_schedule` procédure du pack d'extension émule la `msdb.dbo.sp_attach_schedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_add_jobschedule` procédure du pack d'extension émule la `msdb.dbo.sp_add_jobschedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_delete_job` procédure du pack d'extension émule la `msdb.dbo.sp_delete_job` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_delete_jobstep` procédure du pack d'extension émule la `msdb.dbo.sp_delete_jobstep` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_delete_jobschedule` procédure du pack d'extension émule la `msdb.dbo.sp_delete_jobschedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_delete_schedule` procédure du pack d'extension émule la `msdb.dbo.sp_delete_schedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_detach_schedule` procédure du pack d'extension émule la `msdb.dbo.sp_detach_schedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_update_job` procédure du pack d'extension émule la `msdb.dbo.sp_update_job` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_update_jobschedule` procédure du pack d'extension émule la `msdb.dbo.sp_update_jobschedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_update_jobstep` procédure du pack d'extension émule la `msdb.dbo.sp_update_jobstep` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sp_update_schedule` procédure du pack d'extension émule la `msdb.dbo.sp_update_schedule` procédure. Pour plus d'informations sur la procédure source de l'agent SQL Server, consultez [la documentation technique 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
```
## Exemples d'utilisation de procédures qui émulent l'agent SQL Server dans PostgreSQL
Pour ajouter une nouvelle tâche, suivez la `aws_sqlserver_ext.sp_add_job` procédure décrite ci-dessous.
```
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');
```
Pour ajouter une nouvelle étape de travail, suivez la `aws_sqlserver_ext.sp_add_jobstep` procédure décrite ci-dessous.
```
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');
```
Pour ajouter un calendrier simple, suivez la `aws_sqlserver_ext.sp_add_schedule` procédure ci-dessous.
```
SELECT * FROM aws_sqlserver_ext.sp_add_schedule(
par_schedule_name := 'RunOnce',
par_freq_type := 1,
par_active_start_time := 233000);
```
Pour définir un calendrier pour une tâche, suivez la `aws_sqlserver_ext.sp_attach_schedule` procédure décrite ci-dessous.
```
SELECT * FROM aws_sqlserver_ext.sp_attach_schedule (
par_job_name := 'test_job',
par_schedule_name := 'NightlyJobs');
```
Pour créer un calendrier pour une tâche, suivez la `aws_sqlserver_ext.sp_add_jobschedule` procédure décrite ci-dessous.
```
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);
```
## Exemples d'utilisation pour émuler l'agent SQL Server dans PostgreSQL
Si le code de votre base de données source utilise l'agent SQL Server pour exécuter des tâches, vous pouvez utiliser le pack d'extension SQL Server vers PostgreSQL AWS SCT pour convertir ce code en PostgreSQL. Le pack d'extension utilise des AWS Lambda fonctions pour émuler le comportement de SQL Server Agent.
Vous pouvez créer une nouvelle AWS Lambda fonction ou enregistrer une fonction existante.
**Pour créer une nouvelle AWS Lambda fonction**
1. Dans AWS SCT l'arborescence de la base de données cible, ouvrez le menu contextuel (clic droit), choisissez **Appliquer le pack d'extension pour**, puis **PostgreSQL**.
L'assistant Kit d'extension s'affiche.
1. Dans l'onglet **Service d'émulation de l'agent SQL Server**, procédez comme suit :
+ Choisissez **Créer une AWS Lambda fonction**.
+ Pour **Connexion à la base** de données, entrez le nom de l'utilisateur de la base de données cible.
+ Dans le **champ Mot de passe de la base** de données, entrez le mot de passe correspondant au nom d'utilisateur que vous avez saisi à l'étape précédente.
+ Pour **le dossier de bibliothèque Python**, entrez le chemin d'accès au dossier de votre bibliothèque Python.
+ Choisissez **Créer AWS Lambda une fonction**, puis **Next**.
**Pour enregistrer une AWS Lambda fonction que vous avez déployée précédemment**
+ Exécutez le script suivant sur votre base de données cible.
```
SELECT
FROM aws_sqlserver_ext.set_service_setting(
p_service := 'JOB',
p_setting := 'LAMBDA_ARN',
p_value := ARN)
```
Dans l'exemple précédent, *`ARN`* il s'agit de l'Amazon Resource Name (ARN) de la AWS Lambda fonction déployée.
L'exemple suivant crée une tâche simple composée d'une étape. Toutes les cinq minutes, cette tâche exécute la `job_example` fonction créée précédemment. Cette fonction insère des enregistrements dans la `job_example_table` table.
**Pour créer cette tâche simple**
1. Créez une tâche à l'aide de la `aws_sqlserver_ext.sp_add_job` fonction illustrée ci-dessous.
```
SELECT
FROM aws_sqlserver_ext.sp_add_job (
par_job_name := 'test_simple_job');
```
1. Créez une étape de travail à l'aide de la `aws_sqlserver_ext.sp_add_jobstep` fonction illustrée ci-dessous.
```
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;');
```
L'étape de travail indique le rôle de la fonction.
1. Créez un planificateur pour le travail à l'aide de la `aws_sqlserver_ext.sp_add_jobschedule` fonction illustrée ci-dessous.
```
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 */);
```
L'étape de travail indique le rôle de la fonction.
Pour supprimer cette tâche, utilisez la `aws_sqlserver_ext.sp_delete_job` fonction illustrée ci-dessous.
```
PERFORM aws_sqlserver_ext.sp_delete_job(
par_job_name := 'PeriodicJob1'::character varying,
par_delete_history := 1::smallint,
par_delete_unused_schedule := 1::smallint);
```
# Utilisation d'un pack d' AWS SCT extension pour émuler SQL Server Database Mail dans PostgreSQL
Vous pouvez utiliser SQL Server Database Mail pour envoyer des e-mails aux utilisateurs à partir du moteur de base de données SQL Server ou d'une instance gérée Azure SQL. Ces e-mails peuvent contenir les résultats de requêtes ou inclure des fichiers provenant de n'importe quelle ressource de votre réseau. Pour plus d'informations sur SQL Server Database Mail, consultez [la documentation technique Microsoft](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver15).
PostgreSQL n'a pas d'équivalent pour SQL Server Database Mail. Pour émuler les fonctionnalités de messagerie de base de données SQL Server, AWS SCT créez un pack d'extension. Ce pack d'extension utilise AWS Lambda Amazon Simple Email Service (Amazon SES). AWS Lambda fournit aux utilisateurs une interface leur permettant d'interagir avec le service d'envoi d'e-mails Amazon SES. Pour configurer cette interaction, ajoutez le nom de ressource Amazon (ARN) de votre fonction Lambda.
Pour créer un nouveau compte de messagerie, utilisez la commande suivante.
```
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;
```
Pour ajouter l'ARN de votre fonction Lambda au compte de messagerie existant, utilisez la commande suivante.
```
do
$$
begin
PERFORM sysmail_update_account_sp (
par_account_name :='existind_account_name',
par_mailserver_type := 'AWSLAMBDA'
par_mailserver_name := 'ARN'
);
end;
$$ language plpgsql;
```
Dans les exemples précédents, *`ARN`* c'est l'ARN de votre fonction Lambda.
Pour émuler le comportement du courrier de base de données SQL Server dans PostgreSQL, AWS SCT le pack d'extension utilise les tables, les vues et les procédures suivantes.
## Tables qui émulent le courrier de base de données SQL Server dans PostgreSQL
Pour émuler SQL Server Database Mail, le pack d'extension utilise les tables suivantes :
**compte sysmail\$1**
Stocke les informations relatives aux comptes de messagerie.
**sysmail\$1profile**
Stocke les informations relatives aux profils utilisateur.
**serveur\$1système**
Stocke les informations relatives aux serveurs de messagerie.
**sysmail\$1mailitems**
Stocke la liste des e-mails.
**sysmail\$1attachments**
Contient une ligne pour chaque pièce jointe à un e-mail.
**journal de messagerie système**
Stocke les informations de service relatives à l'envoi de messages électroniques.
**compte sysmail\$1profile**
Stocke les informations relatives aux profils d'utilisateurs et aux comptes de messagerie.
## Vues qui émulent le courrier de base de données SQL Server dans PostgreSQL
Pour émuler SQL Server Database Mail, AWS SCT créez les vues suivantes dans la base de données PostgreSQL afin de garantir la compatibilité. Le pack d'extension ne les utilise pas, mais votre code converti peut interroger ces vues.
**sysmail\$1allitems**
Inclut une liste de tous les e-mails.
**sysmail\$1faileditems**
Inclut une liste des e-mails qui n'ont pas pu être envoyés.
**sysmail\$1sentitems**
Inclut une liste des e-mails envoyés.
**sysmail\$1unsentitems**
Inclut une liste d'e-mails qui n'ont pas encore été envoyés.
**sysmail\$1mailattachments**
Inclut une liste des fichiers joints.
## Procédures qui émulent le courrier de base de données SQL Server dans PostgreSQL
Pour émuler SQL Server Database Mail, le pack d'extension utilise les procédures suivantes :
**sp\$1send\$1dbmail**
Envoie un e-mail aux destinataires spécifiés.
**sysmail\$1add\$1profile\$1sp**
Crée un nouveau profil utilisateur.
**sysmail\$1add\$1account\$1sp**
Crée un nouveau compte de messagerie qui stocke des informations telles que les informations d'identification du protocole SMTP (Simple Mail Transfer Protocol), etc.
**sysmail\$1add\$1profileaccount\$1sp**
Ajoute un compte e-mail au profil utilisateur spécifié.
**sysmail\$1update\$1profile\$1sp**
Modifie les attributs du profil utilisateur tels que la description, le nom, etc.
**sysmail\$1update\$1account\$1sp**
Modifie les informations du compte de messagerie existant.
**sysmail\$1update\$1profileaccount\$1sp**
Met à jour les informations du compte e-mail dans le profil utilisateur spécifié.
**sysmail\$1delete\$1profileaccount\$1sp**
Supprime un compte de messagerie du profil utilisateur spécifié.
**sysmail\$1delete\$1account\$1sp**
Supprime le compte de messagerie.
**sysmail\$1delete\$1profile\$1sp**
Supprime le profil utilisateur.
**sysmail\$1delete\$1mailitems\$1sp**
Supprime les e-mails des tables internes.
**sysmail\$1help\$1profile\$1sp**
Affiche des informations sur le profil utilisateur.
**sysmail\$1help\$1account\$1sp**
Affiche les informations relatives au compte de messagerie.
**sysmail\$1help\$1profileaccount\$1sp**
Affiche des informations sur les comptes de messagerie associés au profil utilisateur.
**sysmail\$1dbmail\$1json**
Procédure interne qui génère des requêtes JSON pour des AWS Lambda fonctions.
**sysmail\$1verify\$1profile\$1sp, sysmail\$1verify\$1account\$1sp, sysmail\$1verify\$1addressparams\$1sp**
Procédures internes qui vérifient les paramètres.
**sp\$1get\$1dbmail, sp\$1set\$1dbmail, sysmail\$1dbmail\$1xml**
Procédures internes déconseillées.
## Syntaxe des procédures qui émulent le courrier de base de données SQL Server dans PostgreSQL
La `aws_sqlserver_ext.sp_send_dbmail` procédure du pack d'extension émule la `msdb.dbo.sp_send_dbmail` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_delete_mailitems_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_delete_mailitems_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_add_profile_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_add_profile_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_add_account_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_add_account_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_add_profileaccount_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_add_profileaccount_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_help_profile_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_help_profile_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_update_profile_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_update_profile_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_delete_profile_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_delete_profile_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_help_account_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_help_account_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_update_account_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_update_account_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_delete_account_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_delete_account_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_help_profileaccount_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_help_profileaccount_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_update_profileaccount_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_update_profileaccount_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
La `aws_sqlserver_ext.sysmail_delete_profileaccount_sp` procédure du pack d'extension émule la `msdb.dbo.sysmail_delete_profileaccount_sp` procédure. Pour plus d'informations sur la procédure source de courrier de base de données SQL Server, consultez [la documentation technique 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
```
## Exemples d'utilisation de procédures qui émulent le courrier de base de données SQL Server dans PostgreSQL
Pour envoyer un e-mail, suivez la `aws_sqlserver_ext.sp_send_dbmail` procédure ci-dessous.
```
PERFORM sp_send_dbmail (
par_profile_name := 'Administrator',
par_recipients := 'hello@rusgl.info',
par_subject := 'Automated Success Message',
par_body := 'The stored procedure finished'
);
```
L'exemple suivant montre comment envoyer un e-mail contenant les résultats d'une requête.
```
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'
);
```
L'exemple suivant montre comment envoyer un e-mail avec du code 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'
);
```
Pour supprimer des e-mails, suivez la `aws_sqlserver_ext.sysmail_delete_mailitems_sp` procédure ci-dessous.
```
DECLARE var_GETDATE datetime;
SET var_GETDATE = NOW();
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := var_GETDATE
);
```
L'exemple suivant montre comment supprimer les e-mails les plus anciens.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_before := '31.12.2015'
);
```
L'exemple suivant montre comment supprimer tous les e-mails qui ne peuvent pas être envoyés.
```
PERFORM sysmail_delete_mailitems_sp (
par_sent_status := 'failed'
);
```
Pour créer un nouveau profil utilisateur, suivez la `aws_sqlserver_ext.sysmail_add_profile_sp` procédure décrite ci-dessous.
```
PERFORM sysmail_add_profile_sp (
profile_name := 'Administrator',
par_description := 'administrative mail'
);
```
L'exemple suivant montre comment créer un nouveau profil et enregistrer l'identifiant de profil unique dans une 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;
```
Pour créer un nouveau compte de messagerie, suivez la `aws_sqlserver_ext.sysmail_add_account_sp` procédure ci-dessous.
```
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'
);
```
Pour ajouter un compte e-mail au profil utilisateur, suivez la `aws_sqlserver_ext.sysmail_add_profileaccount_sp` procédure ci-dessous.
```
PERFORM sysmail_add_profileaccount_sp (
par_account_name := 'Administrator',
par_account_name := 'Audit Account',
par_sequence_number := 1
);
```
## Exemples d'utilisation pour émuler SQL Server Database Mail dans PostgreSQL
Si le code de votre base de données source utilise SQL Server Database Mail pour envoyer des e-mails, vous pouvez utiliser le pack d' AWS SCT extension pour convertir ce code en PostgreSQL.
**Pour envoyer un e-mail depuis votre base de données PostgreSQL**
1. Créez et configurez votre AWS Lambda fonction.
1. Appliquez le pack d' AWS SCT extension.
1. Créez un profil utilisateur à l'aide de la `sysmail_add_profile_sp` fonction illustrée ci-dessous.
1. Créez un compte e-mail à l'aide de la `sysmail_add_account_sp` fonction illustrée ci-dessous.
1. Ajoutez ce compte e-mail à votre profil utilisateur à l'aide de la `sysmail_add_profileaccount_sp` fonction illustrée ci-dessous.
```
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. Envoyez un e-mail à l'aide de la `sp_send_dbmail` fonction illustrée ci-dessous.
```
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;
```
Pour consulter les informations relatives à tous les profils utilisateur, suivez la `sysmail_help_profile_sp` procédure décrite ci-dessous.
```
SELECT FROM aws_sqlserver_ext.sysmail_help_profile_sp();
```
L'exemple suivant affiche les informations relatives au profil utilisateur spécifique.
```
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');
```
Pour consulter les informations relatives à tous les comptes de messagerie, suivez la `sysmail_help_account_sp` procédure ci-dessous.
```
select from aws_sqlserver_ext.sysmail_help_account_sp();
```
L'exemple suivant affiche les informations relatives au compte de messagerie spécifique.
```
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');
```
Pour consulter les informations relatives à tous les comptes de messagerie associés aux profils utilisateur, suivez la `sysmail_help_profileaccount_sp` procédure décrite ci-dessous.
```
select from aws_sqlserver_ext.sysmail_help_profileaccount_sp();
```
L'exemple suivant filtre les enregistrements par identifiant, nom de profil ou nom de compte.
```
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');
```
Pour modifier le nom ou la description du profil utilisateur, suivez la `sysmail_update_profile_sp` procédure ci-dessous.
```
select aws_sqlserver_ext.sysmail_update_profile_sp(
par_profile_id := 2,
par_profile_name := 'New profile name'
);
```
Pour modifier les paramètres du compte de messagerie, suivez la `ysmail_update_account_sp` procédure décrite ci-dessous.
```
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'
);
```
# Migration de SQL Server vers Amazon RDS for SQL Server avec AWS Schema Conversion Tool
Éléments à prendre en compte lors de la migration d'un schéma et de code SQL Server vers Amazon RDS pour SQL Server :
+ AWS SCT peut convertir l'agent SQL Server pour fournir des plannings, des alertes et des tâches sur une instance de base de données Amazon RDS for SQL Server. Après la conversion, vous pouvez utiliser une instance de base de données Amazon RDS pour SQL Server avec SQL Server Reporting Service (SSRS), SQL Server Analysis Services (SSAS) et SQL Server Integration Services (SSIS).
+ Actuellement, Amazon RDS ne prend pas en charge les points de terminaison T-SQL supplémentaires ou SQL Server Service Broker qui nécessitent que vous exécutiez la commande CREATE ENDPOINT.
+ Amazon RDS offre une prise en charge limitée des serveurs associés. Lors de la conversion du code d'application SQL Server qui utilise des serveurs liés, AWS SCT convertit le code de l'application. Toutefois, assurez-vous de vérifier le comportement des objets qui utilisent des serveurs liés avant d'exécuter le code converti.
+ Always-On est utilisé.
+ Le rapport AWS SCT d'évaluation fournit les indicateurs du serveur pour la conversion. Ces metrics sur votre instance SQL Server sont les suivantes :
+ La mise en miroir de données est utilisée.
+ L'envoi de journaux SQL Server est configuré.
+ Un cluster de basculement est utilisé.
+ La messagerie de base de données est configurée.
+ Le service de recherche en texte intégral est utilisé. Amazon RDS pour SQL Server possède une recherche en texte intégral limitée et ne prend pas en charge les recherches sémantiques.
+ Data Quality Service (DQS) est installé. Amazon RDS ne prend pas en charge DQS. Nous vous recommandons donc d'installer SQL Server sur une instance Amazon EC2.
## Privilèges pour RDS for SQL Server en tant que cible
Pour migrer vers RDS pour SQL Server, créez un utilisateur de base de données, puis accordez les privilèges requis pour chaque base de données. Vous pouvez utiliser l'exemple de code suivant.
```
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;
```
Dans l'exemple précédent, remplacez *user\$1name* par le nom de votre utilisateur. Remplacez ensuite *db\$1name* par le nom de votre base de données cible. Enfin, remplacez-le *your\$1password* par un mot de passe sécurisé.