Dināmiskais dzimtais (native) SQL un PL/SQL bloki

EXECUTE IMMEDIATE SQL_teksts[INTO mainīgais_1, mainīgais_2, ...][USING [IN | OUT | IN OUT] piesaist_mainīg_1, piesaist_manīg_2, ...][RETURNING INTO | RETURN piesaist_main_1, piesaist_main_2, ...]

Dināmiskā SQL nepieciešamība1. SQL komandu CREATE, GRANT), ALTER SESSION izpilde, kuras

nevar tieši ievietot PL/SQL komandās; 2. programmā noteiktu tabulu un kolonu nosaukumu un noteikumu

iekļaušana SQL komandās;

SQL teksts neietver beigās semikolonu (;).

PL/SQL bloka teksts ietver beigās semikolonu (;).

Dināmiskajā SQL var izmantot visus SQL datu tipus.

Dināmiskajā SQL nevar izmantot PL/SQL specifiskos tipus.

1

Dināmiskā SQL un PL/SQL tipiskākie piemēri

DECLARE sql_teksts varchar2(100); plsql_bloks varchar2(500); m_num number default 7; m_uzv varchar2(50) default 'Koks', m_alga number(7,2); type RAKSTA_TIPS is record(NUM number, UZV varchar2(50), ALGA number(8,2)); m_raksts RAKSTA_TIPS;begin EXECUTE IMMEDIATE 'create table DARBINIEKI(NUM number, UZV varchar2(50), ALGA number(8,2))'; sql_teksts := 'insert into DARBINIEKI values(:1, :2, :3)'; EXECUTE IMMEDIATE sql_teksts USING m_num, m_uzv, m_alga; sql_teksts := 'select * from DARBINIEKI where NUM = :id'; EXECUTE IMMEDIATE sql_teksts INTO m_raksts USING m_num; plsql_bloks := 'begin PAKETE_A.ALGAS_IEVADE(:id, :alga); end;'; EXECUTE IMMEDIATE plsql_bloks USING 7, 500; sql_teksts := 'UPDATE emp SET ALGA = 2000 WHERE empno = :1 RETURNING ALGA INTO :2'; EXECUTE IMMEDIATE sql_teksts USING m_num RETURNING INTO m_alga; EXECUTE IMMEDIATE 'delete from DARBINIEKI where NUM = :num' USING m_num; EXECUTE IMMEDIATE 'ALTER SESSION SET SQL_TRACE TRUE';end;

2

Tabulas nosaukuma un where rindas noteikuma norāde

create or replace procedure RAKSTU_DZESANA( tabulas_nosaukums IN varchar2, noteikums IN varchar2 default NULL) as where_rinda varchar2(100) := ' where ' || noteikums;begin if noteikums is NULL then where_rinda := NULL; end if; EXECUTE IMMEDIATE 'delete from' || tabulas_nosaukums || where_rinda;end;

Mainīgo (ieejas parametru) izmantošana INSERT komandā

create or replace procedure FIRMAS( p_num IN OUT number, p_nos IN varchar2, p_telef IN varchar2) asbegin select VIRKNE_A.NEXTVAL into NUM from DUAL; insert into FIRMAS values(p_num, p_nos, p_telef);end;

3

Dināmiska PL/SQL procedūra ar ieejas un izejas parametriem

declare m_plsql_bloks varchar2(500); m_num number(2); m_nos varchar2(14) default 'AAA'; m_telef varchar2(13);begin m_plsql_bloks := 'begin PROC_FIRMU_DATI(:a, :b, :c); end;'; EXECUTE IMMEDIATE m_plsql_bloks USING IN OUT m_num, m_nos, m_telef; if m_num > 90 then ...end;

Mainīgā izmantošana kursora mainīgajādeclare type KURS_MAIN_TIPS is REF cursor; m_kurs_main KURS_MAIN_TIPS; m_raksts DARBINIEKI%ROWTYPE; sql_teksts varchar2(200); m_amats varchar2(15) := 'galdnieks';begin sql_teksts := 'select * from DARBINIEKI where AMATS = :j'; open m_kurs_main for sql_teksts USING m_amats; loop fetch m_kurs_main into m_raksts; exit when m_kurs_main%NOTFOUND; -- turpmākās darbības

