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
*Sai Parthasaradhi und Mahesh Balumuri, Amazon Web Services*
## Zusammenfassung
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.](https://docs.oracle.com/cd/E11882_01/appdev.112/e10825/pc_01int.htm#i2415) Eine kurze Einführung in ECPG finden Sie im Abschnitt [Zusätzliche](#migrate-legacy-applications-from-oracle-pro-c-to-ecpg-additional) 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) — 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 der von der browserbasierten AWS-Managementkonsole bereitgestellten Funktionen entsprechen, von einer Befehlszeile aus ausführen.
## Epen
### Stellen Sie die Build-Umgebung auf CentOS oder RHEL ein
| Aufgabe | Description | Erforderliche 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 |
### Pro\*C-Code nach ECPG konvertieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Unerwünschte Header entfernen. | Entfernen Sie die `include ` Header, die in PostgreSQL nicht erforderlich sind, wie`oci.h`, und`oratypes`. `sqlda` | App-Besitzer, App-Entwickler |
| 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);
| 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 mit`typedef`, 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. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-legacy-applications-from-oracle-pro-c-to-ecpg.html) | 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 |
### Kompilieren Sie ECPG-Programme
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine ausführbare Datei für ECPG. | Wenn Sie eine eingebettete SQL C-Quelldatei mit dem Namen haben`prog1.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 |
### Testen der Anwendung
| Aufgabe | Description | Erforderliche 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
+ [ECPG - Eingebettetes SQL in C](https://www.postgresql.org/docs/current/static/ecpg.html) (PostgreSQL-Dokumentation)
+ [Fehlerbehandlung](https://www.postgresql.org/docs/12/ecpg-errors.html) (PostgreSQL-Dokumentation)
+ [Warum den Oracle Pro\*C/C\+\+ Precompiler verwenden](https://docs.oracle.com/cd/E11882_01/appdev.112/e10825/pc_01int.htm#i2415) (Oracle-Dokumentation)
## 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 mithilfe des Standardprotokolls mit dem PostgreSQL-Server. frontend/backend