Migrer les applications existantes d'Oracle Pro*C vers ECPG - Recommandations AWS
RécapitulatifConditions préalables et limitationsOutilsÉpopéesRessources connexesInformations supplémentaires

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

Créée par Sai Parthasaradhi (AWS) et Mahesh Balumuri (AWS)

Environnement : PoC ou pilote

Source : Oracle

Cible : PostgreSQL

Type R : Ré-architecte

Charge de travail : Oracle

Technologies : migration ; bases de données

Récapitulatif

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. Pour une brève introduction à l'ECPG, consultez la section Informations supplémentaires.

Conditions préalables et limitations

Prérequis

  • 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

  • Les packages PostgreSQL répertoriés dans la section suivante.

  • AWS CLI — 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

TâcheDescriptionCompétences requises
Installez les packages PostgreSQL.

Installez les packages PostgreSQL requis à l'aide des commandes suivantes.

yum update -y
yum install -y yum-utils
rpm -ivh https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm
dnf -qy module disable postgresql
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.

dnf -y install postgresql12-devel
yum install ncompress zip ghostscript jq unzip wget git -y

Pour l'environnement de développement uniquement, exécutez également les commandes suivantes.

yum install zlib-devel make -y
ln -s /usr/pgsql-12/bin/ecpg /usr/bin/
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.

export PATH=$PATH:/usr/pgsql-12/bin
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.

wget -O /etc/yum.repos.d/pgloader-ccl.repo https://dl.packager.io/srv/opf/pgloader-ccl/master/installer/el/7.repo
yum install pgloader-ccl -y
ln -s /opt/pgloader-ccl/bin/pgloader /usr/bin/

Si vous appelez des applications Java à partir de modules Pro*C, installez Java.

yum install java -y

Installez ant pour compiler le code Java.

yum install ant -y
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.

cd /tmp/
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
./aws/install -i /usr/local/aws-cli -b /usr/local/bin --update
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
TâcheDescriptionCompétences requises
Supprimez les en-têtes indésirables.

Supprimez include les en-têtes qui ne sont pas obligatoires dans PostgreSQL, tels queoci.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.

Supprimez les EXEC SQL VAR déclarations telles que les suivantes de votre application.

EXEC SQL VAR query IS STRING(2048);
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.

Code Pro*C :

SELECT SUBSTR(RTRIM(FILE_NAME,'.txt'),12) INTO :gcpclFileseq  
FROM   (SELECT FILE_NAME 
FROM  DEMO_FILES_TABLE 
WHERE FILE_NAME    LIKE '%POC%' 
ORDER BY FILE_NAME DESC) FL2 
WHERE ROWNUM <=1 ORDER BY ROWNUM;

Code ECPG :

SELECT SUBSTR(RTRIM(FILE_NAME,'.txt'),12) INTO :gcpclFileseq  
FROM   (SELECT FILE_NAME , ROW_NUMBER() OVER (ORDER BY FILE_NAME DESC) AS ROWNUM
FROM  demo_schema.DEMO_FILES_TABLE 
WHERE FILE_NAME    LIKE '%POC%'
ORDER BY FILE_NAME DESC) FL2 
WHERE ROWNUM <=1 ORDER BY ROWNUM;
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.

Code Pro*C :

int processData(int referenceId){
  EXEC SQL char col_val[100];
  EXEC SQL select column_name INTO :col_val from table_name where col=:referenceId;
}

Code ECPG :

int processData(int referenceIdParam){
  EXEC SQL int referenceId = referenceIdParam;
  EXEC SQL char col_val[100];
  EXEC SQL select column_name INTO :col_val from table_name where col=:referenceId;
}
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.

Code Pro*C :

Fichier d'en-tête (demo.h)

struct s_partition_ranges
{
 char   sc_table_group[31];
 char   sc_table_name[31];
 char   sc_range_value[10];
}; 
struct s_partition_ranges_ind
{
  short    ss_table_group;
  short    ss_table_name;
  short    ss_range_value;
};

Code ECPG :

Fichier d'en-tête (demo.h)

EXEC SQL BEGIN DECLARE SECTION;
typedef struct 
{
  char   sc_table_group[31];
  char   sc_table_name[31];
  char   sc_range_value[10];
} s_partition_ranges; 
typedef struct 
{
  short    ss_table_group;
  short    ss_table_name;
  short    ss_range_value;
} s_partition_ranges_ind; 
EXEC SQL END DECLARE SECTION;