end loop; close m_kurs_main;end;

4

DECLARE sql_stmt VARCHAR2(100); plsql_block VARCHAR2(300); v_zip VARCHAR2(5) := '11106'; v_total_students NUMBER; v_new_zip VARCHAR2(5); v_student_id NUMBER := 151;BEGIN -- Create table MY_STUDENT sql_stmt := 'CREATE TABLE my_student '|| 'AS SELECT * FROM student WHERE zip = '||v_zip; EXECUTE IMMEDIATE sql_stmt;

-- Select total number of records from MY_STUDENT table -- and display results on the screen EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM my_student' INTO v_total_students; DBMS_OUTPUT.PUT_LINE ('Students added: '||v_total_students);

-- Select current date and display it on the screen plsql_block := 'DECLARE ' || 'v_date DATE; ' || 'BEGIN ' || 'SELECT SYSDATE INTO v_date FROM DUAL; ' || 'DBMS_OUTPUT.PUT_LINE (TO_CHAR(v_date, ''DD-MON- YYYY''));'|| 'END;'; EXECUTE IMMEDIATE plsql_block;

-- Update record in MY_STUDENT table sql_stmt := 'UPDATE my_student SET zip = 11105 WHERE student_id = :1 '|| 'RETURNING zip INTO :2'; EXECUTE IMMEDIATE sql_stmt USING v_student_id RETURNING INTO v_new_zip; DBMS_OUTPUT.PUT_LINE ('New zip code: '||v_new_zip);END;

5

Sākot ar Oracle7.1 dinamiska SQL atbalsts notiek ar DBMS_SQL paketi. Bet Oracle8i paradījas

papildus iespēja- iebūvēts dinamiskais SQL (Native Dynamic SQL, NDS), kas arī tiks apskatīts

šajā darbā.

NDS Instrukcijas Galvenais kas piemīt NDS ir tā vienkāršība, atšķirība no DBMS_SQL paketes, kur

nepieciešams zināt pietiekoši daudz informācijas, lai ielietotu dinamiska SQL iespējas, lietojot

DBMS_SQL paketi. NDS definēts PL/SQL vidē ar vienīgu jaunu konstrukciju EXECUTE

IMMEDIATE, kura uzreiz izpilda SQL-instrukciju, un arī ir OPEN FOR instrukcijas

paplašinājums, kurš atļauj izpildīt sarežģītus dinamiskus vaicājumus.

EXECUTE IMMEDIATE instrukcija Instrukcija EXECUTE IMMEDIATE, tiek lietota, lai nekavējoties izpildītu noteiktu SQL-

instrukciju, tā tiek definēta šādi:

EXECUTE IMMEDIATE SQL_vaicājums[INTRO {mainīgais[, mainīgais].... | ieraksts}][USING [IN | OUT | IN OUT] arguments

[, [IN | OUT | IN OUT] arguments]...];

Kur SQL_vaicājums- ir simbolu izteiksme, kura satur vaicājumu jeb SQL-instrukciju vai

PL/SQL bloku; mainīgais- mainīgais, kuram tiek piešķirs lauka saturs, kuru atgriež pats

vaicājums; ieraksts-ieraksts, tiek nozīmēts balstoties uz lietotāju noteiktu datu tipu vai tiek

noteikts ar atribūtu %ROWTYPE, kurš saņem vērtības no vaicājuma rezultāta rindas;

arguments- izteiksme, kuras vērtība tiek nozīmēta kā ienākošais parametrs SQL vaicājumam vai

PL/SQL blokam; INTO –teikums, kurš pielietojas vienrindu vaicājumu gadījumā(katram

vaicājuma rezultāta laukam ir jābūt noteikta atsevišķais mainīgais vai ir rezultāta rindai jāatbilst

ieraksta konstrukcija); USING- teikums nosaka SQL-instrukcijas parametrus dinamiskā SQL tā

arī dinamiskā PL/SQL(parametru pārraide tiek noteikta tikai PL/SQL, kurs pēc noklusējuma

uzstādīts parametru nodošanas veids IN).

Instrukcija EXECUTE IMMEDIATE var tikt pielietota, lai izpildītu jebkuru SQL-

