Migrazione delle applicazioni legacy da Oracle Pro*C a ECPG - Prontuario AWS
RiepilogoPrerequisiti e limitazioniStrumentiEpicheRisorse correlateInformazioni aggiuntive

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Migrazione delle applicazioni legacy da Oracle Pro*C a ECPG

Creato da Sai Parthasaradhi (AWS) e Mahesh Balumuri (AWS)

Riepilogo

La maggior parte delle applicazioni legacy con codice SQL incorporato utilizza il precompilatore Oracle Pro*C per accedere al database. Quando esegui la migrazione di questi database Oracle ad Amazon Relational Database Service (Amazon RDS) per PostgreSQL o Amazon Aurora PostgreSQL Compatible Edition, devi convertire il codice dell'applicazione in un formato compatibile con il precompilatore di PostgreSQL, chiamato ECPG. Questo modello descrive come convertire il codice Oracle Pro*C nel suo equivalente in PostgreSQL ECPG. 

Per ulteriori informazioni su Pro*C, consulta la documentazione Oracle. Per una breve introduzione a ECPG, vedere la sezione Informazioni aggiuntive.

Prerequisiti e limitazioni

Prerequisiti

  • Un account AWS attivo

  • Un database compatibile con Amazon RDS per PostgreSQL o Aurora PostgreSQL

  • Un database Oracle in esecuzione in locale

Strumenti

  • I pacchetti PostgreSQL elencati nella sezione successiva.

  • AWS CLI — L'AWS Command Line Interface (AWS CLI) è uno strumento open source per interagire con i servizi AWS tramite comandi nella shell della riga di comando. Con una configurazione minima, puoi eseguire comandi AWS CLI che implementano funzionalità equivalenti a quelle fornite dalla Console di gestione AWS basata su browser da un prompt dei comandi.

Epiche

AttivitàDescrizioneCompetenze richieste
Installa i pacchetti PostgreSQL.

Installa i pacchetti PostgreSQL richiesti utilizzando i seguenti comandi.

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
Sviluppatore di app, ingegnere DevOps
Installa i file di intestazione e le librerie.

Installa il postgresql12-devel pacchetto, che contiene i file di intestazione e le librerie, utilizzando i seguenti comandi. Installa il pacchetto sia nell'ambiente di sviluppo che in quello di runtime per evitare errori nell'ambiente di runtime.

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

Solo per l'ambiente di sviluppo, esegui anche i seguenti comandi.

yum install zlib-devel make -y
ln -s /usr/pgsql-12/bin/ecpg /usr/bin/
Sviluppatore di app, DevOps ingegnere
Configura la variabile del percorso di ambiente.

Imposta il percorso dell'ambiente per le librerie client PostgreSQL.

export PATH=$PATH:/usr/pgsql-12/bin
Sviluppatore di app, ingegnere DevOps
Installa software aggiuntivo se necessario.

Se necessario, installare pgLoader in sostituzione di 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/

Se state chiamando delle applicazioni Java dai moduli Pro*C, installate Java.

yum install java -y

Installa ant per compilare il codice Java.

yum install ant -y
Sviluppatore di app, DevOps ingegnere
Installare l'interfaccia a riga di comando di AWS.

Installa l'AWS CLI per eseguire comandi per interagire con servizi AWS come AWS Secrets Manager e Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) dalle tue applicazioni.

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
Sviluppatore di app, ingegnere DevOps
Identifica i programmi da convertire.

Identifica le applicazioni che desideri convertire da Pro*C a ECPG.

Sviluppatore di app, proprietario dell'app
AttivitàDescrizioneCompetenze richieste
Rimuovi le intestazioni indesiderate.

Rimuovi le include intestazioni che non sono richieste in PostgreSQL, ad esempio, e. oci.h oratypes sqlda

Proprietario dell'app, sviluppatore dell'app
Aggiorna le dichiarazioni delle variabili.

Aggiungi EXEC SQL istruzioni per tutte le dichiarazioni di variabili utilizzate come variabili host.

Rimuovi EXEC SQL VAR le dichiarazioni come le seguenti dall'applicazione.

EXEC SQL VAR query IS STRING(2048);
Sviluppatore di app, proprietario dell'app
Aggiorna la funzionalità ROWNUM.

La ROWNUM funzione non è disponibile in PostgreSQL. Sostituiscila con la funzione ROW_NUMBER window nelle query SQL.

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

Codice 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;
Sviluppatore di app, proprietario dell'app
Aggiorna i parametri della funzione per utilizzare le variabili alias.

In PostgreSQL, i parametri delle funzioni non possono essere usati come variabili host. Sovrascrivili utilizzando una variabile alias.

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

Codice 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;
}
Sviluppatore di app, proprietario dell'app
Aggiorna i tipi di struttura.

Definisci struct i tipi EXEC SQL BEGIN e END i blocchi specificando typedef se le variabili struct di tipo vengono utilizzate come variabili host. Se i struct tipi sono definiti nei file header (.h), includi i file con le istruzioni EXEC SQL include.

