Migrieren Sie Legacy-Anwendungen von Oracle Pro*C zu ECPG - AWS Prescriptive Guidance
ÜbersichtVoraussetzungen und EinschränkungenToolsEpenZugehörige RessourcenZusätzliche Informationen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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

Erstellt von Sai Parthasaradhi (AWS) und Mahesh Balumuri (AWS)

Umgebung: PoC oder Pilotprojekt

Quelle: Oracle

Ziel: PostgreSQL

R-Typ: Re-Architect

Arbeitslast: Oracle

Technologien: Migration; Datenbanken

Übersicht

Die meisten älteren Anwendungen mit eingebettetem SQL-Code verwenden den Oracle Pro*C-Precompiler für den Zugriff auf die Datenbank. Wenn Sie diese Oracle-Datenbanken zu Amazon Relational Database Service (Amazon RDS) for PostgreSQL oder Amazon Aurora PostgreSQL-Compatible Edition migrieren, müssen Sie Ihren Anwendungscode in ein Format konvertieren, das mit dem Precompiler in PostgreSQL kompatibel ist, das als ECPG bezeichnet wird. Dieses Muster beschreibt, wie Oracle Pro*C-Code in sein Äquivalent in PostgreSQL ECPG konvertiert wird. 

Weitere Informationen zu Pro*C finden Sie in der Oracle-Dokumentation. Eine kurze Einführung in ECPG finden Sie im Abschnitt Zusätzliche Informationen.

Voraussetzungen und Einschränkungen

Voraussetzungen

  • Ein aktives AWS-Konto

  • Eine Amazon RDS for PostgreSQL- oder Aurora PostgreSQL-kompatible Datenbank

  • Eine Oracle-Datenbank, die lokal läuft

Tools

  • Die im nächsten Abschnitt aufgeführten PostgreSQL-Pakete.

  • AWS CLI — Die AWS-Befehlszeilenschnittstelle (AWS CLI) ist ein Open-Source-Tool für die Interaktion mit AWS-Services über Befehle in Ihrer Befehlszeilen-Shell. Mit minimaler Konfiguration können Sie AWS-CLI-Befehle, die Funktionen implementieren, die denen entsprechen, die von der browserbasierten AWS-Managementkonsole bereitgestellt werden, von einer Befehlszeile aus ausführen.

Epen

AufgabeBeschreibungErforderliche Fähigkeiten
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
App-Entwickler, Ingenieur DevOps
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/
App-Entwickler, DevOps Ingenieur
Konfigurieren Sie die Umgebungspfadvariable.

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

export PATH=$PATH:/usr/pgsql-12/bin
App-Entwickler, Ingenieur DevOps
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
App-Entwickler, DevOps Ingenieur
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
App-Entwickler, DevOps Ingenieur
Identifizieren Sie die Programme, die konvertiert werden sollen.

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

App-Entwickler, App-Besitzer
AufgabeBeschreibungErforderliche Fähigkeiten
Entfernen Sie unerwünschte Header.

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

App-Besitzer, App-Entwickler
Aktualisieren Sie die Variablendeklarationen.

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);
App-Entwickler, App-Besitzer
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;
App-Entwickler, App-Besitzer
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;
}
App-Entwickler, App-Besitzer
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;
App-Entwickler, App-Besitzer
Ä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;
App-Entwickler, App-Besitzer
Ä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;
}
App-Entwickler, App-Besitzer
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;
App-Entwickler, App-Besitzer
Wenden Sie gängige Migrationsmuster an.

  • Ändern Sie SQL-Abfragen so, dass sie mit PostgreSQL kompatibel sind.

  • Verschieben Sie anonyme Blöcke, wenn sie in ECPG nicht unterstützt werden, in die Datenbank.

  • Entfernen Sie die dbms_application_info Logik, die von PostgreSQL nicht unterstützt wird.

  • Verschiebt die EXEC SQL COMMIT Anweisungen, nachdem der Cursor geschlossen wurde. Wenn Sie Abfragen ausführen, während Sie sich in der Schleife befinden, um die Datensätze vom Cursor abzurufen, wird der Cursor geschlossen und die Fehlermeldung Cursor existiert nicht angezeigt.

  • Informationen zur Behandlung von Ausnahmen in ECPG und Fehlercodes finden Sie unter Fehlerbehandlung in der PostgreSQL-Dokumentation.

App-Entwickler, App-Besitzer
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);
App-Entwickler, App-Besitzer
AufgabeBeschreibungErforderliche Fähigkeiten
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
App-Entwickler, App-Besitzer
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)
App-Entwickler, App-Besitzer
AufgabeBeschreibungErforderliche Fähigkeiten
Testen Sie den Code.

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

App-Entwickler, App-Besitzer, Testingenieur

Zugehörige Ressourcen

Zusätzliche Informationen

PostgreSQL hat einen eingebetteten SQL-Precompiler, ECPG, der dem Oracle Pro*C-Precompiler entspricht. ECPG konvertiert C-Programme mit eingebetteten SQL-Anweisungen in Standard-C-Code, indem es die SQL-Aufrufe durch spezielle Funktionsaufrufen ersetzt. Die Ausgabedateien können dann mit jeder C-Compiler-Toolchain verarbeitet werden.

Eingabe- und Ausgabedateien

ECPG konvertiert jede Eingabedatei, die Sie in der Befehlszeile angeben, in die entsprechende C-Ausgabedatei. Wenn ein Eingabedateiname keine Dateierweiterung hat, wird .pgc angenommen. Die Erweiterung der Datei wird durch ersetzt, .c um den Namen der Ausgabedatei zu erstellen. Sie können jedoch den Standardnamen der Ausgabedatei überschreiben, indem Sie die -o Option verwenden.

Wenn Sie einen Bindestrich (-) als Namen der Eingabedatei verwenden, liest ECPG das Programm aus der Standardeingabe und schreibt in die Standardausgabe, sofern Sie dies nicht mit der -o Option überschreiben.

Header-Dateien

Wenn der PostgreSQL-Compiler die vorverarbeiteten C-Codedateien kompiliert, sucht er im PostgreSQL-Verzeichnis nach den ECPG-Header-Dateien. include Daher müssen Sie möglicherweise die -I Option verwenden, um den Compiler auf das richtige Verzeichnis zu verweisen (z. B.). -I/usr/local/pgsql/include

Bibliotheken

Programme, die C-Code mit Embedded SQL verwenden, müssen mit der libecpg Bibliothek verknüpft werden. Sie können beispielsweise die Linker-Optionen  -L/usr/local/pgsql/lib -lecpg verwenden.

Konvertierte ECPG-Anwendungen rufen Funktionen in der libpq Bibliothek über die Embedded SQL-Bibliothek (ecpglib) auf und kommunizieren mit dem PostgreSQL-Server unter Verwendung des Standard-Frontend-/Backend-Protokolls.