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.

# Migrer les applications existantes d'Oracle Pro\*C vers ECPG
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg"></a>

*Sai Parthasaradhi et Mahesh Balumuri, Amazon Web Services*

## Résumé
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-summary"></a>

La plupart des applications existantes qui intègrent du code SQL utilisent le précompilateur Oracle Pro\*C pour accéder à la base de données. Lorsque vous migrez ces bases de données Oracle vers Amazon Relational Database Service (Amazon RDS) pour PostgreSQL ou Amazon Aurora PostgreSQL Compatible Edition, vous devez convertir le code de votre application dans un format compatible avec le précompilateur de PostgreSQL, appelé ECPG. Ce modèle décrit comment convertir le code Oracle Pro\*C en son équivalent dans PostgreSQL ECPG. 

Pour plus d'informations sur Pro\*C, consultez la documentation [Oracle](https://docs.oracle.com/cd/E11882_01/appdev.112/e10825/pc_01int.htm#i2415). Pour une brève introduction à l'ECPG, consultez la section [Informations supplémentaires](#migrate-legacy-applications-from-oracle-pro-c-to-ecpg-additional).

## Conditions préalables et limitations
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-prereqs"></a>

**Conditions préalables**
+ Un compte AWS actif
+ Une base de données compatible avec Amazon RDS for PostgreSQL ou Aurora PostgreSQL
+ Une base de données Oracle exécutée sur site

## Outils
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-tools"></a>
+ Les packages PostgreSQL répertoriés dans la section suivante.
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) — L'interface de ligne de commande AWS (AWS CLI) est un outil open source permettant d'interagir avec les services AWS par le biais de commandes dans votre shell de ligne de commande. Avec une configuration minimale, vous pouvez exécuter des commandes de l'interface de ligne de commande AWS qui mettent en œuvre des fonctionnalités équivalentes à celles fournies par la console de gestion AWS basée sur un navigateur à partir d'une invite de commande.

## Épopées
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-epics"></a>

### Définissez l'environnement de génération sur CentOS ou RHEL
<a name="set-the-build-environment-on-centos-or-rhel"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Installez les packages PostgreSQL. | Installez les packages PostgreSQL requis à l'aide des commandes suivantes.<pre>yum update -y<br />yum install -y yum-utils<br />rpm -ivh https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm<br />dnf -qy module disable postgresql</pre> | Développeur d'applications, DevOps ingénieur | 
| Installez les fichiers d'en-tête et les bibliothèques. | Installez le `postgresql12-devel` package, qui contient les fichiers d'en-tête et les bibliothèques, à l'aide des commandes suivantes. Installez le package dans les environnements de développement et d'exécution pour éviter les erreurs dans l'environnement d'exécution.<pre>dnf -y install postgresql12-devel<br />yum install ncompress zip ghostscript jq unzip wget git -y</pre><br />Pour l'environnement de développement uniquement, exécutez également les commandes suivantes.<pre>yum install zlib-devel make -y<br />ln -s /usr/pgsql-12/bin/ecpg /usr/bin/</pre> | Développeur d'applications, DevOps ingénieur | 
| Configurez la variable de chemin d'environnement. | Définissez le chemin d'environnement pour les bibliothèques clientes PostgreSQL.<pre>export PATH=$PATH:/usr/pgsql-12/bin</pre> | Développeur d'applications, DevOps ingénieur | 
| Installez des logiciels supplémentaires si nécessaire. | Si nécessaire, installez **pgLoader en** remplacement de **SQL\*Loader** dans Oracle.<pre>wget -O /etc/yum.repos.d/pgloader-ccl.repo https://dl.packager.io/srv/opf/pgloader-ccl/master/installer/el/7.repo<br />yum install pgloader-ccl -y<br />ln -s /opt/pgloader-ccl/bin/pgloader /usr/bin/</pre><br />Si vous appelez des applications Java à partir de modules Pro\*C, installez Java.<pre>yum install java -y</pre><br />Installez **ant** pour compiler le code Java.<pre>yum install ant -y</pre> | Développeur d'applications, DevOps ingénieur | 
| Installez l'AWS CLI. | Installez l'interface de ligne de commande AWS pour exécuter des commandes afin d'interagir avec les services AWS tels qu'AWS Secrets Manager et Amazon Simple Storage Service (Amazon S3) depuis vos applications.<pre>cd /tmp/<br />curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"<br />unzip awscliv2.zip<br />./aws/install -i /usr/local/aws-cli -b /usr/local/bin --update</pre> | Développeur d'applications, DevOps ingénieur | 
| Identifiez les programmes à convertir. | Identifiez les applications que vous souhaitez convertir de Pro\*C en ECPG. | Développeur d'applications, propriétaire de l'application | 