instrukciju vai PL/SQL bloku, izņemot daudzrindu vaicājumus. Ja SQL-rinda beidzas ar

semikolu, tas tā tiek interpretēta kā PL/SQL bloks, citā gadījumā tiek saprasta kā datu

manipulāciju instrukcija DML(piemēram, CREATE TABLE). Rinda var saturēt formālus

parametrus, bet ar tiem nav iespējams uzdot shēmas objektu vārdus, piemēram, kā tabulas lauku

nosaukumi.

6

Izpildes laika Oracle kodols aizvieto parametrus (identifikatori, kuri sākas ar kolu,

piemēram :param1) ar noteiktām vērtībām. Ka parametru elementus drīkst uzdot izteiksmes,

kuras atgriež skaitļus, datumu un rindas, bet loģiskās izteiksmes uzdot nav iespējams, jo

loģiskais tips BOOLEAN tiek atbalstīts tikai PL/SQL vidē. Nav arī iespējams nododot vērtības

ar tipu NULL- tajā vieta ir nepieciešams noteikts mainīgo, kuram ir atbilstošs vērtības tips ar

pašu vērtību.

Iebūvētais dinamiskais SQL atbalsta visus SQL datu tipus. Mainīgie un ieraksti var būt

kā kolekcijas, LOB-objekti, objektu tipa eksemplāri un REF tipa. Bet NDS neatbalsta datu tipus,

kuri ir specifiski PL/SQL vidē, tādi kā BOOLEAN asociatīvie masīvi un lietotāju ierakstu tipi.

Teikumā INTO var tikt uzdots PL/SQL ieraksts.

Zemāk tiks apskatīti daži piemēri: kā izveidot indeksu, lietojot dinamisko SQL:

EXECUTE IMMEDIATE ‘CREATE INDEX emp_u_1 ON employee (last_name)’;

Ir jāpiekrīt, ka tas ir pietiekoši vienkārši.Iekšēja procedūra, kura izpilda jebkuru DDL instrukciju var nodefinēt šādi:

CREATE OR REPLACE PROCEDURE execDDL(ddl_string IN VARCHAR)ISBEGIN

EXECUTE IMMEDIATE ddl_string;END;

Kad procedūra tika izveidota var izveidot indeksu šādi:execDLL(‘CREATE INDEX emp_u_1 ON employee (last_name)’);

Zemāk tiks mēģināts iegūt rindiņu skaitu neradītai shēmai un nodefinētam teikumam WHERE:

CREATE OR REPLACE FUNCTION tabCount ( tab IN VARCHAR2, whr IN VARCHAR2 := NULL, sch IN VARCHAR2 := NULL) RETURN INTEGERIS retval INTEGER;BEGIN EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM ' || NVL (sch, USER) || '.' || tab || ' WHERE ' || NVL (whr, '1=1') INTO retval; RETURN retval;END;

Nākotnē vairs nebūs vajadzības rakstīt vaicājumu SELECT (*) ne SQL Plus vidē un arī

PL/SQL vidē. Lai saskaitītu rindiņu skaitu būs tikai jāizsauc šo funkciju no PL/SQL kodā:BEGIN

IF tabCount(‘emp’,’deptno= ‘ || v_dept)>100 THEN DBMS_OUTPUT(‘Ātri pieauga’);

7

END IFEND;

Nākošais piemērs paradis kā var izmainīt jebkuru skaitlisko vērtību jebkuram tabulas

laukam jebkurai tabulai:CREATE OR REPLACE FUNCTION updNVal ( tab IN VARCHAR2, col IN VARCHAR2, val IN NUMBER, whr IN VARCHAR2 := NULL, sch IN VARCHAR2 := NULL) RETURN INTEGERISBEGIN EXECUTE IMMEDIATE 'UPDATE ' || NVL (sch, USER) || '.' || tab || ' SET ' || col || ' = :the_value WHERE ' || NVL (whr, '1=1') USING val; RETURN SQL%ROWCOUNT;END;

Nav nekādu šaubu, ka tik mazs koda apjoms dod lielu priekšrocību un elastību daudzās

situācijās. Piemērā ir paradīts kā tiek izmantots aizvietojamais parametrs un pēc sintakses

pārbaudes tas tiek aizvietots ar savu vērtību. Ir jāpievērš uzmanību tam, ka kursora atribūtu SQL

