Esegui la 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à.

Esegui la migrazione delle applicazioni legacy da Oracle Pro*C a ECPG

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

Ambiente: PoC o pilota

Fonte: Oracle

Obiettivo: Postgre SQL

Tipo R: Re-architect

Carico di lavoro: Oracle

Tecnologie: migrazione; database

Riepilogo

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

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

Prerequisiti e limitazioni

Prerequisiti

  • Un AWS account attivo

  • Un database compatibile con Amazon RDS for Postgre o SQL Aurora Postgre SQL

  • Un database Oracle in esecuzione in locale

Strumenti

  • I SQL pacchetti Postgre elencati nella sezione successiva.

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

Epiche

AttivitàDescrizioneCompetenze richieste
Installa i pacchetti Postger. SQL

Installa i SQL pacchetti Postgre 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 di ambiente per le librerie SQL client Postgre.

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

Se necessario, installalo pgLoaderin 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 richiami un'applicazione Java dai moduli Pro*C, installa Java.

yum install java -y

Installa ant per compilare il codice Java.

yum install ant -y
Sviluppatore di app, DevOps ingegnere
Installa il AWSCLI.

AWSCLIInstalla i comandi per eseguire l'interazione con AWS servizi come AWS Secrets Manager e Amazon 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, DevOps ingegnere
Identifica i programmi da convertire.

Identificate le applicazioni che desiderate 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
ROWNUMFunzionalità di aggiornamento.

La ROWNUM funzione non è disponibile in SQL Postgre. Sostituiscila con la funzione ROW_NUMBER finestra nelle SQL query.

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;

ECPGcodice:

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

ECPGcodice:

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

ECPGcodice:

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

ECPGfile () 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;

ECPGcodice:

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

ECPGcodice:

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 SQL _ CURSOR variabili.

Riscrivi la SQL_CURSOR variabile e la sua implementazione.

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;

ECPGcodice:

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.
Sviluppatore di app, proprietario dell'app
Abilita il debug, se necessario.

Per eseguire il ECPG programma in modalità debug, aggiungi 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 perECPG.

Se si dispone di un file sorgente SQL C incorporato denominatoprog1.pgc, è possibile 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 ECPG programma, 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

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

File di input e output

ECPGconverte 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 presupposto 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 SQL compilatore Postgre compila i file di codice C preelaborati, cerca i file di ECPG intestazione nella directory Postgre. SQL 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 incorporato SQL devono essere collegati alla libecpg libreria. Ad esempio, è possibile utilizzare le opzioni  -L/usr/local/pgsql/lib -lecpg del linker.

ECPGLe applicazioni convertite richiamano le funzioni della libpq libreria tramite la SQL libreria incorporata (ecpglib) e comunicano con il SQL server Postgre utilizzando il protocollo frontend/backend standard.