8 Dynamic SQL (Română)

Dynamic SQL este o tehnică de programare care vă permite să construiți instrucțiuni SQL dinamic în timp de execuție. Puteți crea aplicații mai flexibile cu scop general folosind SQL dinamic, deoarece textul complet al unei instrucțiuni SQL poate fi necunoscut la compilare. De exemplu, SQL dinamic vă permite să creați o procedură care funcționează pe un tabel al cărui nume nu este cunoscut până la runtime.

În versiunile anterioare ale Oracle, singurul mod de a implementa SQL dinamic într-o aplicație PL / SQL utilizând pachetul DBMS_SQL. Oracle8i introduce SQL dinamic nativ, o alternativă la pachetul DBMS_SQL. Folosind SQL dinamic nativ, puteți plasa instrucțiuni SQL dinamice direct în blocuri PL / SQL.

Acest capitol acoperă următoarele subiecte:

• Ce este Dynamic SQL?
• Când să utilizați SQL dinamic
• Un scenariu SQL dinamic utilizând SQL dinamic nativ
• SQL dinamic nativ față de pachetul DBMS_SQL
• Aplicație Limbaje de dezvoltare, altele decât PL / SQL

Ce este Dynamic SQL?

Dynamic SQL vă permite să scrieți programe care fac referire la instrucțiuni SQL al căror text complet nu este cunoscut până la runtime. Înainte de a discuta în detaliu SQL-ul dinamic, o definiție clară a SQL-ului static poate oferi un bun punct de plecare pentru înțelegerea SQL-ului dinamic. Instrucțiunile SQL statice nu se schimbă de la execuție la execuție. Textul complet al instrucțiunilor SQL statice este cunoscut la compilare, ceea ce oferă următoarele avantaje:

• Compilarea cu succes verifică dacă instrucțiunile SQL fac referire la obiecte de bază de date valabile.
• Compilarea cu succes verifică existența privilegiilor necesare pentru a accesa obiectele bazei de date.
• Performanța SQL static este, în general, mai bună decât SQL dinamic.

Datorită acestor avantaje, ar trebui să utilizați SQL dinamic numai dacă nu puteți utiliza SQL static pentru a vă atinge obiectivele sau dacă utilizarea SQL static este greoaie în comparație cu SQL dinamic. Cu toate acestea, SQL static are limitări care pot fi depășite cu SQL dinamic. Este posibil să nu cunoașteți întotdeauna textul complet al instrucțiunilor SQL care trebuie executate într-o procedură PL / SQL. Programul dvs. poate accepta introducerea utilizatorului care definește instrucțiunile SQL de executat sau programul dvs. poate fi necesar să finalizeze unele lucrări de procesare pentru a determina cursul corect de acțiune. În astfel de cazuri, ar trebui să utilizați SQL dinamic.

De exemplu, luați în considerare o aplicație de raportare care efectuează interogări standard pe tabele dintr-un mediu de depozitare de date în care numele tabelului exact este necunoscut până la runtime. Pentru a găzdui în mod eficient cantitatea mare de date din depozitul de date, creați un nou tabel în fiecare trimestru pentru a stoca informațiile despre factură pentru trimestrul respectiv. Toate aceste tabele au exact aceeași definiție și sunt denumite în funcție de luna și anul de început ale trimestrului, de exemplu INV_01_1997, INV_04_1997, INV_07_1997, INV_10_1997, INV_01_1998 etc. Într-un astfel de caz, puteți utiliza dinamica SQL în aplicația dvs. de raportare pentru a specifica numele tabelului în timpul rulării.

Cu SQL static, toate informațiile de definire a datelor, cum ar fi definițiile tabelelor, la care se face referire prin instrucțiunile SQL din programul dvs. trebuie să fie cunoscute la compilare. Dacă se modifică definiția datelor, trebuie să modificați și să recompilați programul. Programele SQL dinamice pot gestiona modificările informațiilor de definire a datelor, deoarece instrucțiunile SQL se pot schimba „din mers” în timpul rulării. Prin urmare, SQL dinamic este mult mai flexibil decât SQL static. Dynamic SQL vă permite să scrieți codul aplicației care este reutilizabil deoarece codul definește un proces care este independent de instrucțiunile SQL specifice utilizate.

În plus, SQL dinamic vă permite să executați instrucțiuni SQL care nu sunt acceptate în format static Programe SQL, cum ar fi instrucțiunile limbajului de definire a datelor (DDL). Suportul pentru aceste afirmații vă permite să realizați mai multe cu programele dvs. PL / SQL.