Fichier Pro*C () demo.pc

#include "demo.h"
struct s_partition_ranges gc_partition_data[MAX_PART_TABLE] ;
struct s_partition_ranges_ind gc_partition_data_ind[MAX_PART_TABLE] ;

Fichier ECPG () demo.pc

exec sql include "demo.h"
EXEC SQL BEGIN DECLARE SECTION;
s_partition_ranges gc_partition_data[MAX_PART_TABLE] ;
s_partition_ranges_ind gc_partition_data_ind[MAX_PART_TABLE] ;
EXEC SQL END DECLARE SECTION;
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

Code Pro*C :

EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];
EXEC SQL FETCH filename_cursor into :aPoeFiles;

Code ECPG :

EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];
EXEC SQL int fetchSize = MAX_FILES;
EXEC SQL FETCH FORWARD :fetchSize filename_cursor into :aPoeFiles;
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.

Code Pro*C :

void ProcessData (char *data , int id)
{        
        EXEC SQL EXECUTE
               BEGIN
                  pkg_demo.process_data (:data, :id);                                                                                    
               END;
       END-EXEC;
}

Code ECPG :

void ProcessData (char *dataParam, int idParam )
{
        EXEC SQL char *data = dataParam;
        EXEC SQL int id = idParam;
        EXEC SQL short rowInd;
        EXEC SQL short rowInd = 0;
        EXEC SQL SELECT pkg_demo.process_data (
                       inp_data => :data::text,
                       inp_id => :id
               ) INTO :rowInd;
}
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.

Code Pro*C :

/* SQL Cursor */
SQL_CURSOR      demo_cursor;
EXEC SQL ALLOCATE :demo_cursor;
EXEC SQL EXECUTE
  BEGIN
      pkg_demo.get_cursor(     
        demo_cur=>:demo_cursor
      );
  END;
END-EXEC;

Code ECPG :

EXEC SQL DECLARE demo_cursor CURSOR FOR SELECT
         * from
    pkg_demo.open_filename_rc(
            demo_cur=>refcursor
          ) ;
EXEC SQL char open_filename_rcInd[100]; 
# As the below function returns cursor_name as 
# return we need to use char[] type as indicator. 
EXEC SQL SELECT pkg_demo.get_cursor (
        demo_cur=>'demo_cursor'
    ) INTO :open_filename_rcInd;
Développeur d'applications, propriétaire de l'application
Appliquez des modèles de migration courants.

  • Modifiez les requêtes SQL afin qu'elles soient compatibles avec PostgreSQL.

  • Déplacez les blocs anonymes, lorsqu'ils ne sont pas pris en charge dans ECPG, vers la base de données.

  • Supprimez dbms_application_info la logique, qui n'est pas prise en charge par PostgreSQL.

  • Déplace EXEC SQL COMMIT les instructions après la fermeture du curseur. Si vous validez des requêtes alors que vous êtes dans la boucle pour récupérer les enregistrements à partir du curseur, le curseur est fermé et une erreur s'affiche.

  • Pour plus d'informations sur la gestion des exceptions dans ECPG et des codes d'erreur, consultez la section Gestion des erreurs dans la documentation de PostgreSQL.

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.

ECPGdebug(1, stderr);
Développeur d'applications, propriétaire de l'application
TâcheDescriptionCompétences requises
Créez un fichier exécutable pour ECPG.

Si vous avez nommé un fichier source Embedded SQL Cprog1.pgc, vous pouvez créer un programme exécutable à l'aide de la séquence de commandes suivante.

ecpg prog1.pgc
cc -I/usr/local/pgsql/include -c prog1.c
cc -o prog1 prog1.o -L/usr/local/pgsql/lib -lecpg
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.

CFLAGS ::= $(CFLAGS) -I/usr/pgsql-12/include -g -Wall
LDFLAGS ::= $(LDFLAGS) -L/usr/pgsql-12/lib -Wl,-rpath,/usr/pgsql-12/lib
LDLIBS ::= $(LDLIBS) -lecpg
PROGRAMS = test 
.PHONY: all clean
%.c: %.pgc
      ecpg $<
all: $(PROGRAMS)
clean:
    rm -f $(PROGRAMS) $(PROGRAMS:%=%.c) $(PROGRAMS:%=%.o)
Développeur d'applications, propriétaire de l'application
TâcheDescriptionCompé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

Informations supplémentaires

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'-ooption.

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'-ooption.

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'-Ioption 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 frontend/backend standard.