PL/SQL - PL/SQL
PL / SQL ( eljárási nyelv SQL) az Oracle Corporation által eljárási kiterjesztése az SQL és a Oracle relációs adatbázis . PL / SQL kapható az Oracle Database (mivel 6-os verzió - a tárolt PL / SQL eljárások / függvények / packages / kiváltó verzió óta 7), Times Ten in-memória adatbázis (verzió óta 11.2.1), valamint az IBM DB 2 (verzió óta 9.7). Az Oracle Corporation általában kiterjeszti a PL/SQL funkciókat az Oracle Database minden egyes kiadásával.
A PL/SQL olyan eljárási nyelvi elemeket tartalmaz, mint a feltételek és a ciklusok . Lehetővé teszi az állandók és változók , eljárások és függvények, az ilyen típusú típusok és változók, valamint a triggerek deklarálását . Képes kezelni a kivételeket (futásidejű hibákat). A tömbök támogatottak PL/SQL gyűjtemények használatával. Az Oracle Database 8-as verziójától kezdődő implementációk az objektum-orientációhoz kapcsolódó funkciókat tartalmaztak . Létrehozhatunk PL/SQL egységeket, például eljárásokat, funkciókat, csomagokat, típusokat és triggereket, amelyeket az adatbázisban tárolnak az Oracle Database bármely programozási felületét használó alkalmazások.
Történelmileg a PL/SQL definíció első nyilvános változata 1995 -ben, az Oracle kezdeti éve pedig 1992 volt. Megvalósítja az ISO SQL/PSM szabványt.
PL/SQL programegység
Az SQL fő jellemzője (nem eljárási) egyben az SQL hátránya is: nem használhatunk vezérlő utasításokat ( döntéshozatali vagy iteratív ellenőrzés ), ha csak SQL-t kell használni. A PL/SQL alapvetően egy eljárási nyelv, amely biztosítja a döntéshozatalt, az iterációt és még sok más funkciót, mint más eljárási programozási nyelvek. A PL/SQL programegység a következők egyike: PL/SQL névtelen blokk, eljárás , függvény , csomag specifikáció, csomag törzs, trigger, típus specifikáció, típus törzs, könyvtár. A programegységek azok a PL/SQL forráskódok, amelyeket az adatbázis összeállít, kifejleszt és végül végrehajt.
PL/SQL névtelen blokk
A PL/SQL forrásprogram alapegysége a blokk, amely a kapcsolódó deklarációkat és utasításokat csoportosítja. A PL/SQL blokkot a DECLARE, BEGIN, EXCEPTION és END kulcsszavak határozzák meg. Ezek a kulcsszavak a blokkot deklaratív részre, végrehajtható részre és kivételkezelő részre osztják. A deklarációs szakasz nem kötelező, és felhasználható állandók és változók meghatározására és inicializálására. Ha egy változót nem inicializálnak, akkor alapértelmezés szerint NULL értékre áll. Az opcionális kivételkezelő rész a futási idő hibáinak kezelésére szolgál. Csak a végrehajtható rész szükséges. Egy blokknak lehet címkéje.
Például:
<<label>> -- this is optional
DECLARE
-- this section is optional
number1 NUMBER(2);
number2 number1%TYPE := 17; -- value default
text1 VARCHAR2(12) := 'Hello world';
text2 DATE := SYSDATE; -- current date and time
BEGIN
-- this section is mandatory, must contain at least one executable statement
SELECT street_number
INTO number1
FROM address
WHERE name = 'INU';
EXCEPTION
-- this section is optional
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Error Code is ' || TO_CHAR(sqlcode));
DBMS_OUTPUT.PUT_LINE('Error Message is ' || sqlerrm);
END;
A szimbólum :=funkcionál értékadó operátor tárolni egy értéket egy változó.
A blokkok beágyazhatók - azaz mivel a blokk egy végrehajtható utasítás, megjelenhet egy másik blokkban, ahol a végrehajtható utasítás megengedett. A blokk beküldhető egy interaktív eszköznek (például SQL*Plus), vagy beágyazható egy Oracle Precompiler vagy OCI programba. Az interaktív eszköz vagy program egyszer futtatja a blokkot. A blokkot nem tárolja az adatbázis, és ezért névtelen blokknak nevezik (még akkor is, ha címkével rendelkezik).
Funkció
A PL/SQL függvény célja általában egyetlen érték kiszámítása és visszaadása. Ez a visszaadott érték lehet egyetlen skaláris érték (például szám, dátum vagy karakterlánc) vagy egyetlen gyűjtemény (például beágyazott táblázat vagy tömb). A felhasználó által definiált funkciók kiegészítik az Oracle Corporation beépített funkcióit.
A PL/SQL függvény formája:
CREATE OR REPLACE FUNCTION <function_name> [(input/output variable declarations)] RETURN return_type
[AUTHID <CURRENT_USER | DEFINER>] <IS|AS> -- heading part
amount number; -- declaration block
BEGIN -- executable part
<PL/SQL block with return statement>
RETURN <return_value>;
[Exception
none]
RETURN <return_value>;
END;
A csővonallal ellátott táblázati függvények gyűjteményeket adnak vissza, és a következő formát öltik:
CREATE OR REPLACE FUNCTION <function_name> [(input/output variable declarations)] RETURN return_type
[AUTHID <CURRENT_USER | DEFINER>] [<AGGREGATE | PIPELINED>] <IS|USING>
[declaration block]
BEGIN
<PL/SQL block with return statement>
PIPE ROW <return type>;
RETURN;
[Exception
exception block]
PIPE ROW <return type>;
RETURN;
END;
Egy függvény csak az alapértelmezett IN típusú paramétert használja. A függvény egyetlen kimeneti értéke legyen a visszaadott érték.
Eljárás
Az eljárások hasonlítanak a funkciókhoz, mivel olyan programegységeknek nevezik őket, amelyek többször is meghívhatók. Az elsődleges különbség az, hogy a függvények használhatók egy SQL utasításban, míg az eljárások nem . Egy másik különbség az, hogy az eljárás több értéket is visszaadhat, míg a függvénynek csak egyetlen értéket kell visszaadnia.
Az eljárás egy kötelező címsorral kezdődik, amely tartalmazza az eljárás nevét és opcionálisan az eljárásparaméterek listáját. Ezután következnek a kijelentő, végrehajtható és kivételkezelő részek, mint a PL/SQL névtelen blokkban. Egy egyszerű eljárás így nézhet ki:
CREATE PROCEDURE create_email_address ( -- Procedure heading part begins
name1 VARCHAR2,
name2 VARCHAR2,
company VARCHAR2,
email OUT VARCHAR2
) -- Procedure heading part ends
AS
-- Declarative part begins (optional)
error_message VARCHAR2(30) := 'Email address is too long.';
BEGIN -- Executable part begins (mandatory)
email := name1 || '.' || name2 || '@' || company;
EXCEPTION -- Exception-handling part begins (optional)
WHEN VALUE_ERROR THEN
DBMS_OUTPUT.PUT_LINE(error_message);
END create_email_address;
A fenti példa önálló eljárást mutat be - az ilyen típusú eljárást a CREATE PROCEDURE utasítás használatával hozza létre és tárolja egy adatbázis -sémában. PL/SQL csomagban is létrehozható egy eljárás - ezt hívják csomag eljárásnak. A PL/SQL névtelen blokkban létrehozott eljárást beágyazott eljárásnak nevezzük. Az adatbázisban tárolt önálló vagy csomag eljárásokat " tárolt eljárásoknak " nevezzük .
Az eljárásoknak háromféle paramétere lehet: IN, OUT és IN OUT.
- Az IN paraméter csak bemenetként használható. Az IN paramétert referenciaként továbbítják, bár az inaktív program megváltoztathatja.
- Az OUT paraméter kezdetben NULL. A program hozzárendeli a paraméter értékét, és ezt az értéket visszaadja a hívó programnak.
- Az IN OUT paraméter kezdeti értéke lehet, vagy nem. Ezt a kezdeti értéket a hívott program módosíthatja vagy nem. A paraméteren végrehajtott módosítások alapértelmezésben visszakerülnek a hívó programhoz másolás útján, de - a NO -COPY jelzéssel - hivatkozással továbbíthatók .
A PL/SQL külső eljárásokat is támogat az Oracle adatbázis szabványos ext-procfolyamatán keresztül.
Csomag
A csomagok fogalmilag összekapcsolt függvények, eljárások, változók, PL/SQL tábla és rekord TYPE utasítások, állandók, kurzorok stb. Csoportjai. A csomagok használata elősegíti a kód újrafelhasználását. A csomagok a csomag specifikációiból és egy opcionális csomagtestből állnak. A specifikáció az alkalmazás interfésze; az elérhető típusokat, változókat, állandókat, kivételeket, kurzorokat és alprogramokat deklarálja. A törzs teljesen meghatározza a kurzorokat és alprogramokat, és így végrehajtja a specifikációt. A csomagok két előnye:
- Moduláris megközelítés, üzleti logika beágyazása/elrejtése, biztonság, teljesítményjavítás, újrafelhasználhatóság. Támogatják az objektum-orientált programozási funkciókat, például a funkciók túlterhelését és a beágyazást.
- A csomagváltozók használatával deklarálhatók a munkamenet szintű (hatókörű) változók, mivel a csomag -specifikációban deklarált változóknak munkamenet -hatóköre van.
Trigger
Az adatbázis -trigger olyan, mint egy tárolt eljárás, amelyet az Oracle Database automatikusan meghív, amikor egy adott esemény bekövetkezik. Ez egy elnevezett PL/SQL egység, amelyet az adatbázis tárol, és többször is meghívható. A tárolt eljárással ellentétben engedélyezheti és letilthatja az aktiválást, de nem hívhatja meg kifejezetten. Amíg az aktiválási szabály engedélyezve van, az adatbázis automatikusan meghívja azt - azaz a trigger aktiválódik -, amikor a kiváltó esemény bekövetkezik. Bár a trigger le van tiltva, nem indul el.
A CREATE TRIGGER utasítással aktiválható trigger. A kiváltó eseményt a kiváltó utasítások és az azok alapján végrehajtott elemek alapján határozza meg. A ravaszt állítólag az elemen hozzák létre vagy határozzák meg - ez vagy táblázat, nézet , séma vagy adatbázis. Meghatározza az időzítési pontot is, amely meghatározza, hogy a trigger aktiválódik -e az aktiváló utasítás futtatása előtt vagy után, és hogy minden egyes sorra aktiválódik -e, amelyet az aktiváló utasítás befolyásol.
Ha a trigger egy táblán vagy nézeten jön létre, akkor a kiváltó esemény DML -utasításokból áll, és a trigger -t DML -triggernek hívják. Ha a trigger az sémán vagy az adatbázison jön létre, akkor a kiváltó esemény vagy DDL vagy adatbázis -művelet utasításokból áll, és az aktiválást rendszerindítónak nevezik.
Az INSTEAD OF trigger vagy: egy nézetben létrehozott DML -trigger, vagy egy CREATE utasításban definiált rendszerindító. Az adatbázis az INSTEAD OF trigger -t aktiválja a trigger utasítás futtatása helyett.
A kiváltók célja
A triggerek a következő célokra írhatók:
- Egyes származtatott oszlopértékek automatikus generálása
- A referenciális integritás érvényesítése
- Eseménynaplózás és az asztalok elérésével kapcsolatos információk tárolása
- Könyvvizsgálat
- A táblázatok szinkron replikációja
- Biztonsági jogosultságok előírása
- Az érvénytelen tranzakciók megelőzése
Adattípusok
A PL/SQL fő adattípusai a NUMBER, CHAR, VARCHAR2, DATE és TIMESTAMP.
Numerikus változók
variable_name number([P, S]) := 0;
Egy numerikus változó meghatározásához a programozó hozzáfűzi a NUMBER típusú változót a névdefinícióhoz . Az (opcionális) pontosság (P) és az (opcionális) skála (S) megadásához ezeket még kerek zárójelbe is lehet tenni, vesszővel elválasztva. (A "pontosság" ebben az összefüggésben a változó által eltartható számjegyek számát jelenti, a "skála" pedig a számjegyek számát, amelyek követhetik a tizedespontot.)
A numerikus változók egyéb adattípusai a következők lehetnek: bináris_float, bináris_double, dec, decimális, kettős pontosság, float, egész, int, numerikus, real, small-int, binary_integer.
Karakterváltozók
variable_name varchar2(20) := 'Text';
-- e.g.:
address varchar2(20) := 'lake view road';
A karakterváltozó definiálásához a programozó általában hozzáfűzi a VARCHAR2 típusú változót a névdefinícióhoz. A zárójelben a változók által eltárolható karakterek maximális száma szerepel.
A karakterváltozók egyéb adattípusai a következők: varchar, char, long, raw, long raw, nchar, nchar2, clob, blob és bfile.
Dátum változók
variable_name date := to_date('01-01-2005 14:20:23', 'DD-MM-YYYY hh24:mi:ss');
A dátumváltozók dátumot és időt tartalmazhatnak. Az idő kimaradhat, de nincs lehetőség olyan változó meghatározására, amely csak az időt tartalmazza. Nincs DATETIME típus. És van egy TIME típus. De nincs olyan TIMESTAMP típus, amely finomszemcsés időbélyeget tartalmazhat akár ezredmásodpercig vagy nanoszekundumig. Oracle adattípusok
A TO_DATEfunkció segítségével a karakterláncok dátumértékekké konvertálhatók. A függvény az első idézett karakterláncot dátummá alakítja, meghatározásként a második idézett karakterláncot használva, például:
to_date('31-12-2004', 'dd-mm-yyyy')
vagy
to_date ('31-Dec-2004', 'dd-mon-yyyy', 'NLS_DATE_LANGUAGE = American')
A dátumok karakterláncokká alakításához használja a függvényt TO_CHAR (date_string, format_string).
A PL/SQL támogatja az ANSI dátum- és intervallum literálok használatát is. A következő pont 18 hónapos időtartamot ad meg:
WHERE dateField BETWEEN DATE '2004-12-30' - INTERVAL '1-6' YEAR TO MONTH
AND DATE '2004-12-30'
Kivételek
A kivételek-a kódfuttatás során fellépő hibák-két típusból állnak: felhasználó által definiált és előre meghatározott.
A felhasználó által meghatározott kivételeket a programozók mindig kifejezetten felvetik a RAISEvagy RAISE_APPLICATION_ERRORparancsok használatával, minden olyan helyzetben, amikor úgy ítélik meg, hogy lehetetlen a normál végrehajtás folytatása. A RAISEparancs szintaxisa:
RAISE <exception name>;
Az Oracle Corporation előre több kivétel van, mint NO_DATA_FOUND, TOO_MANY_ROWS, stb
Minden kivétel van egy SQL hiba számát és az SQL hibaüzenet társítva. A programozók ezeket a SQLCODEés a SQLERRMfunkciók segítségével érhetik el .
Adott oszlopok adattípusai
Variable_name Table_name.Column_name%type;
Ez a szintaxis meghatározza a hivatkozott oszlopok típusának változóját a hivatkozott táblázatokban.
A programozók a felhasználó által meghatározott adattípusokat adják meg a szintaxissal:
type data_type is record (field_1 type_1 := xyz, field_2 type_2 := xyz, ..., field_n type_n := xyz);
Például:
declare
type t_address is record (
name address.name%type,
street address.street%type,
street_number address.street_number%type,
postcode address.postcode%type);
v_address t_address;
begin
select name, street, street_number, postcode into v_address from address where rownum = 1;
end;
Ez a mintaprogram meghatározza saját adattípusát, az úgynevezett t_címet , amely tartalmazza a mezők nevét, utca, utca_szám és irányítószámot .
Tehát a példa szerint képesek vagyunk lemásolni az adatokat az adatbázisból a program mezőibe.
Ezzel az adattípussal a programozó definiált egy v_address nevű változót, és betöltötte az ADDRESS táblából származó adatokkal.
A programozók a pontozásos jelöléssel kezelhetik az egyes attribútumokat egy ilyen struktúrában, így:
v_address.street := 'High Street';
Feltételes állítások
A következő kódrészlet az IF-THEN-ELSIF-ELSE konstrukciót mutatja be. Az ELSIF és az ELSE alkatrészek opcionálisak, így egyszerűbb IF-THEN vagy IF-THEN-ELSE konstrukciók létrehozása lehetséges.
IF x = 1 THEN
sequence_of_statements_1;
ELSIF x = 2 THEN
sequence_of_statements_2;
ELSIF x = 3 THEN
sequence_of_statements_3;
ELSIF x = 4 THEN
sequence_of_statements_4;
ELSIF x = 5 THEN
sequence_of_statements_5;
ELSE
sequence_of_statements_N;
END IF;
A CASE utasítás egyszerűsít néhány nagy IF-THEN-ELSIF-ELSE struktúrát.
CASE
WHEN x = 1 THEN sequence_of_statements_1;
WHEN x = 2 THEN sequence_of_statements_2;
WHEN x = 3 THEN sequence_of_statements_3;
WHEN x = 4 THEN sequence_of_statements_4;
WHEN x = 5 THEN sequence_of_statements_5;
ELSE sequence_of_statements_N;
END CASE;
A CASE utasítás használható az előre meghatározott választóval:
CASE x
WHEN 1 THEN sequence_of_statements_1;
WHEN 2 THEN sequence_of_statements_2;
WHEN 3 THEN sequence_of_statements_3;
WHEN 4 THEN sequence_of_statements_4;
WHEN 5 THEN sequence_of_statements_5;
ELSE sequence_of_statements_N;
END CASE;
Tömbkezelés
A PL/SQL a tömböket "gyűjteményeknek" nevezi . A nyelv háromféle gyűjteményt kínál:
- Asszociatív tömbök (Index-by-táblák)
- Beágyazott asztalok
- Változók (változó méretű tömbök)
A programozóknak meg kell határozniuk a felső korlátot a változókhoz, de nem szükséges az index-by táblák vagy a beágyazott táblák esetében. A nyelv magában foglalja a több gyűjtemény módszereket használják, hogy manipulálják gyűjtemény elemek: például első, utolsó, NEXT előtt, EXTEND, TRIM, törlés stb Index-asztalok lehet használni, hogy szimulálja asszociatív tömbök, mint ebben példa a Memo funkció Ackermann PL/SQL funkciójához .
Asszociatív tömbök (index-by táblázatok)
Az index-by táblákkal a tömb számokkal vagy karakterláncokkal indexelhető. Párhuzamos egy Java- térképpel , amely kulcs-érték párokat tartalmaz. Csak egy dimenzió létezik, és ez korlátlan.
Beágyazott asztalok
A beágyazott táblázatoknál a programozónak meg kell értenie, hogy mi van beágyazva. Itt egy új típus jön létre, amely számos összetevőből állhat. Ezt a típust lehet használni egy oszlop létrehozásához a táblázatban, és az oszlopba ágyazva vannak ezek az összetevők.
Változók (változó méretű tömbök)
A Változókkal meg kell értenie, hogy a "változó méretű tömbök" kifejezésben a "változó" szó nem vonatkozik a tömb méretére úgy, ahogy azt gondolná. A tömb deklarált mérete valójában rögzített. A tömb elemeinek száma a megadott méretig változó. Vitathatatlan, hogy a változó méretű tömbök nem annyira változó méretűek.
Kurzorok
A kurzor egy mechanizmus, egy magán SQL területre mutató mutató, amely a SELECT vagy adatkezelési nyelv (DML) utasításból (INSERT, UPDATE, DELETE vagy MERGE) származó információkat tárolja. A kurzor tartja az SQL utasítás által visszaadott sorokat (egy vagy több). Azokat a sorokat, amelyeket a kurzor tart, aktív halmaznak nevezzük.
A kurzor lehet explicit vagy implicit. A FOR ciklusban explicit kurzort kell használni, ha a lekérdezést újra használni fogják, ellenkező esetben az implicit kurzor előnyben részesül. Ha a kurzort egy cikluson belül használja, akkor a FETCH használata ajánlott, ha tömeges gyűjtést vagy dinamikus SQL -t igényel.
Hurok
A PL/SQL definíció szerint eljárási nyelvként számos iterációs konstrukciót biztosít, beleértve az alapvető LOOP utasításokat, a WHILE ciklusokat , a FOR ciklusokat és a Cursor FOR ciklusokat. Az Oracle 7.3 óta a REF CURSOR típust vezették be, hogy lehetővé tegyék a rekordkészletek visszatérését a tárolt eljárásokból és funkciókból. Az Oracle 9i bevezette az előre definiált SYS_REFCURSOR típust, vagyis már nem kell saját REF CURSOR típusokat definiálnunk.
LOOP állítások
<<parent_loop>>
LOOP
statements
<<child_loop>>
loop
statements
exit parent_loop when <condition>; -- Terminates both loops
exit when <condition>; -- Returns control to parent_loop
end loop child_loop;
if <condition> then
continue; -- continue to next iteration
end if;
exit when <condition>;
END LOOP parent_loop;
A ciklusokat a EXIT kulcsszó használatával vagy kivétel kivonásával lehet befejezni .
A hurkokhoz
DECLARE
var NUMBER;
BEGIN
/* N.B. for loop variables in PL/SQL are new declarations, with scope only inside the loop */
FOR var IN 0 .. 10 LOOP
DBMS_OUTPUT.PUT_LINE(var);
END LOOP;
IF var IS NULL THEN
DBMS_OUTPUT.PUT_LINE('var is null');
ELSE
DBMS_OUTPUT.PUT_LINE('var is not null');
END IF;
END;
Kimenet:
0 1 2 3 4 5 6 7 8 9 10 var is null
Kurzor FOR hurkok
FOR RecordIndex IN (SELECT person_code FROM people_table)
LOOP
DBMS_OUTPUT.PUT_LINE(RecordIndex.person_code);
END LOOP;
A kurzor-for ciklusok automatikusan megnyitják a kurzort , beolvassák az adataikat, és újra bezárják a kurzort.
Alternatív megoldásként a PL/SQL programozó előre definiálhatja a kurzor SELECT utasítását, hogy (például) lehetővé tegye az újrafelhasználást vagy érthetőbbé tegye a kódot (különösen hasznos hosszú vagy összetett lekérdezések esetén).
DECLARE
CURSOR cursor_person IS
SELECT person_code FROM people_table;
BEGIN
FOR RecordIndex IN cursor_person
LOOP
DBMS_OUTPUT.PUT_LINE(recordIndex.person_code);
END LOOP;
END;
A FOR-cikluson belüli person_code fogalmát pont-jelöléssel (".") Fejezzük ki:
RecordIndex.person_code
Dinamikus SQL
Míg a programozók könnyen beágyazhatják a Data Manipulation Language (DML) utasításokat közvetlenül a PL/SQL kódba egyszerű SQL utasítások használatával, addig a Data Definition Language (DDL) összetettebb "Dynamic SQL" utasításokat igényel a PL/SQL kódban. A tipikus szoftveralkalmazásokban azonban a PLL/SQL kódok többségét a DML utasítások támogatják.
A PL/SQL dinamikus SQL esetében az Oracle Database korai verziói bonyolult Oracle DBMS_SQLcsomagkönyvtár használatát igényelték . Az újabb verziók azonban bevezettek egy egyszerűbb "natív dinamikus SQL -t" és a hozzá tartozó EXECUTE IMMEDIATEszintaxist.
Hasonló nyelvek
A PL/SQL a más relációs adatbázisokhoz társított beágyazott eljárási nyelvekhez hasonlóan működik . Például a Sybase ASE és a Microsoft SQL Server rendelkezik Transact-SQL-vel , a PostgreSQL rendelkezik PL/pgSQL-vel (amely bizonyos mértékben emulálja a PL/SQL-t), a MariaDB tartalmaz egy PL/SQL-kompatibilitási elemzőt, és az IBM DB2 tartalmazza az SQL procedurális nyelvet, amely megfelel a az ISO SQL „s SQL / PSM szabvány.
A PL/SQL tervezői az Ada szintaxisát mintázták . Mind az Ada, mind a PL/SQL közös elődje a Pascal , így a PL/SQL is a Pascalhoz hasonlít a legtöbb szempontból. A PL/SQL csomag felépítése azonban nem hasonlít az alapvető Object Pascal programstruktúrára, amelyet egy Borland Delphi vagy Free Pascal egység hajtott végre . A programozók definiálhatnak nyilvános és privát globális adattípusokat, állandókat és statikus változókat egy PL/SQL csomagban.
A PL/SQL lehetővé teszi az osztályok meghatározását és objektumokként való megjelenítését a PL/SQL kódban. Ez hasonlít az objektum-orientált programozási nyelvek használatához, mint például az Object Pascal , a C ++ és a Java . A PL/SQL "Abstract Data Type" (ADT) vagy "User Defined Type" (UDT) típusként hivatkozik egy osztályra, és Oracle SQL adattípusként határozza meg , szemben a PL/SQL felhasználó által definiált típussal, amely lehetővé teszi használata mind az Oracle SQL Engine, mind az Oracle PL/SQL motorban. Az absztrakt adattípus konstruálója és módszerei PL/SQL nyelven íródnak. A kapott Absztrakt adattípus objektumosztályként működhet a PL/SQL -ben. Az ilyen objektumok oszlopértékként is megmaradhatnak az Oracle adatbázis -táblákban.
A PL/SQL alapvetően különbözik a Transact-SQL-től , a felületes hasonlóságok ellenére. A kódok egyikről a másikra történő átvitele általában nem triviális munkát jelent, nemcsak a két nyelv funkciókészleteiben mutatkozó különbségek miatt, hanem az Oracle és az SQL Server párhuzamossággal és zárolással való kezelésének nagyon jelentős különbségei miatt is .
A StepSqlite termék egy PL/SQL fordító a népszerű kis SQLite adatbázishoz, amely támogatja a PL/SQL szintaxis egy részhalmazát. Az Oracle Berkeley DB 11g R2 kiadása támogatást nyújtott a népszerű SQLite API -n alapuló SQL -hez azáltal, hogy a Berkeley DB -ben tartalmazta az SQLite egyik verzióját. Következésképpen a StepSqlite harmadik féltől származó eszközként is használható a PL/SQL kód futtatásához a Berkeley DB-n.
Lásd még
Hivatkozások
További irodalom
- Feuerstein, Steven ; Bill Pribyl (2014). Oracle PL/SQL programozás (6. kiadás). O'Reilly & Associates . ISBN 978-1449324452.
- Naudé, Frank (2005. június 9.). "Oracle PL/SQL GYIK rev 2.08" .