Când se folosește Dynamic SQL

Ar trebui să utilizați SQL dinamic în cazurile în care SQL static nu acceptă operație pe care doriți să o efectuați sau în cazurile în care nu cunoașteți instrucțiunile SQL exacte care trebuie executate printr-o procedură PL / SQL. Aceste instrucțiuni SQL pot depinde de introducerea utilizatorului sau pot depinde de munca de procesare efectuată de program. Următoarele secțiuni descriu situații tipice în care ar trebui să utilizați SQL dinamic și probleme tipice care pot fi rezolvate folosind SQL dinamic.

Pentru a executa instrucțiuni DML dinamice

Puteți utiliza SQL dinamic pentru a executa Instrucțiuni DML în care instrucțiunea SQL exactă nu este cunoscută până la runtime.Pentru exemple, consultați exemplele DML din „Exemple de cod pachet DBMS_SQL și cod SQL dinamic nativ” și „Exemplu de operare DML”.

Pentru a executa declarații neacceptate de SQL static în PL / SQL

În PL / SQL, nu puteți executa următoarele tipuri de instrucțiuni folosind SQL static:

• Instrucțiuni cu limbaj de definire a datelor (DDL), cum ar fi CREATE, DROP, GRANT și REVOKE
• Instrucțiuni de control al sesiunii (SCL), cum ar fi ALTER SESSION și SET ROLE
  Consultați și:

  Oracle8i SQL Reference pentru informații despre instrucțiunile DDL și SCL.

Utilizați SQL dinamic dacă trebuie să executați oricare dintre aceste tipuri de instrucțiuni într-un PL / Bloc SQL.

În plus, SQL static în PL / SQL nu permite utilizarea clauzei TABLE în SELECT declarații. Nu există o astfel de limitare în SQL dinamic. De exemplu, următorul bloc PL / SQL conține o instrucțiune SELECT care folosește clauza TABLE și SQL dinamic nativ:

Pentru a executa interogări dinamice

Puteți utiliza SQL dinamic pentru a crea aplicații care execută interogări dinamice, care sunt interogări al căror text complet nu este cunoscut până la runtime. Multe tipuri de aplicații trebuie să utilizeze interogări dinamice, inclusiv:

• Aplicații care permit utilizatorilor să introducă sau să aleagă căutarea interogării sau criteriile de sortare în timp de execuție
• Aplicații care permit utilizatorilor să introducă sau alegeți indicii de optimizare în timpul rulării
• Aplicații care interogă o bază de date în care definițiile de date ale tabelelor sunt în continuă schimbare
• Aplicații care interogă o bază de date în care sunt create de multe ori tabele noi

Pentru exemple, consultați „Exemplu de interogare” și consultați exemplele de interogare din „Un scenariu SQL dinamic folosind SQL dinamic nativ”.

Pentru a face referință la obiecte din baza de date care nu există la compilare

Multe tipuri de aplicații trebuie să interacționeze cu datele generate periodic. De exemplu, poate fi posibil să se determine definiția tabelelor bazei de date la compilare, dar nu și numele tabelelor, deoarece noi tabele sunt generate periodic. Aplicația dvs. trebuie să acceseze datele, dar nu există nicio modalitate de a cunoaște numele exacte ale tabelelor până la runtime.

SQL dinamic poate rezolva această problemă, deoarece SQL dinamic vă permite să așteptați până la runtime pentru a specifica numele tabelelor pe care trebuie să le accesați. De exemplu, în exemplul de aplicație de depozitare a datelor discutat în „Ce este Dynamic SQL?”, Sunt generate tabele noi în fiecare trimestru, iar aceste tabele au întotdeauna aceeași definiție. În acest caz, puteți permite unui utilizator să specifice numele tabelului în timpul rulării cu o interogare SQL dinamică similară cu următoarea:

Pentru a optimiza execuția dinamic

Dacă utilizați static SQL, trebuie să decideți la compilare cum doriți să vă construiți instrucțiunile SQL, dacă aveți indicii în instrucțiunile dvs. și, dacă includeți indicii, exact ce indicii să aveți. Cu toate acestea, puteți utiliza SQL dinamic pentru a construi o instrucțiune SQL într-un mod care optimizează execuția și / sau concatenează în mod dinamic sugestiile într-o instrucțiune SQL. Acest lucru vă permite să modificați sugestiile pe baza statisticilor curente ale bazei de date, fără a necesita recompilare.

