8 Dynamic SQL

Dynamic SQL è una tecnica di programmazione che consente di creare istruzioni SQL dinamicamente in fase di esecuzione. È possibile creare applicazioni più generiche e flessibili utilizzando SQL dinamico poiché il testo completo di un’istruzione SQL potrebbe essere sconosciuto al momento della compilazione. Ad esempio, l’SQL dinamico consente di creare una procedura che opera su una tabella il cui nome non è noto fino al runtime.

Nelle versioni precedenti di Oracle, l’unico modo per implementare l’SQL dinamico in un’applicazione PL / SQL era utilizzando il pacchetto DBMS_SQL. Oracle8i introduce l’SQL dinamico nativo, un’alternativa al pacchetto DBMS_SQL. Utilizzando l’SQL dinamico nativo, è possibile inserire istruzioni SQL dinamiche direttamente nei blocchi PL / SQL.

Questo capitolo tratta i seguenti argomenti:

• Che cos’è l’SQL dinamico?
• Quando utilizzare SQL dinamico
• Uno scenario SQL dinamico che utilizza SQL dinamico nativo
• SQL dinamico nativo rispetto al pacchetto DBMS_SQL
• Applicazione Linguaggi di sviluppo diversi da PL / SQL

Che cos’è SQL dinamico?

SQL dinamico consente di scrivere programmi che fanno riferimento a istruzioni SQL il cui testo completo non è noto fino al runtime. Prima di discutere in dettaglio l’SQL dinamico, una chiara definizione di SQL statico può fornire un buon punto di partenza per comprendere l’SQL dinamico. Le istruzioni SQL statiche non cambiano da esecuzione a esecuzione. Il testo completo delle istruzioni SQL statiche è noto al momento della compilazione, il che fornisce i seguenti vantaggi:

• Una compilazione riuscita verifica che le istruzioni SQL facciano riferimento a oggetti di database validi.
• La corretta compilazione verifica che siano presenti i privilegi necessari per accedere agli oggetti del database.
• Le prestazioni dell’SQL statico sono generalmente migliori dell’SQL dinamico.

A causa di questi vantaggi, è necessario utilizzare SQL dinamico solo se non è possibile utilizzare SQL statico per raggiungere i propri obiettivi o se l’utilizzo di SQL statico è complicato rispetto a SQL dinamico. Tuttavia, l’SQL statico presenta limitazioni che possono essere superate con l’SQL dinamico. Potrebbe non essere sempre possibile conoscere il testo completo delle istruzioni SQL che devono essere eseguite in una procedura PL / SQL. Il programma potrebbe accettare l’input dell’utente che definisce le istruzioni SQL da eseguire, oppure potrebbe essere necessario completare un lavoro di elaborazione per determinare la corretta linea di azione. In questi casi, è necessario utilizzare SQL dinamico.

Ad esempio, si consideri un’applicazione di reporting che esegue query standard su tabelle in un ambiente di data warehouse in cui il nome esatto della tabella è sconosciuto fino al runtime. Per gestire in modo efficiente la grande quantità di dati nel data warehouse, creare una nuova tabella ogni trimestre per archiviare le informazioni sulla fattura per il trimestre. Queste tabelle hanno tutte esattamente la stessa definizione e sono denominate in base al mese e all’anno di inizio del trimestre, ad esempio INV_01_1997, INV_04_1997, INV_07_1997, INV_10_1997, INV_01_1998 e così via. In tal caso, puoi utilizzare dinamico SQL nell’applicazione di reporting per specificare il nome della tabella in fase di esecuzione.

Con SQL statico, tutte le informazioni sulla definizione dei dati, come le definizioni di tabella, a cui fanno riferimento le istruzioni SQL nel programma devono essere note al momento della compilazione. Se la definizione dei dati cambia, è necessario modificare e ricompilare il programma. I programmi SQL dinamici possono gestire le modifiche nelle informazioni di definizione dei dati, poiché le istruzioni SQL possono cambiare “al volo” in fase di esecuzione. Pertanto, l’SQL dinamico è molto più flessibile dell’SQL statico. SQL dinamico consente di scrivere codice dell’applicazione riutilizzabile perché il codice definisce un processo indipendente dalle istruzioni SQL specifiche utilizzate.

Inoltre, SQL dinamico consente di eseguire istruzioni SQL che non sono supportate in static Programmi SQL, come le istruzioni DDL (Data Definition Language). Il supporto per queste istruzioni consente di ottenere di più con i programmi PL / SQL.