%ROWCOUNT var tik pat droši izmantot kā SQL statiskā konstrukcijā (parastā konstrukcijā).

Nākošais dinamiskais SQL piemērs izpilda sekojošu darbību: pieņemsim, ka katru dienu

no 9 rīta ir nepieciešams izpildīt neteiktu iekšējo procedūru, kura veido oficiālu tikšanas laiku

grafiku kādam kompānijas darbiniekam. Šādas procedūras struktūra varēt izskatīties šādi:

DAYNAME_set_schedule. Kur simbolu rinda DAYNAME- atbilsts dienas nosaukumam nedēļā.

Katra šāda procedūra izmanto četrus vienus un tos pašus parametrus: ieejoši parametri:

darbinieka identifikators un pirmās tikšanas laiks, izejošie parametri: darbinieka vārds, tikšanas

reižu skaits. Piemērs zemāk parada kā to var realizēt:

CREATE OR REPLACE PROCEDURE run_9am_procedure ( id_in IN employee.employee_id%TYPE, hour_in IN INTEGER)IS v_apptcount INTEGER; v_name VARCHAR2 (100);BEGIN EXECUTE IMMEDIATE 'BEGIN ' || TO_CHAR (SYSDATE, 'DAY') || '_set_schedule (:id, :hour, :name, :appts); END;' USING IN id_in, IN hour_in, OUT v_name, OUT v_apptcount;

DBMS_OUTPUT.put_line ( 'Employee ' || v_name || ' has ' || v_apptcount

8

|| ' appointments on ' || TO_CHAR (SYSDATE) );END;

OPEN FOR Instrukcija

Šī instrukcija pirmo reizi parādījās Oracle7 versijā un tās uzdevums bija kursoru-mainīgo

apstrāde. Vēlāk tās sintakses papildināja, lai varētu apstrādāt daudzrindu dinamiskus vaicājumus.

Jo šādu vaicājumu izpilde un pielietošana, lietojot DBMS_SQL paketi, bija sarežģīts un

darbietilpīgs uzdevums: vispirms ir nepieciešams veikts sintaksisko analīzi ar turpmāko

aizvietošanu, atsevišķi noteikt katru lauku, izpildīt instrukciju, atlasīt iegūtas rindiņas lauku

vērtības. Tātad programmas apjoms ir pietiekoši liels.

Dinamiskam SQL Oracle izstrādātāji saglabāja OPEN FOR sintaksi piemērojot to

dinamiskam SQL:

OPEN {kursora-mainīgais | host_kursora_mainīgais } FOR SQL_rinda[USING arguments [, arguments] ... ];

Kur kursora-mainīgais vāji tipizēts kursora-mainīgais, host_kursora_mainīgais – kursora-

mainīgais, kas ir definēts PL/SQL host-vidē, SQL_rinda – SELECT instrukcija, kuru ir

dinamiski jāizpilda; USING- tāds pats teikums kā EXECUTE IMMEDIATE operatoram.

Sekojošā piemērā tiks nodefinēts tips REF CURSOR un mainīgai ar šādu tipu, bet pēc

tam ar operatoru OPEN FOR tiks izpildīts dinamiskais vaicājums:

CREATE OR REPLACE PROCEDURE show_parts_inventory(Parts_table IN VARCHAR2,Where_in IN VARCHAR2 :=NULL)

ISTYPE query_curtype IS REF CURSOR;Dyncur query_curtype;

BEGINOPEN dyncur FOR

‘SELECT * FROM ‘ || parts_table‘WHERE ’ || NVL (where_in, ‘1=1’);

....

Tālāk ir jāizpilda visas tādas pašas darbības kā ar parasto kursoru: tiek atlasīti vaicājuma

rindiņas, kursora-mainīga atvēršana un kursora-mainīga vērtību nolasīšana. Sīkāk šīs darbības

tiks paradītas nākošā sadaļā.

9

Kursoru-maingo daudzrindu vaicājumi

PL/SQL kodols konstrukciju OPEN FOR izpilda sekojošā veidā:

1. Kodols sasaista kursora-mainīgo ar SQL konstrukciju, kura iz uzdota SQL rindā;