### Convertir le code Pro\*C en ECPG
<a name="convert-pro-c-code-to-ecpg"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Supprimez les en-têtes indésirables. | Supprimez `include ` les en-têtes qui ne sont pas obligatoires dans PostgreSQL, tels que`oci.h`, et. `oratypes` `sqlda` | Propriétaire de l'application, développeur de l'application | 
| Mettez à jour les déclarations de variables. | Ajoutez `EXEC SQL` des instructions pour toutes les déclarations de variables utilisées comme variables hôtes.<br />Supprimez les `EXEC SQL VAR` déclarations telles que les suivantes de votre application.<pre>EXEC SQL VAR query IS STRING(2048);</pre> | Développeur d'applications, propriétaire de l'application | 
| Mettez à jour la fonctionnalité ROWNUM. | La `ROWNUM` fonction n'est pas disponible dans PostgreSQL. Remplacez-la par la fonction de `ROW_NUMBER` fenêtre dans les requêtes SQL.<br />Code Pro\*C :<pre>SELECT SUBSTR(RTRIM(FILE_NAME,'.txt'),12) INTO :gcpclFileseq  <br />FROM   (SELECT FILE_NAME <br />FROM  DEMO_FILES_TABLE <br />WHERE FILE_NAME    LIKE '%POC%' <br />ORDER BY FILE_NAME DESC) FL2 <br />WHERE ROWNUM <=1 ORDER BY ROWNUM;</pre><br />Code ECPG :<pre>SELECT SUBSTR(RTRIM(FILE_NAME,'.txt'),12) INTO :gcpclFileseq  <br />FROM   (SELECT FILE_NAME , ROW_NUMBER() OVER (ORDER BY FILE_NAME DESC) AS ROWNUM<br />FROM  demo_schema.DEMO_FILES_TABLE <br />WHERE FILE_NAME    LIKE '%POC%'<br />ORDER BY FILE_NAME DESC) FL2 <br />WHERE ROWNUM <=1 ORDER BY ROWNUM; </pre> | Développeur d'applications, propriétaire de l'application | 
| Mettez à jour les paramètres de la fonction pour utiliser des variables d'alias. | Dans PostgreSQL, les paramètres des fonctions ne peuvent pas être utilisés comme variables hôtes. Remplacez-les en utilisant une variable d'alias.<br />Code Pro\*C :<pre>int processData(int referenceId){<br />  EXEC SQL char col_val[100];<br />  EXEC SQL select column_name INTO :col_val from table_name where col=:referenceId;<br />}</pre><br />Code ECPG :<pre>int processData(int referenceIdParam){<br />  EXEC SQL int referenceId = referenceIdParam;<br />  EXEC SQL char col_val[100];<br />  EXEC SQL select column_name INTO :col_val from table_name where col=:referenceId;<br />}</pre> | Développeur d'applications, propriétaire de l'application | 
| Mettez à jour les types de structure. | Définissez les `struct` types `EXEC SQL BEGIN` et les `END` blocs avec `typedef` si les variables `struct` de type sont utilisées comme variables hôtes. Si les `struct` types sont définis dans des fichiers d'en-tête (`.h`), incluez les fichiers avec des instructions `EXEC SQL` include.<br />Code Pro\*C :<br />Fichier d'en-tête (`demo.h`)<pre>struct s_partition_ranges<br />{<br /> char   sc_table_group[31];<br /> char   sc_table_name[31];<br /> char   sc_range_value[10];<br />}; <br />struct s_partition_ranges_ind<br />{<br />  short    ss_table_group;<br />  short    ss_table_name;<br />  short    ss_range_value;<br />}; </pre><br />Code ECPG :<br />Fichier d'en-tête (`demo.h`)<pre>EXEC SQL BEGIN DECLARE SECTION;<br />typedef struct <br />{<br />  char   sc_table_group[31];<br />  char   sc_table_name[31];<br />  char   sc_range_value[10];<br />} s_partition_ranges; <br />typedef struct <br />{<br />  short    ss_table_group;<br />  short    ss_table_name;<br />  short    ss_range_value;<br />} s_partition_ranges_ind; <br />EXEC SQL END DECLARE SECTION;</pre><br />Fichier Pro\*C () `demo.pc`<pre>#include "demo.h"<br />struct s_partition_ranges gc_partition_data[MAX_PART_TABLE] ;<br />struct s_partition_ranges_ind gc_partition_data_ind[MAX_PART_TABLE] ;</pre><br />Fichier ECPG () `demo.pc`<pre>exec sql include "demo.h"<br />EXEC SQL BEGIN DECLARE SECTION;<br />s_partition_ranges gc_partition_data[MAX_PART_TABLE] ;<br />s_partition_ranges_ind gc_partition_data_ind[MAX_PART_TABLE] ;<br />EXEC SQL END DECLARE SECTION;</pre> | Développeur d'applications, propriétaire de l'application | 
| Modifiez la logique à récupérer à partir des curseurs. | Pour récupérer plusieurs lignes à partir de curseurs à l'aide de variables de tableau, modifiez le code à utiliser. `FETCH FORWARD`<br />Code Pro\*C :<pre>EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];<br />EXEC SQL FETCH filename_cursor into :aPoeFiles;</pre><br />Code ECPG :<pre>EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];<br />EXEC SQL int fetchSize = MAX_FILES;<br />EXEC SQL FETCH FORWARD :fetchSize filename_cursor into :aPoeFiles;</pre> | Développeur d'applications, propriétaire de l'application | 
| Modifiez les appels de packages qui n'ont pas de valeur de retour. | Les fonctions de package Oracle qui n'ont pas de valeurs de retour doivent être appelées avec une variable indicatrice. Si votre application inclut plusieurs fonctions portant le même nom ou si les fonctions de type inconnu génèrent des erreurs d'exécution, transformez les valeurs en types de données.<br />Code Pro\*C :<pre>void ProcessData (char *data , int id)<br />{        <br />        EXEC SQL EXECUTE<br />               BEGIN<br />                  pkg_demo.process_data (:data, :id);                                                                                    <br />               END;<br />       END-EXEC;<br />}</pre><br />Code ECPG :<pre>void ProcessData (char *dataParam, int idParam )<br />{<br />        EXEC SQL char *data = dataParam;<br />        EXEC SQL int id = idParam;<br />        EXEC SQL short rowInd;<br />        EXEC SQL short rowInd = 0;<br />        EXEC SQL SELECT pkg_demo.process_data (<br />                       inp_data => :data::text,<br />                       inp_id => :id<br />               ) INTO :rowInd;<br />}</pre> | Développeur d'applications, propriétaire de l'application | 
| Réécrivez les variables SQL\_CURSOR. | Réécrivez la `SQL_CURSOR` variable et son implémentation.<br />Code Pro\*C :<pre>/* SQL Cursor */<br />SQL_CURSOR      demo_cursor;<br />EXEC SQL ALLOCATE :demo_cursor;<br />EXEC SQL EXECUTE<br />  BEGIN<br />      pkg_demo.get_cursor(     <br />        demo_cur=>:demo_cursor<br />      );<br />  END;<br />END-EXEC;</pre><br />Code ECPG :<pre>EXEC SQL DECLARE demo_cursor CURSOR FOR SELECT<br />         * from<br />    pkg_demo.open_filename_rc(<br />            demo_cur=>refcursor<br />          ) ;<br />EXEC SQL char open_filename_rcInd[100]; <br /># As the below function returns cursor_name as <br /># return we need to use char[] type as indicator. <br />EXEC SQL SELECT pkg_demo.get_cursor (<br />        demo_cur=>'demo_cursor'<br />    ) INTO :open_filename_rcInd;</pre> | Développeur d'applications, propriétaire de l'application | 
| Appliquez des modèles de migration courants. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-legacy-applications-from-oracle-pro-c-to-ecpg.html) | Développeur d'applications, propriétaire de l'application | 
| Activez le débogage, si nécessaire.  | Pour exécuter le programme ECPG en mode debug, ajoutez la commande suivante dans le bloc fonctionnel principal.<pre>ECPGdebug(1, stderr); </pre> | Développeur d'applications, propriétaire de l'application | 