Quando utilizzare SQL dinamico

Dovresti utilizzare SQL dinamico nei casi in cui SQL statico non supporta operazione che si desidera eseguire, o nei casi in cui non si conoscano le esatte istruzioni SQL che devono essere eseguite da una procedura PL / SQL. Queste istruzioni SQL possono dipendere dall’input dell’utente o dal lavoro di elaborazione svolto dal programma. Le sezioni seguenti descrivono situazioni tipiche in cui è necessario utilizzare SQL dinamico e problemi tipici che possono essere risolti utilizzando SQL dinamico.

Per eseguire istruzioni DML dinamiche

È possibile utilizzare SQL dinamico per eseguire Istruzioni DML in cui l’esatta istruzione SQL non è nota fino al runtime.Per esempi, vedere gli esempi DML in “Esempi di codice del pacchetto DBMS_SQL e codice SQL dinamico nativo” e “Operazione DML di esempio”.

Per eseguire dichiarazioni non supportate da SQL statico in PL / SQL

In PL / SQL, non è possibile eseguire i seguenti tipi di istruzioni utilizzando SQL statico:

• Istruzioni DDL (Data Definition Language), come CREATE, DROP, GRANT e REVOKE
• Istruzioni SCL (Session control language), come ALTER SESSION e SET ROLE
  Vedere anche:

  Oracle8i SQL Reference per informazioni sulle istruzioni DDL e SCL.

Usa SQL dinamico se devi eseguire uno qualsiasi di questi tipi di istruzioni all’interno di un PL / Blocco SQL.

Inoltre, l’SQL statico in PL / SQL non consente l’uso della clausola TABLE nella SELECT istruzioni. Non esistono limitazioni di questo tipo nell’SQL dinamico. Ad esempio, il seguente blocco PL / SQL contiene un’istruzione SELECT che utilizza la clausola TABLE e l’SQL dinamico nativo:

Per eseguire query dinamiche

È possibile utilizzare SQL dinamico per creare applicazioni che eseguono query dinamiche, che sono query il cui testo completo non è noto fino al runtime. Molti tipi di applicazioni devono utilizzare query dinamiche, tra cui:

• Applicazioni che consentono agli utenti di inserire o scegliere criteri di ricerca o ordinamento delle query in fase di esecuzione
• Applicazioni che consentono agli utenti di inserire oppure scegli suggerimenti per l’ottimizzazione in fase di esecuzione
• Applicazioni che interrogano un database in cui le definizioni dei dati delle tabelle cambiano costantemente
• Applicazioni che interrogano un database in cui vengono create spesso nuove tabelle

Per esempi, vedere “Esempio di query” e vedere gli esempi di query in “Uno scenario SQL dinamico che utilizza SQL dinamico nativo”.

Per fare riferimento a oggetti di database che non esistono alla compilazione

Molti tipi di applicazioni devono interagire con i dati generati periodicamente. Ad esempio, potrebbe essere possibile determinare la definizione delle tabelle del database durante la compilazione, ma non i nomi delle tabelle, poiché nuove tabelle vengono generate periodicamente. La tua applicazione deve accedere ai dati, ma non c’è modo di conoscere i nomi esatti delle tabelle fino al runtime.

SQL dinamico può risolvere questo problema, perché SQL dinamico ti consente di attendere fino al runtime per specificare il nomi di tabelle a cui devi accedere. Ad esempio, nell’applicazione di data warehouse di esempio discussa in “Che cos’è l’SQL dinamico?”, Vengono generate nuove tabelle ogni trimestre e queste tabelle hanno sempre la stessa definizione. In questo caso, potresti consentire a un utente di specificare il nome della tabella in fase di esecuzione con una query SQL dinamica simile alla seguente:

Per ottimizzare l’esecuzione dinamicamente

Se usi statico SQL, devi decidere al momento della compilazione come vuoi costruire le tue istruzioni SQL, se avere suggerimenti nelle tue istruzioni e, se includi suggerimenti, esattamente quali suggerimenti avere. Tuttavia, è possibile utilizzare l’SQL dinamico per creare un’istruzione SQL in modo da ottimizzare l’esecuzione e / o concatenare i suggerimenti in un’istruzione SQL in modo dinamico. Ciò consente di modificare i suggerimenti in base alle statistiche del database corrente, senza richiedere la ricompilazione.

Ad esempio, la procedura seguente utilizza una variabile chiamata a_hint per consentire agli utenti per passare un’opzione di suggerimento all’istruzione SELECT:

In questo esempio, l’utente può passare uno dei seguenti valori per a_hint:

Per richiamare blocchi dinamici PL / SQL

Puoi utilizzare EXECUTE IMMEDIATE per richiamare blocchi PL / SQL anonimi. La capacità di richiamare blocchi dinamici PL / SQL può essere utile per l’estensione e la personalizzazione dell’applicazione in cui il modulo da eseguire viene determinato dinamicamente in fase di esecuzione.

Ad esempio, supponiamo di voler scrivere un’applicazione che accetta un evento numero e invia a un gestore per l’evento. Il nome del gestore è nella forma EVENT_HANDLER_ event_num, dove event_num è il numero dell’evento. Un approccio potrebbe essere quello di implementare il dispatcher come un’istruzione switch, come mostrato di seguito, in cui il codice gestisce ogni evento effettuando una chiamata statica al suo gestore appropriato.

Questo codice non è molto estensibile perché il codice del dispatcher deve essere aggiornato ogni volta che viene aggiunto un gestore per un nuovo evento. Tuttavia, utilizzando l’SQL dinamico nativo, puoi scrivere un dispatcher di eventi estensibile simile al seguente:

Per eseguire operazioni dinamiche utilizzando i diritti di invocazione

Utilizzando la funzione dei diritti di invocazione con SQL, è possibile creare applicazioni che emettono istruzioni SQL dinamiche con i privilegi e lo schema di invoker.Queste due funzionalità, i diritti di richiamo e l’SQL dinamico, consentono di creare sottocomponenti di applicazioni riutilizzabili che possono operare e accedere ai dati e ai moduli dell’invocatore.

Uno scenario SQL dinamico che utilizza SQL dinamico nativo

Lo scenario descritto in questa sezione illustra la potenza e la flessibilità di SQL dinamico nativo. Questo scenario include esempi che mostrano come eseguire le seguenti operazioni utilizzando SQL dinamico nativo:

• Esegui operazioni DDL e DML
• Esegui query su riga singola e su più righe

Modello di dati

Il database in questo scenario è il database delle risorse umane di un’azienda (denominato hr) con il seguente modello di dati :

una tabella principale denominata offices contiene l’elenco di tutte le sedi dell’azienda. La tabella offices ha la seguente definizione :

Column Name Null? Type LOCATION NOT_NULL VARCHAR2(200)

emp_ tabelle di località contengono le informazioni sui dipendenti, dove località è il nome della città in cui si trova l’ufficio si trova. Ad esempio, una tabella denominata emp_houston contiene informazioni sui dipendenti per l’ufficio di Houston della società, mentre una tabella denominata emp_boston contiene informazioni per l’ufficio di Boston dell’azienda.

Ogni emp_ la tabella delle posizioni ha la seguente definizione:

Le sezioni seguenti descrivono varie operazioni SQL dinamiche native che possono essere eseguite sui dati nella hr database.

Operazione DML di esempio

La seguente procedura SQL dinamica nativa offre un aumento a tutti i dipendenti con un particolare titolo di lavoro:

Operazione DDL di esempio

L’istruzione EXECUTE IMMEDIATE può eseguire operazioni DDL. Ad esempio, la seguente procedura aggiunge una posizione dell’ufficio:

La seguente procedura elimina una posizione dell’ufficio:

Esempio di query dinamica su riga singola

Il EXECUTE IMMEDIATE può eseguire query dinamiche su riga singola. Puoi specificare le variabili di associazione nella clausola USING e caricare la riga risultante nella destinazione specificata nella clausola INTO dell’istruzione.

La seguente funzione recupera il numero di dipendenti in una particolare posizione che eseguono un lavoro specificato:

Esempio di query dinamica su più righe

OPEN-FOR, FETCH e CLOSE possono eseguire query dinamiche su più righe. Ad esempio, la seguente procedura elenca tutti i dipendenti con un particolare lavoro in una posizione specificata:

Native Dynamic SQL rispetto al pacchetto DBMS_SQL

Oracle fornisce due metodi per l’utilizzo di SQL dinamico all’interno di PL / SQL: SQL dinamico nativo e il pacchetto DBMS_SQL. SQL dinamico nativo consente di inserire istruzioni SQL dinamiche direttamente nel codice PL / SQL. Queste istruzioni dinamiche includono istruzioni DML (comprese le query), blocchi anonimi PL / SQL, istruzioni DDL, istruzioni di controllo delle transazioni e istruzioni di controllo della sessione.