2. Izskaitļo aizvietojamo parametru vērtības un nomaina ar tiem formālus parametrus

vaicājuma rindā;

3. Izpilda vaicājumu;

4. Identificē rezultātu kopu;

5. Novieto kursoru uz pirmo rezultātu kopas rindu;

6. Piešķir nolasītu rindiņu skaitītājam vērtību nulle, kuru atgriež atribūts %ROWCOUNT

Ir jāuzsver tas, ka aizvietojamiem parametri, kuri nodefinēti teikumā USING, tiek

aprēķinātas tad, kad kursors tiek atvērts. Tas nozīme, ka lai nodotu tam pašam dinamiskam

vaicājumam jaunas parametru vērtības ir jāizpilda jaunu OPEN FOR operatoru.

Vaicājumam, kurš atgriež rindu kopu ir nepieciešams izpildīt sekojošās darbības:

1. Nodefinēt REF CURSOR tipu (ja tas vel nav nodefinēts) un nodefinēt mainīgo ar

šo tipu.

2. Noteikts vaicājuma rindu un parametrus, tad atvērt kursora-mainīgo;

3. Ar FETCH operatoru palīdzību iegūt pa vienai rindiņai no rezultātu kopas.

4. Tad ja ir nepieciešamība pārbaudīt atribūtu vērtības: %FOUND, %NOTFOUND,

%ROWCOUNT, %ISOPEN);

5. Aizvērt kursora-mainīgo ar CLOSE operatoru.

Nākošais piemērs parada programmu, kura attēlo lauku vērtības uzdotai tabulai rindu

veidā, kur tiek izmantots teikums WHERE (lauks var saturēt skaitļus, datumus vai burtus):CREATE OR REPLACE PROCEDURE showcol ( tab IN VARCHAR2, col IN VARCHAR2, whr IN VARCHAR2 := NULL)IS TYPE cv_type IS REF CURSOR; cv cv_type; val VARCHAR2(32767); BEGIN OPEN cv FOR 'SELECT ' || col || ' FROM ' || tab || ' WHERE ' || NVL (whr, '1 = 1'); LOOP FETCH cv INTO val; EXIT WHEN cv%NOTFOUND;

10

IF cv%ROWCOUNT = 1 THEN DBMS_OUTPUT.PUT_LINE (RPAD ('-', 60, '-')); DBMS_OUTPUT.PUT_LINE ( 'Contents of ' || UPPER (tab) || '.' || UPPER (col)); DBMS_OUTPUT.PUT_LINE (RPAD ('-', 60, '-')); END IF; DBMS_OUTPUT.PUT_LINE (val); END LOOP; CLOSE cv;END;

Datu nolasīšana mainīgos vai ieraktos(record)

Instrukcija FETCH, augstāk minēta piemērā, nolasīja datus un piešķīra tos skalāram

mainīgam. Ja rezultātu kopa satur vairākus laukus to vērtības var piešķirt vairākiem atsevišķiem

mainīgiem.

DECLARETYPE cv_type IS REF CURSOR;cv cv_type;mega_bucks company.ceo_compensation%TYPE;arhived_by company.cost_cutting%TYPE;

BEGINOPEN cv FOR ‘SELECT ceo_compensation, cost_cutting

FROM companyWHERE ‘ || NVL (whr, ‘1=1’);

LOOPFETCH cv INTO mega_buck, achieved_by;

Bet strādāt ar lielu mainīgu sarakstu nav ērti jo tos ir jāsinhronizē ar SQL instrukciju un

ttl. Dinamiskais SQL atrisina šo problēmu, nolasot datus ieraksta struktūrā, kas ir paradīts

piemērā:

DECLARETYPE cv_type IS REF CURSOR;cv cv_type;ceo_info company%ROWTYPE;

BEGINOPEN cv FOR ‘SELECT *

FROM companyWHERE ‘ || NVL (whr, ‘1=1’);

LOOPFETCH cv INTO ceo_info;

Protams, SELECT * instrukcija nav optimāla visos gadījumos datu izgūšanā, jo tabula

var saturēt ļoti lielu lauku skaitu, tad kad kodā ir nepieciešams vērības tikai dažiem no laukiem.

11

Tādēļ ir nepieciešams izveidot atsevišķus datus tipus , kuri atbilst prasībām. Tos ir ērti ievietot