### Compiler des programmes ECPG
<a name="compile-ecpg-programs"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Créez un fichier exécutable pour ECPG. | Si vous avez nommé un fichier source Embedded SQL C`prog1.pgc`, vous pouvez créer un programme exécutable à l'aide de la séquence de commandes suivante.<pre>ecpg prog1.pgc<br />cc -I/usr/local/pgsql/include -c prog1.c<br />cc -o prog1 prog1.o -L/usr/local/pgsql/lib -lecpg</pre> | Développeur d'applications, propriétaire de l'application | 
| Créez un fichier make pour la compilation. | Créez un fichier make pour compiler le programme ECPG, comme indiqué dans l'exemple de fichier suivant.<pre>CFLAGS ::= $(CFLAGS) -I/usr/pgsql-12/include -g -Wall<br />LDFLAGS ::= $(LDFLAGS) -L/usr/pgsql-12/lib -Wl,-rpath,/usr/pgsql-12/lib<br />LDLIBS ::= $(LDLIBS) -lecpg<br />PROGRAMS = test <br />.PHONY: all clean<br />%.c: %.pgc<br />      ecpg $<<br />all: $(PROGRAMS)<br />clean:<br />    rm -f $(PROGRAMS) $(PROGRAMS:%=%.c) $(PROGRAMS:%=%.o)</pre> | Développeur d'applications, propriétaire de l'application | 

