Migrieren Sie Legacy-Anwendungen von Oracle Pro*C zu ECPG

Installieren Sie PostgreSQL-Pakete.

Installieren Sie die erforderlichen PostgreSQL-Pakete mithilfe der folgenden Befehle.

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

Installieren Sie die Header-Dateien und Bibliotheken.

Installieren Sie das postgresql12-devel Paket, das Header-Dateien und Bibliotheken enthält, mithilfe der folgenden Befehle. Installieren Sie das Paket sowohl in der Entwicklungs- als auch in der Laufzeitumgebung, um Fehler in der Laufzeitumgebung zu vermeiden.

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

Führen Sie nur für die Entwicklungsumgebung auch die folgenden Befehle aus.

yum install zlib-devel make -y
ln -s /usr/pgsql-12/bin/ecpg /usr/bin/

Konfigurieren Sie die Umgebungspfadvariable.

Legen Sie den Umgebungspfad für PostgreSQL-Clientbibliotheken fest.

export PATH=$PATH:/usr/pgsql-12/bin

Installieren Sie bei Bedarf zusätzliche Software.

Falls erforderlich, installieren Sie PGLoader als Ersatz für SQL*Loader in 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/

Wenn Sie Java-Anwendungen von Pro*C-Modulen aus aufrufen, installieren Sie Java.

yum install java -y

Installieren Sie Ant, um den Java-Code zu kompilieren.

yum install ant -y

Installieren Sie den AWS CLI.

Installieren Sie die AWS-CLI, um Befehle zur Interaktion mit AWS-Services wie AWS Secrets Manager und Amazon Simple Storage Service (Amazon S3) von Ihren Anwendungen aus auszuführen.

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

Identifizieren Sie die Programme, die konvertiert werden sollen.

Identifizieren Sie die Anwendungen, die Sie von Pro*C nach ECPG konvertieren möchten.

Unerwünschte Header entfernen.

Entfernen Sie die include Header, die in PostgreSQL nicht erforderlich sind, wieoci.h, undoratypes. sqlda

Variablendeklarationen aktualisieren.

Fügen Sie EXEC SQL Anweisungen für alle Variablendeklarationen hinzu, die als Hostvariablen verwendet werden.

Entfernen Sie die EXEC SQL VAR Deklarationen wie die folgenden aus Ihrer Anwendung.

EXEC SQL VAR query IS STRING(2048);

Aktualisieren Sie die ROWNUM-Funktionalität.

Die ROWNUM Funktion ist in PostgreSQL nicht verfügbar. Ersetzen Sie dies in SQL-Abfragen durch die ROW_NUMBER Fensterfunktion.

Pro*C-Code:

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;

ECPG-Kode:

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; 

Aktualisieren Sie die Funktionsparameter, um Aliasvariablen zu verwenden.

In PostgreSQL können Funktionsparameter nicht als Hostvariablen verwendet werden. Überschreiben Sie sie mithilfe einer Aliasvariablen.

Pro*C-Code:

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

ECPG-Kode:

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;
}

Aktualisieren Sie die Strukturtypen.

Definieren Sie struct Typen in EXEC SQL BEGIN und END Blöcke mittypedef, wenn die struct Typvariablen als Hostvariablen verwendet werden. Wenn die struct Typen in Header (.h) -Dateien definiert sind, schließen Sie die Dateien mit EXEC SQL Include-Anweisungen ein.

Pro*C-Code:

Header-Datei () 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;
}; 

ECPG-Code:

Header-Datei () 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;

Pro*C-Datei () 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] ;

ECPG-Datei () 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;

Ändern Sie die Logik, um von Cursorn abzurufen.

Um mithilfe von Array-Variablen mehrere Zeilen aus Cursorn abzurufen, ändern Sie den zu verwendenden Code. FETCH FORWARD

Pro*C-Code:

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

ECPG-Kode:

EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];
EXEC SQL int fetchSize = MAX_FILES;
EXEC SQL FETCH FORWARD :fetchSize filename_cursor into :aPoeFiles;

Ändern Sie Paketaufrufe, die keine Rückgabewerte haben.

Oracle-Paketfunktionen, die keine Rückgabewerte haben, sollten mit einer Indikatorvariablen aufgerufen werden. Wenn Ihre Anwendung mehrere Funktionen mit demselben Namen enthält oder wenn die Funktionen unbekannter Typen Laufzeitfehler erzeugen, typisieren Sie die Werte in die Datentypen.

Pro*C-Code:

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

ECPG-Kode:

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;
}

Schreiben Sie SQL_CURSOR-Variablen neu.

Schreiben Sie die SQL_CURSOR Variable und ihre Implementierung neu.

Pro*C-Code:

/* 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;

ECPG-Kode:

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;

Wenden Sie gängige Migrationsmuster an.

Aktivieren Sie das Debugging, falls erforderlich.

Um das ECPG-Programm im Debug-Modus auszuführen, fügen Sie dem Hauptfunktionsblock den folgenden Befehl hinzu.

ECPGdebug(1, stderr); 

Erstellen Sie eine ausführbare Datei für ECPG.

Wenn Sie eine eingebettete SQL C-Quelldatei mit dem Namen habenprog1.pgc, können Sie mithilfe der folgenden Befehlsfolge ein ausführbares Programm erstellen.

ecpg prog1.pgc
cc -I/usr/local/pgsql/include -c prog1.c
cc -o prog1 prog1.o -L/usr/local/pgsql/lib -lecpg

Erstellen Sie eine Make-Datei für die Kompilierung.

Erstellen Sie eine Make-Datei, um das ECPG-Programm zu kompilieren, wie in der folgenden Beispieldatei gezeigt.

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)

Testen Sie den Code.

Testen Sie den konvertierten Anwendungscode, um sicherzustellen, dass er ordnungsgemäß funktioniert.