Codice Pro*C:

File di intestazione () 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;
};

Codice ECPG:

File di intestazione () 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;

File 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] ;

File 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;
Sviluppatore di app, proprietario dell'app
Modifica la logica da recuperare dai cursori.

Per recuperare più righe dai cursori utilizzando variabili di matrice, modificate il codice da utilizzare. FETCH FORWARD

Codice Pro*C:

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

Codice ECPG:

EXEC SQL char  aPoeFiles[MAX_FILES][FILENAME_LENGTH];
EXEC SQL int fetchSize = MAX_FILES;
EXEC SQL FETCH FORWARD :fetchSize filename_cursor into :aPoeFiles;
Sviluppatore di app, proprietario dell'app
Modifica le chiamate ai pacchetti che non hanno valori restituiti.

Le funzioni dei pacchetti Oracle che non hanno valori restituiti devono essere chiamate con una variabile indicatore. Se l'applicazione include più funzioni con lo stesso nome o se le funzioni di tipo sconosciuto generano errori di runtime, digita i valori nei tipi di dati.

Codice Pro*C:

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

Codice 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;
}
Sviluppatore di app, proprietario dell'app
Riscrivi le variabili SQL_CURSOR.

Riscrivi la variabile e la sua implementazione. SQL_CURSOR

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

Codice 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;
Sviluppatore di app, proprietario dell'app
Applica modelli di migrazione comuni.

  • Modifica le query SQL in modo che siano compatibili con PostgreSQL.

  • Sposta i blocchi anonimi, quando non sono supportati in ECPG, nel database.

  • Rimuovi dbms_application_info la logica, che non è supportata da PostgreSQL.

  • Sposta EXEC SQL COMMIT le istruzioni dopo la chiusura del cursore. Se durante il ciclo si eseguono delle interrogazioni per recuperare i record dal cursore, il cursore viene chiuso e viene visualizzato l'errore «cursore non esiste».

  • Per informazioni sulla gestione delle eccezioni in ECPG e dei codici di errore, vedere Gestione degli errori nella documentazione di PostgreSQL.

Sviluppatore di app, proprietario dell'app
Abilita il debug, se necessario.

Per eseguire il programma ECPG in modalità debug, aggiungete il seguente comando all'interno del blocco funzionale principale.

ECPGdebug(1, stderr);
Sviluppatore dell'app, proprietario dell'app
AttivitàDescrizioneCompetenze richieste
Crea un file eseguibile per ECPG.

Se disponete di un file sorgente SQL C incorporato denominatoprog1.pgc, potete creare un programma eseguibile utilizzando la seguente sequenza di comandi.

ecpg prog1.pgc
cc -I/usr/local/pgsql/include -c prog1.c
cc -o prog1 prog1.o -L/usr/local/pgsql/lib -lecpg
Sviluppatore di app, proprietario dell'app
Crea un make file per la compilazione.

Create un make file per compilare il programma ECPG, come mostrato nel seguente file di esempio.

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)
Sviluppatore di app, proprietario dell'app
AttivitàDescrizioneCompetenze richieste
Test del codice.

Verifica il codice dell'applicazione convertito per assicurarti che funzioni correttamente.

Sviluppatore di app, proprietario dell'app, tecnico di test

Risorse correlate

Informazioni aggiuntive

PostgreSQL ha un precompilatore SQL incorporato, ECPG, che è equivalente al precompilatore Oracle Pro*C. ECPG converte i programmi C che hanno istruzioni SQL incorporate in codice C standard sostituendo le chiamate SQL con chiamate a funzioni speciali. I file di output possono quindi essere elaborati con qualsiasi catena di strumenti del compilatore C.

File di input e output

ECPG converte ogni file di input specificato nella riga di comando nel file di output C corrispondente. Se il nome di un file di input non ha un'estensione di file, viene utilizzato l'estensione.pgc. L'estensione del file viene sostituita da .c per costruire il nome del file di output. Tuttavia, è possibile sovrascrivere il nome del file di output predefinito utilizzando l'-oopzione.

Se utilizzate un trattino (-) come nome del file di input, ECPG legge il programma dallo standard input e scrive sullo standard output, a meno che non lo sovrascriviate utilizzando l'opzione. -o

File di intestazione

Quando il compilatore PostgreSQL compila i file di codice C preelaborati, cerca i file di intestazione ECPG nella directory PostgreSQL. include Pertanto, potrebbe essere necessario utilizzare l'-Iopzione per indirizzare il compilatore alla directory corretta (ad esempio,). -I/usr/local/pgsql/include

Libraries (Librerie)

I programmi che utilizzano codice C con SQL incorporato devono essere collegati alla libecpg libreria. Ad esempio, è possibile utilizzare le opzioni  -L/usr/local/pgsql/lib -lecpg del linker.

Le applicazioni ECPG convertite richiamano le funzioni nella libpq libreria tramite la libreria SQL incorporata (ecpglib) e comunicano con il server PostgreSQL utilizzando il protocollo frontend/backend standard.