paketē un izmantot to no dažādiem programmas koda vietām. Piemērs parada kā to var realizēt:

CREATE OR REPLACE PAKAGE company_structIS

TYPE dynsql_curtype IS REF CURSOR;TYPE ceo_info_rt IS RECORD(

Mega_bucks company.ceo_compensatio%TYPE,achieved _by company.cost_cutting%TYPE);

END company_struct;

Tad kodu var pārrakstīt šādi:

DECLARECur company_struct.dynsql_curtype;Rec company_struct.ceo_info_rt;

BEGINOPEN cv FOR ‘SELECT ceo_compensation, cost_cutting

FROM companyWHERE ‘ || NVL (whr, ‘1=1’);

LOOPFETCH cv INTO rec;

Using teikums OPEN FOR instrukcijā

Konstrukcijā OPEN FOR, tāpat, kā EXECUTE IMMEDIATE, var uzdot SQL

instrukcijas parametrus. Bet ir jāuzsver, ka veidojot parametrus ir iespējams tos uzdot tikai IN

veidā. Vaicājumu parametru izmantošana dod iespēju daudz kārt samazināt instrukciju

daudzumu, kuri tiek kušeti SGA atmiņā. Un šādu vaicājumu izmantošana atvieglo daudzu

problēmu atrisinājumu.

Atgriežoties pie procedūras showcol, kurā varēja uzdot patvaļīgu teikumu WHERE.

Konkretizējot prasības procedūrai, ir nepieciešams ievadīt informāciju tiem tabulas laukiem,

kuriem ir datuma vērtība noteiktajā periodā. Īsi sākot, ir nepieciešamība izpildīt sekojošu

vaicājumu:

SELECT enameFROM empWHERE hiredate BETWEEN x AND y;

vai šādu:

SELECT flavourFROM favoritiesWHERE preference_period BETWEEN x AND y;

Šeit ir ļoti svarīgi, lai nosacījumā WHERE netiktu uzskaitīts laika komponente. Piemēram:CREATE OR REPLACE PROCEDURE showcol ( tab IN VARCHAR2,

12

col IN VARCHAR2, dtcol IN VARCHAR2, dt1 IN DATE, dt2 IN DATE := NULL)IS TYPE cv_type IS REF CURSOR; cv cv_type; val VARCHAR2(32767); BEGIN OPEN cv FOR 'SELECT ' || col || ' FROM ' || tab || ' WHERE ' || dtcol || ' BETWEEN TRUNC (:startdt) AND TRUNC (:enddt)' USING dt1, NVL (dt2, dt1+1); LOOP FETCH cv INTO val; EXIT WHEN cv%NOTFOUND; IF cv%ROWCOUNT = 1 THEN DBMS_OUTPUT.PUT_LINE (RPAD ('-', 70, '-')); DBMS_OUTPUT.PUT_LINE ( 'Contents of ' || UPPER (tab) || '.' || UPPER (col) || ' for ' || UPPER (dtcol) || ' between ' || dt1 || ' and ' || NVL (dt2, dt1)); DBMS_OUTPUT.PUT_LINE (RPAD ('-', 70, '-')); END IF; DBMS_OUTPUT.PUT_LINE (val); END LOOP; CLOSE cv;END;/

Instrukcijā OPEN FOR tiek uzdots vaicājums ar diviem formāliem parametriem un

atbilstošam USING teikumam:

OPEN cv FOR 'SELECT ' || col || ' FROM ' || tab || ' WHERE ' || dtcol || ' BETWEEN TRUNC (:startdt) AND TRUNC (:enddt)' USING dt1, NVL (dt2, dt1+1);

Parametri teikuma USING tika noteikti tādā veidā, lai gadījuma ja lietotājs neuzdos

beidzamo datumu un teikums WHERE atgrieztu rindas ar datumu nodarīto parametrā dt1. Pāreja

procedūras daļa netika mainīta ja neskaitīt dažas nelielas modifikācijas, kas ir saistītas ar lauka

nosākumu izvadīšanu.

13

Parametru nodošana dinamiskai SQL konstrukcijai

Dinamiskais SQL izmanto divus atšķirīgus veidus kā nodot ārējos parametrus