Per elaborare la maggior parte delle istruzioni SQL dinamiche native, utilizzare EXECUTE IMMEDIATE. Tuttavia, per elaborare una query su più righe (istruzione SELECT), utilizza OPEN-FOR, FETCH e CLOSE.

Il pacchetto DBMS_SQL è una libreria PL / SQL che offre un’API programmatica per eseguire dinamicamente le istruzioni SQL. Il pacchetto DBMS_SQL dispone di interfacce programmatiche per aprire un cursore, analizzare un cursore, fornire binding e così via. I programmi che utilizzano il pacchetto DBMS_SQL effettuano chiamate a questo pacchetto per eseguire operazioni SQL dinamiche.

Le sezioni seguenti forniscono informazioni dettagliate sui vantaggi di entrambi i metodi.

Vantaggi di Native Dynamic SQL

Native Dynamic SQL offre i seguenti vantaggi rispetto a DBMS_SQL pacchetto:

Facilità d’uso

L’SQL dinamico nativo è molto più semplice da usare rispetto al pacchetto DBMS_SQL.Poiché SQL dinamico nativo è integrato con SQL, è possibile utilizzarlo nello stesso modo in cui si utilizza attualmente SQL statico nel codice PL / SQL. Inoltre, il codice SQL dinamico nativo è in genere più compatto e leggibile del codice equivalente che utilizza il pacchetto DBMS_SQL.

Il DBMS_SQL non è facile da usare come l’SQL dinamico nativo. Esistono molte procedure e funzioni che devono essere utilizzate in una sequenza rigorosa. In genere, l’esecuzione di operazioni semplici richiede una grande quantità di codice quando si utilizza il pacchetto DBMS_SQL. Puoi evitare questa complessità utilizzando invece l’SQL dinamico nativo.

La Tabella 8-1 illustra la differenza nella quantità di codice richiesta per eseguire la stessa operazione utilizzando DBMS_SQL pacchetto e SQL dinamico nativo.

Tabella 8-1 Confronto del codice del pacchetto DBMS_SQL e SQL dinamico nativo

Miglioramenti delle prestazioni

Le prestazioni dell’SQL dinamico nativo in PL / SQL sono paragonabili alle prestazioni dell’SQL statico perché l’interprete PL / SQL ha il supporto integrato per l’SQL dinamico nativo. Pertanto, le prestazioni dei programmi che utilizzano SQL dinamico nativo sono molto migliori di quelle dei programmi che utilizzano il pacchetto DBMS_SQL. In genere, le istruzioni SQL dinamiche native hanno prestazioni da 1,5 a 3 volte migliori delle istruzioni equivalenti che utilizzano il pacchetto DBMS_SQL. Ovviamente, i guadagni in termini di prestazioni possono variare a seconda dell’applicazione.

Il pacchetto DBMS_SQL è basato su un’API procedurale e, di conseguenza, incorre in chiamate di procedura elevate e overhead per la copia dei dati. Ad esempio, ogni volta che si collega una variabile, il pacchetto DBMS_SQL copia la variabile di associazione PL / SQL nel suo spazio per un uso successivo durante l’esecuzione. Allo stesso modo, ogni volta che esegui un fetch, prima i dati vengono copiati nello spazio gestito dal pacchetto DBMS_SQL e poi i dati recuperati vengono copiati, una colonna alla volta, nell’apposito Variabili PL / SQL, con conseguente notevole sovraccarico derivante dalla copia dei dati. Al contrario, l’SQL dinamico nativo raggruppa i passaggi di preparazione, associazione ed esecuzione dell’istruzione in un’unica operazione, riducendo al minimo il sovraccarico della copia dei dati e delle chiamate di procedura e migliorando le prestazioni.

Suggerimento sulle prestazioni

Quando si utilizza l’SQL dinamico nativo o il pacchetto DBMS_SQL, è possibile migliorare le prestazioni utilizzando le variabili di associazione, poiché l’utilizzo di variabili di associazione consente a Oracle di condividere un singolo cursore per più istruzioni SQL.

Ad esempio, il seguente codice SQL dinamico nativo non utilizza variabili bind:

Per ogni variabile my_deptno distinta, viene creato un nuovo cursore, che può causare conflitti di risorse e prestazioni scadenti. Invece, bind my_deptno come variabile bind, come nell’esempio seguente:

Qui, lo stesso cursore viene riutilizzato per diversi valori di bind my_deptno, migliorando così le prestazioni e la scalabilità.

Supporto per tipi definiti dall’utente

SQL dinamico nativo supporta tutti i tipi supportati da SQL statico in PL / SQL. Pertanto, l’SQL dinamico nativo fornisce supporto per i tipi definiti dall’utente, come gli oggetti definiti dall’utente, le raccolte e REFs. Il pacchetto DBMS_SQL non supporta questi tipi definiti dall’utente.

Supporto per il recupero nei record

SQL dinamico nativo e SQL statico supportano entrambi il recupero nei record, ma il Il pacchetto DBMS_SQL no. Con l’SQL dinamico nativo, le righe risultanti da una query possono essere recuperate direttamente nei record PL / SQL.

Nell’esempio seguente, le righe di una query vengono recuperate nel emp_rec record:

Vantaggi del pacchetto DBMS_SQL

Il pacchetto DBMS_SQL fornisce i seguenti vantaggi rispetto all’SQL dinamico nativo:

Supporto per programmi lato client

Attualmente, il pacchetto DBMS_SQL è supportato nei programmi lato client, ma SQL dinamico nativo non lo è. Ogni chiamata al pacchetto DBMS_SQL dal programma lato client si traduce in una chiamata di procedura remota (RPC) PL / SQL; queste chiamate si verificano quando è necessario associare una variabile, definire una variabile o eseguire un’istruzione.

Supporto per DESCRIBE

La procedura DESCRIBE_COLUMNS nel pacchetto DBMS_SQL può essere utilizzata per descrivere le colonne per un cursore aperto e analizzato tramite DBMS_SQL. La funzionalità è simile al comando DESCRIBE in SQL * Plus. L’SQL dinamico nativo non dispone di una funzione DESCRIBE.

Supporto per Bulk Dynamic SQL

Bulk SQL è la capacità di elaborare più righe di dati in una singola istruzione DML. Bulk SQL migliora le prestazioni riducendo la quantità di cambio di contesto tra SQL e la lingua host. Attualmente, il pacchetto DBMS_SQL supporta l’SQL dinamico in blocco.

Sebbene non sia disponibile un supporto diretto per le operazioni in blocco in SQL dinamico nativo, è possibile simulare un SQL dinamico in blocco nativo inserendo l’istruzione SQL in blocco in un blocco “BEGIN … END” ed eseguendo il blocco dinamicamente. Questa soluzione alternativa consente di realizzare i vantaggi dell’SQL di massa all’interno di un programma SQL dinamico nativo. Ad esempio, il seguente codice SQL dinamico nativo copia la colonna ename di una tabella in un’altra:

Aggiornamenti ed eliminazioni di più righe con una clausola RETURNING

Il pacchetto DBMS_SQL supporta istruzioni con una clausola RETURNING che aggiorna o elimina più righe. L’SQL dinamico nativo supporta solo una clausola RETURNING se viene restituita una singola riga.

Supporto per istruzioni SQL di dimensioni superiori a 32 KB

DBMS_SQL il pacchetto supporta istruzioni SQL superiori a 32 KB; SQL dinamico nativo no.

Riutilizzo di istruzioni SQL

La procedura PARSE nella DBMS_SQL package analizza un’istruzione SQL una volta. Dopo l’analisi iniziale, l’istruzione può essere utilizzata più volte con diversi set di argomenti di associazione.

Al contrario, l’SQL dinamico nativo prepara un’istruzione SQL per l’esecuzione ogni volta che l’istruzione viene utilizzata. La preparazione dell’istruzione in genere implica l’analisi, l’ottimizzazione e la generazione di piani. La preparazione di una dichiarazione ogni volta che viene utilizzata comporta una piccola penalizzazione delle prestazioni. Tuttavia, il meccanismo del cursore condiviso di Oracle riduce al minimo il costo e la penalizzazione delle prestazioni è in genere irrisoria rispetto ai vantaggi in termini di prestazioni dell’SQL dinamico nativo.

Esempi di codice del pacchetto DBMS_SQL e codice SQL dinamico nativo

I seguenti esempi illustrano le differenze nel codice necessario per completare le operazioni con il pacchetto DBMS_SQL e l’SQL dinamico nativo. Nello specifico, vengono presentati i seguenti tipi di esempi:

• Una query
• Un’operazione DML
• Un’operazione di restituzione DML

In generale, il codice SQL dinamico nativo è più leggibile e compatto, che può migliorare la produttività degli sviluppatori.