### Tester l'application
<a name="test-the-application"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Testez le code. | Testez le code d'application converti pour vous assurer qu'il fonctionne correctement. | Développeur d'applications, propriétaire de l'application, ingénieur de test | 

## Ressources connexes
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-resources"></a>
+ [ECPG - SQL intégré en C (documentation](https://www.postgresql.org/docs/current/static/ecpg.html) PostgreSQL)
+ [Gestion des erreurs](https://www.postgresql.org/docs/12/ecpg-errors.html) (documentation PostgreSQL)
+ [Pourquoi utiliser le précompilateur Oracle Pro\*C/C\+\+ (](https://docs.oracle.com/cd/E11882_01/appdev.112/e10825/pc_01int.htm#i2415)documentation Oracle)

## Informations supplémentaires
<a name="migrate-legacy-applications-from-oracle-pro-c-to-ecpg-additional"></a>

PostgreSQL possède un précompilateur SQL intégré, ECPG, équivalent au précompilateur Oracle Pro\*C. ECPG convertit les programmes C contenant des instructions SQL intégrées en code C standard en remplaçant les appels SQL par des appels de fonction spéciaux. Les fichiers de sortie peuvent ensuite être traités avec n'importe quelle chaîne d'outils de compilation C.

**Fichiers d'entrée et de sortie**

ECPG convertit chaque fichier d'entrée que vous spécifiez sur la ligne de commande en fichier de sortie C correspondant. Si le nom d'un fichier d'entrée n'a pas d'extension de fichier, .pgc est supposé. L'extension du fichier est remplacée par `.c` pour construire le nom du fichier de sortie. Cependant, vous pouvez remplacer le nom du fichier de sortie par défaut en utilisant l'`-o`option.

Si vous utilisez un tiret (`-`) comme nom de fichier d'entrée, ECPG lit le programme depuis l'entrée standard et écrit sur la sortie standard, sauf si vous le remplacez en utilisant l'`-o`option.

**Fichiers d'en-tête**

Lorsque le compilateur PostgreSQL compile les fichiers de code C prétraités, il recherche les fichiers d'en-tête ECPG dans le répertoire PostgreSQL. `include` Par conséquent, vous devrez peut-être utiliser l'`-I`option pour pointer le compilateur vers le bon répertoire (par exemple,`-I/usr/local/pgsql/include`).

**Bibliothèques**

Les programmes qui utilisent le code C avec Embedded SQL doivent être liés à la `libecpg` bibliothèque. Par exemple, vous pouvez utiliser les options ` -L/usr/local/pgsql/lib -lecpg` de l'éditeur de liens.

Les applications ECPG converties appellent des fonctions de la `libpq` bibliothèque via la bibliothèque Embedded SQL (`ecpglib`) et communiquent avec le serveur PostgreSQL en utilisant le protocole standard. frontend/backend