dinamiskam SQL. Pirmais veids saucās aizvietošana, kad parametri tiek aizvietoti ar to vērtībām

pirms SQL vaicājums tiek izpildīts; otrs veids ir – konkatenācija, ka parametru vērtības tiek

pievienotas SQL rindai un ja parametru tips nav rindas tips, tad ir nepieciešams konvertēt

parametru vērtību rindas tipā.

Parametru aizvietošanas piemērs:

EXECUTE IMMEDIATE‘UPDATE’ || tab‘SET sal=:new_sal’USING v_sal /* v_sal ir mainīgais izpildāma procedūra vai funkcija bloka, kas sākas ar atslēgvārdu BEGIN un beidzas ar END; */

Konkatenācija piemērs:

EXECUTE_IMMEDIATE‘UPDATE’ || tab‘SET sal=’ || v_sal;/* || - zīme nosaka konkatenācija

Aizvietošana izmanto formālus parametrus un šajā gadījumā ir nepieciešams teikumu

USING, caur kuru arī nodot faktiskus parametrus. Parametru aizvietošana paātrina programmas

ātrdarbību. SQL instrukcija ar formāliem parametriem nosaka tikai to, kur izvietosies parametri,

nevis pašus parametru. Tādēļ vienā instrukcija var nodot dažādus parametru vērtības laikā,

nemainot to konstrukciju. Tādēļ lietojumā var izmantot kursorus, kuri tika iepriekš sagatavoti un

kešeti sistēmas datu bāzes globālajā apgabalā (SGA).

Otrkārt aizvietošanas metode, daudz lielāk vienkāršo dinamisko SQL instrukciju. Un to ir

vienkāršāk izprast vai labot. Nododot instrukcijai formālus parametrus nav nepieciešams

konvertēt rindas datu tipā –NDS kodols pats izdara visu nepieciešamo. Bet konkatenācija

gadījumā dažkārt nepieciešams rakstīt patiekoši sarežģītas rindu izteiksmes, kas potenciāli r

kļūdu avoti. Piemērām:

/* Parametru aizvietošanas pielietojums */EXECUTE IMMEDIATE‘UPDATE employee SET salary=:valWHERE hire_date BETWEEN :lodate AND :hidate’USING val, v_start, v_end;

/*Konkatenācijas pielietojums */ EXECUTE IMMEDIATE‘UPDATE employee SET salary= ’ || val_in ||‘WHERE hire_date BETWEEN ’ ||