De exemplu, următoarea procedură utilizează o variabilă numită a_hint pentru a permite utilizatorilor pentru a trece o opțiune de sugestie la instrucțiunea SELECT:

În acest exemplu, utilizatorul poate transmite oricare dintre următoarele valori pentru a_hint:

Pentru a invoca blocuri dinamice PL / SQL

Puteți utiliza EXECUTE IMMEDIATE declarație pentru a invoca blocuri PL / SQL anonime. Abilitatea de a invoca blocuri dinamice PL / SQL poate fi utilă pentru extensia și personalizarea aplicațiilor, în cazul în care modulul care urmează să fie executat este determinat dinamic în timpul rulării.

De exemplu, să presupunem că doriți să scrieți o aplicație care să ia un eveniment numărul și expedierile către un handler pentru eveniment. Numele gestionarului este sub forma EVENT_HANDLER_ event_num, unde event_num este numărul evenimentului. O abordare ar fi implementarea dispecerului ca o instrucțiune de comutare, așa cum se arată mai jos, în care codul gestionează fiecare eveniment efectuând un apel static către gestionarul său corespunzător.

Acest cod nu este foarte extensibil deoarece codul dispecerului trebuie actualizat ori de câte ori se adaugă un handler pentru un nou eveniment. Cu toate acestea, utilizând SQL dinamic nativ, puteți scrie un dispecer de extensie extensibil similar cu următorul:

Pentru a efectua operațiuni dinamice folosind Invoker-Rights

Prin utilizarea caracteristicii invoker-rights cu dynamic SQL, puteți crea aplicații care emit instrucțiuni SQL dinamice sub privilegiile și schema invocatorului.Aceste două caracteristici, drepturile invocatorului și SQL dinamic, vă permit să construiți subcomponenți de aplicații reutilizabili care pot opera și accesa datele și modulele invocatorului.

Un scenariu SQL dinamic utilizând SQL dinamic nativ

Scenariul descris în această secțiune ilustrează puterea și flexibilitatea de SQL dinamic nativ. Acest scenariu include exemple care vă arată cum să efectuați următoarele operații folosind SQL dinamic nativ:

• Executați operațiuni DDL și DML
• Executați interogări pe un singur rând și pe mai multe rânduri

Model de date

Baza de date din acest scenariu este baza de date a resurselor umane a companiei (numită hr) cu următorul model de date :

Un tabel principal numit offices conține lista tuturor locațiilor companiei. Tabelul offices are următoarea definiție :

Column Name Null? Type LOCATION NOT_NULL VARCHAR2(200)

Mai multe tabele de locații emp_ conțin informații despre angajați, unde locația este numele orașului unde se află biroul este situat. De exemplu, un tabel numit emp_houston conține informații despre angajați pentru biroul companiei din Houston, în timp ce un tabel numit emp_boston conține angajați informații pentru biroul companiei din Boston.

Fiecare emp_ tabelul de locație are următoarea definiție:

Următoarele secțiuni descriu diverse operațiuni SQL dinamice native care pot fi efectuate pe datele din hr baza de date.

Exemplu de operare DML

Următoarea procedură nativă SQL dinamică oferă o creștere tuturor angajaților cu un anumit titlu de post:

Exemplu de operare DDL

Instrucțiunea EXECUTE IMMEDIATE poate efectua operații DDL. De exemplu, următoarea procedură adaugă o locație de birou:

Următoarea procedură șterge o locație de birou:

Exemplu de interogare dinamică cu un singur rând

EXECUTE IMMEDIATE instrucțiunea poate efectua interogări dinamice cu un singur rând. Puteți specifica variabile de legare în clauza USING și puteți prelua rândul rezultat în ținta specificată în clauza INTO din instrucțiune.

Următoarea funcție preia numărul de angajați dintr-o anumită locație care efectuează o activitate specificată:

Exemplu de interogare dinamică pe mai multe rânduri

OPEN-FOR, FETCH și instrucțiunile CLOSE pot efectua interogări dinamice pe mai multe rânduri. De exemplu, următoarea procedură listează toți angajații cu o anumită activitate la o locație specificată:

SQL nativ dinamic față de pachetul DBMS_SQL