Esempio di query

L’esempio seguente include un’istruzione di query dinamica con una variabile di bind (:jobname) e due colonne selezionate (ename e sal):

stmt_str := "SELECT ename, sal FROM emp WHERE job = :jobname";

Questo esempio interroga i dipendenti con j ob description SALESMAN nella colonna job della tabella emp. La Tabella 8-2 mostra il codice di esempio che esegue questa query utilizzando il pacchetto DBMS_SQL e l’SQL dinamico nativo.

Tabella 8-2 Query utilizzando il pacchetto DBMS_SQL e l’SQL dinamico nativo

Esempio DML

Il Il seguente esempio include un’istruzione INSERT dinamica per una tabella con tre colonne:

stmt_str := "INSERT INTO dept_new VALUES (:deptno, :dname, :loc)";

Questo esempio inserisce una nuova riga per i quali i valori delle colonne sono nelle variabili PL / SQL deptnumber, deptname e location. La Tabella 8-3 mostra il codice di esempio che esegue questa operazione DML utilizzando il pacchetto DBMS_SQL e l’SQL dinamico nativo.

Tabella 8-3 Operazione DML utilizzando il pacchetto DBMS_SQL e SQL dinamico nativo

Esempio di restituzione di DML

L’esempio seguente include un UPDATE istruzione che aggiorna la posizione di un reparto quando viene fornito il numero di reparto (deptnumber) e una nuova posizione (location), quindi restituisce il nome del dipartimento:

stmt_str := "UPDATE dept_new SET loc = :newloc WHERE deptno = :deptno RETURNING dname INTO :dname";

Questo esempio inserisce una nuova riga i cui valori di colonna sono nelle variabili PL / SQL deptnumber, deptname e location. La Tabella 8-4 mostra il codice di esempio che esegue questa operazione di restituzione DML utilizzando il pacchetto DBMS_SQL e l’SQL dinamico nativo.

Tabella 8-4 Operazione di restituzione DML utilizzando DBMS_SQL Pacchetto e SQL dinamico nativo

Linguaggi di sviluppo di applicazioni diversi da PL / SQL

Finora, la discussione in questo capitolo è stata sul supporto PL / SQL per SQL dinamico.Tuttavia, è possibile utilizzare altri linguaggi di sviluppo dell’applicazione per implementare programmi che utilizzano SQL dinamico. Questi linguaggi di sviluppo di applicazioni includono C / C ++, COBOL e Java.

Se utilizzi C / C ++, puoi sviluppare applicazioni che utilizzano SQL dinamico con Oracle Call Interface (OCI), oppure puoi utilizzare il precompilatore Pro * C / C ++ per aggiungere estensioni SQL dinamiche al tuo C codice. Allo stesso modo, se si utilizza COBOL, è possibile utilizzare il precompilatore Pro * COBOL per aggiungere estensioni SQL dinamiche al codice COBOL. Se utilizzi Java, puoi sviluppare applicazioni che utilizzano SQL dinamico con JDBC.

In passato, l’unico modo per utilizzare SQL dinamico nelle applicazioni PL / SQL era utilizzare DBMS_SQL pacchetto. Esistono numerose limitazioni all’uso di questo pacchetto, inclusi i problemi di prestazioni. Di conseguenza, gli sviluppatori di applicazioni potrebbero aver utilizzato una delle alternative a PL / SQL discusse sopra per implementare SQL dinamico. Tuttavia, con l’introduzione dell’SQL dinamico nativo in PL / SQL, molti degli svantaggi dell’utilizzo di PL / SQL per l’SQL dinamico vengono ora eliminati.

Se si dispone di un’applicazione che utilizza OCI, Pro * C / C ++, o Pro * COBOL per l’esecuzione SQL dinamica, i roundtrip di rete necessari per eseguire operazioni SQL dinamiche possono compromettere le prestazioni. Poiché queste applicazioni in genere risiedono sui client, sono necessarie più chiamate di rete per completare le operazioni SQL dinamiche. Se si dispone di questo tipo di applicazione, valutare la possibilità di spostare la funzionalità SQL dinamica su stored procedure e funzioni archiviate in PL / SQL che utilizzano SQL dinamico nativo. Ciò potrebbe migliorare le prestazioni dell’applicazione poiché le procedure memorizzate possono risiedere sul server, eliminando così il sovraccarico di rete. È quindi possibile chiamare le stored procedure PL / SQL e le funzioni memorizzate dall’applicazione.