‘TO_DATE (``` || TO_CHAR (v_start) || ```)` ||

14

‘AND ’ ||‘TO_DATE (``` || TO_CHAR (v_end) ||’ ```)’;

Parametru aizvietošanās metodes lietošanās ierobežojumi

SQL instrukcijas aizvietojamo parametru vērtības var būt mainīgo vērtības, izteiksmes,

un rindas, bet nedrīkst izmantot datu bāzes shēmas objektu nosaukumus (tabulas, laukus un ttl.).

Lai tomēr to varētu izdarīt ir nepieciešams lietot konkatenāciju.

Pieņemsim, ka ir nepieciešama procedūra, kura ar TRUNCATE instrukciju notīra uzdotu

tabulu vai skatu. Viens no šāda procedūras veidiem ir paradīts piemērā:

CREATE OR REPLACE PROCEDURE truncobj (nm IN VARCHAR2,tp IN VARCHAR:=’TABLE’,sch IN VARCHAR2:=NULL)ISBEGIN

EXECUTE IMMEDIATE‘TRUNCATE :trunc_type :obj_name’USING tp, NVL (shc, USER) || ‘.’ || nm;

END;

Pirmā skatienā šīs kods ir pareizs, bet ja to mēģināt izpildīt, tiks paziņots par kļūdu:ORA-0390: invalid truncate command- missing CKUSTER or TABLE keyword

Tad instrukcija tiek vienkāršota:

EXECUTE IMMEDIATE ‘TRUNCATE TABLE :obj_name’ USING nm;

Un tā pat tiks paziņots par kļūdu:

ORA-00903: invalid table name

Kādēļ NDS (un arī DBMS_SQL pakete) ir šāds ierobežojums? Nododot rindu

EXECUTE IMMEDIATE operatoram, kodols vispirms jāizpilda instrukcijas sintētisko analīzi,

lai būt pārliecinātam, ka nākoša instrukcija ir uzdota pareizi, pat nezinot :xyz parametra vērtību:

‘UPDATE emp SET sal=:xyz’, bet vai nākoša konstrukcija ir pareiza-kodols nemācēs pateikt:

‘UPDATE emp SET :colname=:xyz’.

Ja :col_name parametru vietā tiks ievietota vērtība, kuras tiešam var neeksistēt- iznāks

sintaksiski nepareiza, tādēļ šajā gadījumā ir nepieciešams izmantot konkatenāciju:

CREATE OR REPLACE PROCEDURE truncobj (nm IN VARCHAR2,tp IN VARCHAR:=’TABLE’,sch IN VARCHAR2:=NULL)IS

15

BEGINEXECUTE IMMEDIATE‘TRUNCATE ’ || tp || ‘ ’ NVL (shc, USER) || ‘.’ || nm;

END;

Aizvietojamo parametru lietošanas režīmi

Nododot parametrus SQL instrukcijai var lietot vienu no trim veidiem: IN (tikai lasīšana,

pēc noklusējuma), OUT (tikai rakstīšanai) un IN OUT (lasīšana un ierakstīšana). Kad tiek

izpildīts dinamiskais vaicājums, visi SQL instrukcijas parametri, izslēdzot teikuma

RETURNING parametru, tiek nodoti IN režīmā.

CREATE OR REPLACE PROCEDURE wrong_intcentive(Company_in IN INTEGER,New_layoffs IN NUMBER)

ISSql_string VARCHAR2(2000);Sal_after_layoffs NUMBER;

BEGINSql_string:= ‘UPDATE ceo_compensation

SET salary = salary +10 * :layoffsWHERE company_id= :companyRETURNING salary INTO :newsal’;

EXECUTE IMMEDIATE sql_stringUSING new_layoffs, company_in, OUT sal_after_layoffs;

DBMS_OUTPUT(‘CEO compensation after latest round of layoffs $’ ||

sal_after_layoffs);END;

SQL- instrukcijas aizvietojamie parametri, kuri tiek nodoti OUT un IN OUT režīmos,

pirmkārt, tiek pielietoti izpildot dinamisko PL./SQL. Šajā gadījumā parametru nodošanas režīmi

var būt tādi paši kā PL/SQL programmai.

Zemāk ir rekomendācijas, kas attiecās uz teikumu USING, kad tiek izpildīts dinamiskais

PL/SQL:

Aizvietojamais parametrs, kurš tiek nodots IN režīma var piederēt šādiem tipiem:

literārām vērtībām, konstantēm, mainīgiem vai izteikumiem. Parametrs vispirms tiek

aprēķināts un tikai tad nodots PL/SQL dinamiskam blokam;

Dinamiskās instrukcijas parametru vērtībai, kura tiek nodota OUT vai IN OUT režīmā ir

nepieciešams nodefinēt mainīgo;

Vērtības dinamiskā SQL var aizvietot, tikai tādā gadījumā ja elementa datu tipu atbalsta

SQL. Piemēram, ja procedūras parametriem ir BOOLEAN tips, to vērtību nevar uzdot ar

teikuma USING palīdzību.

16

PROCEDURE analyze_new_tehnology (Tech_name IN VARCHAR2,Analysis_year IN INTEGER,Number_of_adherents IN OUT NUMBER,Project_revenue OUT NUMBER,).... ;

Aprakstīta procedūra ir četri parametri, tad USING teikumam arī ir jābūt četriem

elementiem atdalītiem ar komatiem. Piemēram, diviem parametriem, kuri tiek nodoti IN režīmā,

vērtībām literārām izteiksmēm, bet nākošiem diviem elementu vērtībām jābūt uzdotiem ar

mainīgiem OUT un IN OUT režīmos.

Zemāk kā ir redzams šīs procedūras turpinājums:

DECLAREDevoted_followers NUMBER;Est_revenue NUMBER;

BEGINEXECUTE IMMEDIATE‘BEGINanalyze_new_tehnology (:p1, :p2, :p3, :p4); END;’

USING ‘Java’, 2002, devoted_followers, est_reveue;END;

17