Oracle oferă două metode pentru utilizarea SQL dinamic în cadrul PL / SQL: SQL dinamic nativ și pachetul DBMS_SQL. SQL dinamic nativ vă permite să plasați instrucțiuni SQL dinamice direct în codul PL / SQL. Aceste instrucțiuni dinamice includ instrucțiuni DML (inclusiv interogări), blocuri anonime PL / SQL, instrucțiuni DDL, instrucțiuni de control al tranzacțiilor și instrucțiuni de control al sesiunii.

Pentru a procesa cele mai multe instrucțiuni SQL dinamice native, utilizați EXECUTE IMMEDIATE declarație. Cu toate acestea, pentru a procesa o interogare pe mai multe rânduri (instrucțiunea SELECT), utilizați OPEN-FOR, FETCH și CLOSE instrucțiuni.

Pachetul DBMS_SQL este o bibliotecă PL / SQL care oferă un API programatic pentru executați instrucțiuni SQL dinamic. Pachetul DBMS_SQL are interfețe programatice pentru a deschide un cursor, analiza un cursor, furniza legături etc. Programele care utilizează pachetul DBMS_SQL efectuează apeluri la acest pachet pentru a efectua operațiuni SQL dinamice.

Următoarele secțiuni oferă informații detaliate despre avantajele ambelor metode.

Avantajele SQL dinamic nativ

SQL dinamic nativ oferă următoarele avantaje față de DBMS_SQL pachet:

Ușurința de utilizare

SQL dinamic nativ este mult mai simplu de utilizat decât pachetul DBMS_SQL.Deoarece SQL dinamic nativ este integrat cu SQL, îl puteți utiliza în același mod în care utilizați în prezent SQL static în codul PL / SQL. În plus, codul SQL dinamic nativ este de obicei mai compact și mai lizibil decât codul echivalent care folosește pachetul DBMS_SQL.

DBMS_SQL pachetul nu este la fel de ușor de utilizat ca SQL dinamic nativ. Există multe proceduri și funcții care trebuie utilizate într-o succesiune strictă. De obicei, efectuarea operațiunilor simple necesită o cantitate mare de cod atunci când utilizați pachetul DBMS_SQL. Puteți evita această complexitate utilizând în schimb SQL dinamic nativ.

Tabelul 8-1 ilustrează diferența în cantitatea de cod necesară pentru a efectua aceeași operație folosind DBMS_SQL pachet și SQL dinamic nativ.

Tabelul 8-1 Compararea codurilor pachetului DBMS_SQL și SQL dinamic nativ

Îmbunătățiri ale performanței

Performanța SQL dinamic nativ în PL / SQL este comparabilă cu performanța SQL static, deoarece interpretul PL / SQL are suport încorporat pentru SQL dinamic nativ. Prin urmare, performanța programelor care utilizează SQL dinamic nativ este mult mai bună decât cea a programelor care utilizează pachetul DBMS_SQL. De obicei, instrucțiunile SQL dinamice native au performanțe de 1,5 până la 3 ori mai bune decât instrucțiunile echivalente care utilizează pachetul DBMS_SQL. Desigur, câștigurile dvs. de performanță pot varia în funcție de aplicație.

Pachetul DBMS_SQL se bazează pe un API procedural și, ca urmare, implică apeluri de procedură ridicate și cheltuieli de copiere a datelor. De exemplu, de fiecare dată când legați o variabilă, pachetul DBMS_SQL copiază variabila de legare PL / SQL în spațiul său pentru o utilizare ulterioară în timpul execuției. În mod similar, de fiecare dată când executați o preluare, mai întâi datele sunt copiate în spațiul gestionat de pachetul DBMS_SQL și apoi datele preluate sunt copiate, câte o coloană la un moment dat, în Variabile PL / SQL, rezultând în cheltuieli generale semnificative rezultate din copierea datelor. Spre deosebire, SQL dinamic nativ grupează pașii de pregătire, legare și execuție a instrucțiunilor într-o singură operație, ceea ce minimizează copierea datelor și suprasolicitarea apelurilor de procedură și îmbunătățește performanța.

Sfat privind performanța

Când utilizați fie SQL dinamic nativ, fie pachetul DBMS_SQL, puteți îmbunătăți performanța utilizând variabile de legare, deoarece utilizarea variabilelor de legare permite Oracle să partajeze un singur cursor pentru mai multe instrucțiuni SQL.

De exemplu, următorul cod SQL dinamic nativ nu utilizează variabile de legare:

Pentru fiecare variabilă my_deptno distinctă, se creează un nou cursor, care poate provoca disputa resurselor și performanțe slabe. În schimb, legați my_deptno ca variabilă de legare, ca în exemplul următor:

Aici, același cursor este reutilizat pentru valori diferite ale legării my_deptno, îmbunătățind astfel performanța și scalabilitatea.

Suport pentru tipuri definite de utilizator

SQL dinamic nativ acceptă toate tipurile acceptate de SQL static în PL / SQL. Prin urmare, SQL dinamic nativ oferă suport pentru tipurile definite de utilizator, cum ar fi obiectele definite de utilizator, colecțiile și REFs. Pachetul DBMS_SQL nu acceptă aceste tipuri definite de utilizator.

Suport pentru preluarea înregistrărilor

SQL dinamic nativ și SQL static ambele acceptă preluarea în înregistrări, dar Pachetul DBMS_SQL nu. Cu SQL dinamic nativ, rândurile rezultate dintr-o interogare pot fi preluate direct în înregistrări PL / SQL.

În exemplul următor, rândurile dintr-o interogare sunt preluate în emp_rec record:

Avantajele pachetului DBMS_SQL

Pachetul DBMS_SQL oferă următoarele avantaje față de SQL dinamic nativ:

Suport pentru programe de partea clientului

În prezent, pachetul DBMS_SQL este acceptat în programele de pe partea de client, dar SQL dinamic nativ nu este. Fiecare apel către pachetul DBMS_SQL din programul din partea clientului se traduce printr-un apel de procedură la distanță PL / SQL (RPC); aceste apeluri apar atunci când trebuie să legați o variabilă, să definiți o variabilă sau să executați o instrucțiune.

Suport pentru DESCRIBE

Procedura DESCRIBE_COLUMNS din pachetul DBMS_SQL poate fi utilizată pentru descrie coloanele unui cursor deschis și analizat prin DBMS_SQL. Funcționalitatea este similară cu comanda DESCRIBE din SQL * Plus. SQL dinamic nativ nu are o facilitate DESCRIBE.

Suport pentru Bulk Dynamic SQL

Bulk SQL este capacitatea de a procesa mai multe rânduri de date într-o singură instrucțiune DML. Bulk SQL îmbunătățește performanța prin reducerea numărului de comutări de context între SQL și limbajul gazdă. În prezent, pachetul DBMS_SQL acceptă SQL dinamic în bloc.

Deși nu există suport direct pentru operațiuni în bloc în SQL dinamic nativ, puteți simula un SQL în vrac dinamic nativ declarație plasând instrucțiunea SQL în bloc într-un bloc „BEGIN … END” și executând blocul dinamic. Această soluție vă permite să realizați beneficiile SQL în bloc în cadrul unui program SQL dinamic nativ. De exemplu, următorul cod SQL dinamic nativ copiază ename coloana unui tabel la altul:

Actualizări și ștergeri multiple de rânduri cu o clauză RETURNING

Pachetul DBMS_SQL acceptă instrucțiuni cu o clauză RETURNING care actualizează sau șterge mai multe rânduri. SQL dinamic nativ acceptă doar o clauză RETURNING dacă se returnează un singur rând.

Suport pentru instrucțiuni SQL Mai mari de 32 KB

DBMS_SQL pachetul acceptă instrucțiuni SQL mai mari de 32 KB; SQL dinamic nativ nu.

Reutilizarea instrucțiunilor SQL

Procedura PARSE din DBMS_SQL package analizează o instrucțiune SQL o singură dată. După analiza inițială, instrucțiunea poate fi utilizată de mai multe ori cu diferite seturi de argumente de legare.

În schimb, SQL dinamic nativ pregătește o instrucțiune SQL pentru executare de fiecare dată când este utilizată instrucțiunea. Pregătirea declarațiilor implică de obicei analiza, optimizarea și generarea planului. Pregătirea unei declarații de fiecare dată când este utilizată atrage o mică penalizare de performanță. Cu toate acestea, mecanismul de cursor partajat al Oracle minimizează costurile, iar penalizarea de performanță este de obicei banală în comparație cu beneficiile de performanță ale SQL dinamic nativ.

Exemple de coduri de pachete DBMS_SQL și cod SQL dinamic nativ

Următoarele exemple ilustrează diferențele în codul necesar pentru a finaliza operațiunile cu pachetul DBMS_SQL și SQL dinamic nativ. În mod specific, sunt prezentate următoarele tipuri de exemple:

• O interogare
• O operațiune DML
• O operațiune de returnare DML

În general, codul SQL dinamic nativ este mai ușor de citit și mai compact, ceea ce poate îmbunătăți productivitatea dezvoltatorilor.

Exemplu de interogare

Următorul exemplu include o instrucțiune de interogare dinamică cu o variabilă de legare (:jobname) și două coloane selectate (ename și sal):

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

Acest exemplu interogă pentru angajații cu j descriere ob SALESMAN în coloana job din tabelul emp. Tabelul 8-2 prezintă un exemplu de cod care realizează această interogare utilizând pachetul DBMS_SQL și SQL dinamic nativ.

Tabelul 8-2 Interogare utilizând pachetul DBMS_SQL și SQL dinamic nativ

Exemplu DML

următorul exemplu include o instrucțiune INSERT dinamică pentru un tabel cu trei coloane:

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

Acest exemplu introduce un rând nou pentru care valorile coloanei sunt în variabilele PL / SQL deptnumber, deptname și location. Tabelul 8-3 prezintă un exemplu de cod care realizează această operațiune DML utilizând pachetul DBMS_SQL și SQL dinamic nativ.

Tabelul 8-3 Operațiune DML utilizând pachetul DBMS_SQL și SQL dinamic nativ

Exemplu de returnare DML

Următorul exemplu include un UPDATE declarație care actualizează locația unui departament atunci când i se dă numărul departamentului (deptnumber) și o locație nouă (location), și apoi returnează numele departamentului:

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

Acest exemplu introduce un nou rând pentru care valorile coloanei sunt în variabilele PL / SQL deptnumber, deptname și location. Tabelul 8-4 prezintă un exemplu de cod care realizează această operațiune de returnare DML utilizând pachetul DBMS_SQL și SQL dinamic nativ.

Tabelul 8-4 Operațiune de returnare DML utilizând DBMS_SQL Pachet și SQL dinamic nativ

Limbaje de dezvoltare a aplicațiilor, altele decât PL / SQL

Până în prezent, discuția din acest capitol a fost despre suport PL / SQL pentru SQL dinamic.Cu toate acestea, puteți utiliza alte limbaje de dezvoltare a aplicațiilor pentru a implementa programe care utilizează SQL dinamic. Aceste limbaje de dezvoltare a aplicațiilor includ C / C ++, COBOL și Java.

Dacă utilizați C / C ++, puteți dezvolta aplicații care utilizează SQL dinamic cu interfața de apel Oracle (OCI) sau puteți utiliza precompilatorul Pro * C / C ++ pentru a adăuga extensii SQL dinamice în C cod. În mod similar, dacă utilizați COBOL, puteți utiliza precompilatorul Pro * COBOL pentru a adăuga extensii SQL dinamice la codul COBOL. Dacă utilizați Java, puteți dezvolta aplicații care folosesc SQL dinamic cu JDBC.

În trecut, singura modalitate de a utiliza SQL dinamic în aplicațiile PL / SQL era folosind DBMS_SQL pachet. Există o serie de limitări în utilizarea acestui pachet, inclusiv probleme de performanță. În consecință, dezvoltatorii de aplicații ar fi putut folosi una dintre alternativele la PL / SQL discutate mai sus pentru a implementa SQL dinamic. Cu toate acestea, odată cu introducerea SQL dinamic nativ în PL / SQL, multe dintre dezavantajele utilizării PL / SQL pentru SQL dinamic sunt acum eliminate.

Dacă aveți o aplicație care utilizează OCI, Pro * C / C ++ sau Pro * COBOL pentru execuția SQL dinamică, retururile de rețea necesare pentru efectuarea operațiunilor SQL dinamice pot afecta performanța. Deoarece aceste aplicații se află de obicei pe clienți, sunt necesare mai multe apeluri de rețea pentru a finaliza operațiuni SQL dinamice. Dacă aveți acest tip de aplicație, luați în considerare mutarea funcționalității SQL dinamice în proceduri stocate și funcții stocate în PL / SQL care utilizează SQL dinamic nativ. Acest lucru ar putea îmbunătăți performanța aplicației dvs., deoarece procedurile stocate pot locui pe server, eliminând astfel cheltuielile de rețea. Apoi puteți apela procedurile stocate PL / SQL și funcțiile stocate din aplicație.