Kurzorok a MySQL tárolt eljárásokban. DECLARE CURSOR parancs általános szabályok Mi az sql kurzor

Az explicit kurzor egy SELECT utasítás, amely kifejezetten a program deklarációs szakaszában van definiálva. Ha egy explicit kurzor deklarálva van, akkor az kap egy nevet. Az INSERT, UPDATE, MERGE és DELETE parancsokhoz explicit kurzorok nem definiálhatók.

A SELECT parancs explicit kurzorként történő definiálásával a programozó megkapja az irányítást az Oracle adatbázisból származó információk lekérésének alapvető lépései felett. Meghatározza, hogy mikor kell megnyitni a kurzort (OPEN), mikor kell lekérni belőle a sorokat (FETCH), hány sort kell lekérni, és mikor zárja be a kurzort a CLOSE paranccsal. A kurzor aktuális állapotáról az attribútumokon keresztül érhető el információ. A vezérlés finom részletessége teszi az explicit kurzorokat felbecsülhetetlen értékű eszközzé a programozó számára.

Vegyünk egy példát:

1 FUNKCIÓ ealousy_level (2 NAME_IN IN friends.NAME%TÍPUS) 3. SZÁM VISSZATÉRÉSE MINT 4 KURSZOR jealousy_cur 5 IS 6 VÁLASSZON helyet az ismerősöktől 7 WHERE NÉV = UPPER (NAME_IN); 8 8 jealousy_rec jealousy_cur%ROWTYPE; 9 retval SZÁM; 10 KEZD 11 NYITÁS féltékenység_cur; 13 12 FETCH jealousy_cur INTO jealousy_rec; 15 13 IF ealousy_cur%FOUND 14 THEN 15 IF jealousy_rec.location = "PUERTO RICO" 16 THEN retval:= 10; 17 ELSIF jealousy_rec.location = "CHICAGO" 18 THEN retval:= 1; 19 ENDIF; 20 VÉGE HA; 24 21 BEZÁR féltékenység_cur; 26 22 RETURN retval; 23 24. KIVÉTEL, AMIKOR MÁSOK AKKOR 25 IF jealousy_cur%ISOPEN THEN 26 CLOSE jealousy_cur; 27 END IF; 28END;

A következő néhány rész részletesen tárgyalja ezeket a műveleteket. A "kurzor" kifejezés bennük az explicit kurzorokra utal, hacsak a szöveg kifejezetten másként nem rendelkezik.

Explicit kurzor deklarálása

Az explicit kurzor használatához deklarálni kell egy PL/SQL blokk vagy csomag deklarációs szakaszában:

CURSOR kurzornév [ ([ paraméter [, paraméter...]) ] [ RETURN refEurn_spec ] IS SELECT_command ];

Itt a kurzor neve a deklarált kurzor neve; special_te?um - opcionális RETURN szakasz; KOMaHdaSELECT – bármely érvényes SQL SELECT parancs. A paraméterek átadhatók a kurzornak is (lásd alább a Kurzorparaméterek részt). Végül a SELECT...FOR UPDATE parancs után megadhatja a frissítendő oszlopok listáját (lásd alább). A kurzor deklarálása után az OPEN parancs nyitja meg, a sorok lekérése pedig a FETCH paranccsal történik.

Néhány példa explicit kurzordeklarációra.

• Kurzor paraméterek nélkül. Ennek a kurzornak a sorainak eredménykészlete a táblázat összes sorából kiválasztott vállalati azonosítók halmaza:

CURSOR company_cur IS SELECT company_id FROM company;

• Kurzor paraméterekkel. Az ehhez a kurzorhoz tartozó sorok eredményhalmaza egyetlen sort tartalmaz, amelyben a vállalatnév megegyezik az átadott paraméter értékével:

CURSOR név_kura (cégazonosító SZÁMBAN) IS SELECT név FROM company WHERE cégazonosító = cégazonosító_in;

• Kurzor RETURN záradékkal. Ennek a kurzornak az eredménykészlete tartalmazza a 10-es osztályazonosítóhoz tartozó alkalmazotti táblában szereplő összes adatot:

CURSOR emp_cur RETURN alkalmazottak%ROWTYPE IS SELECT * FROM alkalmazottak WHERE részlegazonosító = 10;

A kurzor neve

Az explicit kurzornévnek legfeljebb 30 karakter hosszúnak kell lennie, és ugyanazokat a szabályokat kell követnie, mint a többi PL/SQL azonosító esetében. A kurzor neve nem változó, hanem a lekérdezésre mutató mutató azonosítója. A kurzor nevéhez nincs hozzárendelve érték, és nem használható kifejezésekben. A kurzor csak az OPEN, CLOSE és FETCH parancsokban, valamint a kurzorattribútum minősítésére használható.

Kurzor deklaráció a csomagban

Az explicit kurzorok a PL/SQL blokk deklarációs részében vannak deklarálva. A kurzor deklarálható a csomag szintjén, de nem egy adott csomag eljárásban vagy függvényben. Példa két kurzor deklarálására egy csomagban:

CSOMAG könyv_információ IS CURSOR titles_cur IS SELECT cím A könyvekből; CURSOR books_cur (title_filter_in IN books.title%TYPE) RETURN books%ROWTYPE IS SELECT * FROM books WHERE cím LIKE title_filter_in; VÉGE;

Az első titles_cur kurzor csak a könyvek címét adja vissza. A második, a books_cur , a könyvtáblázat összes olyan sorát adja vissza, ahol a könyvcímek megegyeznek a kurzorparaméterként megadott mintával (például "Minden könyv, amely tartalmazza a "PL/SQL" karakterláncot). Vegye figyelembe, hogy a második kurzor egy RETURN záradékot használ, amely deklarálja a FETCH parancs által visszaadott adatstruktúrát.

A RETURN részben a következő adatstruktúrák bármelyike ​​megadható:

• Egy adattábla sora alapján meghatározott rekord, a %ROWTYPE attribútum használatával.
• Egy másik korábban deklarált kurzor alapján meghatározott bejegyzés, szintén a %rowtype attribútum használatával.
• A programozó által meghatározott rekord.

A kurzor kijelölőlistájában lévő kifejezések számának meg kell egyeznie a tábla_neve%ROWTYPE, Kypcop%ROWTYPE vagy rekordtípus oszlopainak számával. Az elemek adattípusainak is kompatibilisnek kell lenniük. Például, ha a kiválasztási lista második eleme NUMBER típusú, akkor a RETURN szakasz bejegyzésének második oszlopa nem lehet VARCHAR2 vagy BOOLEAN típusú.

Mielőtt a VISSZATÉRÉS rész részleteibe és előnyeibe belemennénk, először nézzük meg, mi értelme lenne a kurzorokat egy csomagban deklarálni? Miért nem deklarál egy explicit kurzort abban a programban, amelyben használják – eljárásban, függvényben vagy névtelen blokkban?

A válasz egyszerű és meggyőző. Ha egy kurzort definiál egy csomagban, újra felhasználhatja a benne definiált lekérdezést anélkül, hogy ugyanazt a kódot meg kellene ismételnie az alkalmazás különböző helyein. A lekérdezés egy helyen történő megvalósítása megkönnyíti a kód finomítását és karbantartását. Némi időmegtakarítás érhető el a feldolgozott kérelmek számának csökkentésével.

Érdemes megfontolni egy olyan függvény létrehozását is, amely a REF CURSOR alapján ad vissza egy kurzorváltozót. A hívó program a kurzorváltozón keresztül kéri le a sorokat. További információért lásd: Kurzorváltozók és REF CURSOR.

Egy fontos dolgot kell szem előtt tartani, amikor a kurzorokat újrafelhasználható csomagokban deklarálja. Minden adatstruktúra, beleértve a kurzorokat is, amelyek a "csomag szintjén" (nem egy adott funkción vagy eljáráson belül) vannak deklarálva, a munkamenet során megőrzik értéküket. Ez azt jelenti, hogy a köteg kurzor nyitva marad mindaddig, amíg kifejezetten be nem zárja, vagy amíg a munkamenet véget nem ér. A helyi blokkban deklarált kurzorok automatikusan bezáródnak, amikor ezek a blokkok véget érnek.

Most foglalkozzunk a RETURN résszel. A kurzor deklarációja egy csomagban egy érdekes tulajdonsággal rendelkezik: a kurzor címe elválasztható a törzsétől. Egy ilyen fejléc, inkább egy függvényfejléc, olyan információkat tartalmaz, amelyekre a programozónak szüksége van: a kurzor nevét, paramétereit és a visszaadott adatok típusát. A kurzor törzse a SELECT utasítás. Ezt a technikát a books_cur kurzordeklaráció új verziója mutatja be a book_info csomagban:

CSOMAG book_info IS CURSOR books_cur (title_filter_in IN books.title%TYPE) VISSZA könyvek%ROWTYPE; VÉGE; PACKAGE BODY book_info IS CURSOR books_cur (title_filter_in IN books.title%TYPE) RETURN books%ROWTYPE IS SELECT * FROM books WHERE cím LIKE title_filter_in; VÉGE;

Az IS kulcsszóig minden karakter specifikációt alkot, az IS után pedig a kurzor törzse következik. A kurzordeklaráció felosztása két célt szolgálhat.

• Információ elrejtése. A kurzor a csomagban egy "fekete doboz". Ez kényelmes a programozók számára, mert nem kell írniuk, vagy nem kell látniuk a SELECT parancsot. Elég tudni, hogy ez a kurzor mely rekordokat adja vissza, milyen sorrendben, és milyen oszlopokat tartalmaznak. A csomagprogramozó úgy használja a kurzort, mint bármely más kész elemet.
• Minimális újrafordítás. Ha elrejti a lekérdezés definícióját a csomagtörzsben, akkor módosíthatja a SELECT utasítást anélkül, hogy módosítaná a kurzorfejlécet a csomagspecifikációban. Ez lehetővé teszi a kód javítását, javítását és újrafordítását a csomagspecifikáció újrafordítása nélkül, így a csomagtól függő programok nem lesznek érvénytelennek jelölve, és nem kell újrafordítani.

Explicit kurzor megnyitása

A kurzor használata a deklarációs részben lévő definíciójával kezdődik. Ezután meg kell nyitni a deklarált kurzort. Az OPEN utasítás szintaxisa nagyon egyszerű:

OPEN kurzornév [ (argumentum [, argumentum...]) ];

Itt a kurzornév a korábban deklarált kurzor neve, az argumentum pedig a kurzornak átadott érték, ha paraméterlistával deklarálva van.

Az Oracle a FOR szintaxist is támogatja a kurzor megnyitásakor, amely mind a kurzorváltozókhoz (lásd: Kurzorváltozók és REF CURSOR), mind a soron belüli dinamikus SQL-hez használatos.

A kurzor megnyitásakor a PL/SQL végrehajtja a benne lévő lekérdezést. Ezenkívül azonosítja az aktív adatkészletet - a lekérdezésben részt vevő összes tábla azon sorait, amelyek megfelelnek a WHERE feltételnek és az összekapcsolási feltételnek. Az OPEN parancs nem kér adatokat – ez a FETCH parancs feladata.

Függetlenül attól, hogy mikor történik meg az első adatlekérés, az Oracle adatintegritási modellje biztosítja, hogy az összes lekérési művelet a kurzor megnyitásának időpontjában lévő adatokat adja vissza. Más szóval, a kurzor megnyitásától bezárásáig, az adatok lekérésekor az ezalatt végrehajtott beszúrási, frissítési és törlési műveletek teljesen figyelmen kívül maradnak.

Ezen túlmenően, ha a SELECT utasítás FOR UPDATE záradékot tartalmaz, a kurzor által azonosított összes sor zárolva lesz a megnyitásakor.

Ha megpróbál megnyitni egy már nyitott kurzort, a PL/SQL a következő hibaüzenetet generálja:

ORA-06511: PL/SQL: a kurzor már nyitva van

Ezért a kurzor megnyitása előtt ellenőrizni kell az állapotát az attribútum értékével %nyitva van:

HA NEM company_cur%ISOPEN THEN OPEN company_cur; VÉGE HA;

Az explicit kurzorattribútumok leírása az alábbi szakaszban található.

Ha egy program egy FOR ciklust hajt végre egy kurzor használatával, akkor ezt a kurzort nem kell kifejezetten megnyitni (adatlehívás, bezárás). A PL/SQL kernel ezt automatikusan megteszi.

Adatok lekérése explicit kurzorról

A SELECT parancs egy virtuális táblázatot hoz létre – egy WHERE záradék által meghatározott sorok halmazát, amelyek oszlopait egy SELECT oszloplista határozza meg. Így a kurzor ezt a táblát reprezentálja egy PL/SQL programban. A kurzor elsődleges célja a PL/SQL programokban, hogy sorokat kérjen le feldolgozásra. A kurzorsorok lekérése a FETCH paranccsal történik:

FETCH kurzornév INTO rekord_vagy_var_lista;

Itt a kurzornév annak a kurzornak a neve, amelyből a rekordot kiválasztjuk, a rekord vagy a változólista pedig azok a PL/SQL adatstruktúrák, amelyekbe az aktív rekordkészlet következő sorát másoljuk. Az adatok elhelyezhetők PL/SQL rekordban (%ROWTYPE attribútummal vagy TYPE deklarációval deklarálva) vagy változókban (PL/SQL változók vagy kötési változók - például az Oracle Forms elemeiben).

Példák explicit kurzorokra

A következő példák az adatok lekérésének különböző módjait mutatják be.

• Adatok lekérése a kurzorból egy PL/SQL rekordba:

DECLARE CURSOR company_cur a SELECT ...; company_rec company_cur%ROWTYPE; BEGIN OPEN company_cur; FETCH company_cur INTO company_rec;

• Adatok lekérése a kurzorból egy változóba:

FETCH new_balance_cur INTO new_balance_dollars;

• Adatok lekérése a kurzorból egy PL/SQL táblasorba, változóba és Oracle Forms kötési változóba:

FETCH emp_name_cur INTO emp_name(1), hiredate, :dept.min_fizetés;

A kurzorról lekért adatokat mindig egy olyan rekordba kell helyezni, amely ugyanazon a kurzoron alapul, %ROWTYPE attribútummal; kerülje a változólistákba való beolvasást. A Fetch-to-Record funkció kompaktabbá és rugalmasabbá teszi a kódot, lehetővé teszi a lekérési lista módosítását a FETCH parancs megváltoztatása nélkül.

Lehívás az utolsó sor feldolgozása után

Amikor megnyit egy kurzort, egyenként jelöli ki a sorokat, amíg ki nem fogy. A FETCH parancsot azonban ezután is futtathatja.

Furcsa módon a PL/SQL ebben az esetben nem tesz kivételt. Egyszerűen nem csinál semmit. Mivel nincs más kiválasztható, a FETCH parancs INTO szakaszában lévő változók értékei nem változnak. Más szóval, a FETCH parancs nem állítja be ezeket a változókat NULL értékre.

Explicit kurzoroszlop álnevek

A kurzordeklarációban a SELECT parancs határozza meg az általa visszaadott oszlopok listáját. A táblázat oszlopnevei mellett ez a lista tartalmazhat kiszámított vagy virtuális oszlopoknak nevezett kifejezéseket.

Az oszlopálnév egy oszlop vagy kifejezés SELECT parancsában megadott alternatív név. A megfelelő álnevek megadásával az SQL*Plusban egy tetszőleges lekérdezés eredményeit ember által olvasható formában jelenítheti meg. Az ilyen helyzetekben az álnevek nem kötelezőek. Másrészt explicit kurzorok használatakor a következő esetekben van szükség kiszámított oszlopálnevekre:

• amikor adatokat kér le egy kurzorból egy rekordba, amely a %ROWTYPE attribútummal deklarált ugyanazon a kurzoron alapul;
• amikor a program hivatkozást tartalmaz egy számított oszlopra.

Fontolja meg a következő lekérdezést. A SELECT parancs kiválasztja az összes olyan vállalat nevét, amely 2001-ben árut rendelt, valamint a megrendelések teljes mennyiségét (feltételezve, hogy az aktuális adatbázispéldány alapértelmezett formátummaszkja DD-MON-YYYY):

SELECT company_name, SUM (inv_amt) FROM cég c, számla i WHERE c.company_id = i.company_id AND i.invoice_date "2001. JAN. 1." ÉS "2001. DEC. 31" KÖZÖTT;

A parancs futtatása SQL*Plusban a következő kimenetet eredményezi:

CÉGNÉV	SZUM (INV_AMT)
ACME TURBO INC.	1000
WASHINGTON HAIR CO.	25.20

Amint látja, a SUM (INV_AMT) oszlopfejléc nem alkalmas jelentésekhez, de egyszerű adatmegtekintéshez igen. Most futtassuk le ugyanazt a lekérdezést egy PL/SQL programban explicit kurzor használatával, és adjunk hozzá egy oszlopálnevet:

DECLARE CURSOR comp_cur IS SELECT c.name, SUM (inv_amt) total_sales FROM C, I. számla WHERE C.company_id = I.company_id AND I.invoice_date "2001. JAN. 1." ÉS "2001. DEC. 31" KÖZÖTT; comp_rec comp_cur%ROWTYPE; BEGIN OPEN comp_cur; FETCH comp_cur INTO comp_rec; VÉGE;

Az álnév nélkül nem tudok hivatkozni az oszlopra a comp_rec rekordstruktúrában. Adott álnévvel a számított oszlopokkal ugyanúgy dolgozhat, mint bármely más lekérdezési oszloppal:

HA comp_rec.total_sales > 5000 AKKOR DBMS_OUTPUT.PUT_LINE (" Túllépte 5000 USD-s hitelkeretét " || TO_CHAR-ral (comp_rec.total_sales - 5000, "9999 USD")); VÉGE HA;

A %ROWTYPE attribútummal deklarált rekordba való sor beolvasásakor a számított oszlop csak a neve alapján érhető el, mivel a rekord szerkezetét maga a kurzor szerkezete határozza meg.

Explicit kurzor bezárása

Egyszer gyerekkorunkban arra tanítottak bennünket, hogy takarítsunk el magunk után, és ez a szokásunk (bár nem mindenkinél) egy életre megmaradt. Kiderült, hogy ez a szabály rendkívül fontos szerepet játszik a programozásban is, és különösen, ha kurzorvezérlésről van szó. Soha ne felejtse el bezárni a kurzort, ha már nincs rá szüksége!

A CLOSE parancs szintaxisa a következő:

CLOSE kurzornév;

Az alábbiakban néhány fontos tippet és szempontot olvashat az explicit kurzorok bezárásához.

• Ha egy kurzort deklarálnak és megnyitnak egy eljárásban, ne felejtse el bezárni, amikor végzett vele; ellenkező esetben a kód kiszivárogtatja a memóriát. Elméletileg a kurzort (mint minden adatszerkezetet) automatikusan be kell zárni és meg kell semmisíteni, ha kikerül a hatókörből. Általában egy eljárásból, függvényből vagy névtelen blokkból való kilépéskor a PL/SQL ténylegesen bezár minden benne nyitva lévő kurzort. Ennek a folyamatnak azonban ára van, ezért hatékonysági okokból a PL/SQL néha késlelteti a nyitott kurzorok észlelését és bezárását. A REF CURSOR-okat értelemszerűen nem lehet implicit módon bezárni. Az egyetlen dolog, amiben biztos lehetsz, az az, hogy amikor a "legkülső" PL/SQL blokk véget ér, amikor a vezérlés visszakerül az SQL-hez vagy egy másik hívóhoz, a PL/SQL implicit módon bezárja az adott blokk vagy beágyazott blokkok által megnyitott kurzorokat, kivéve a REF CURSOR. . Az Oracle Technology Network Kurzor újrafelhasználása PL/SQL statikus SQL-ben című cikke részletes elemzést ad arról, hogy a PL/SQL hogyan és mikor zárja be a kurzorokat. Az egymásba ágyazott névtelen blokkok példák arra a helyzetre, amikor a PL/SQL nem zárja be implicit módon a kurzorokat. A témával kapcsolatos érdekes információkért tekintse meg Jonathan Gennick „Does PL/SQL Implicitly Close Cursors?” című cikkét.
• Ha egy kurzort a csomagban deklarálnak a csomag szintjén, és megnyitják valamelyik blokkban vagy programban, akkor az mindaddig nyitva marad, amíg kifejezetten be nem zárja, vagy amíg a munkamenet véget nem ér. Ezért, ha befejezte a kötegszintű kurzorral való munkát, azonnal zárja be a CLOSE paranccsal (és mellesleg ugyanezt kell tennie a kivétel részben):

KEZDJE MEGNYITÁS my_package.my_cursor; ... Munka a kurzorral CLOSE my_package.my_cursor; KIVÉTEL, AMIKOR MÁSOK, MAJD HA mypackage.my_cursor%ISOPEN, MAJD ZÁRJA be a my_package.my_cursor; VÉGE HA; VÉGE;

• A kurzor csak akkor zárható be, ha korábban nyitva volt; ellenkező esetben INVALID_CURS0R kivételt dob ​​a rendszer. A kurzor állapotát a %ISOPEN attribútum segítségével ellenőrizzük:

IF company_cur%ISOPEN, MAJD ZÁRJA be company_cur; VÉGE HA;

• Ha túl sok nyitott kurzor maradt a programban, számuk meghaladhatja az OPEN_CURSORS adatbázis paraméter értékét. Ha hibaüzenetet kap, először meg kell győződnie arról, hogy a csomagokban deklarált kurzorok bezáródnak, amikor már nincs rájuk szükség.

Explicit kurzor attribútumok

Az Oracle négy attribútumot támogat (%FOUND, %NOTFOUND, %ISOPEN, %ROWCOUNTM) az explicit kurzor állapotáról való információszerzéshez. Az attribútumhivatkozás szintaxisa a következő: cursor%attribute

Itt a kurzor a deklarált kurzor neve.

Az explicit kurzorattribútumok által visszaadott értékek az 1. táblázatban láthatók. 1.

Asztal 1. Explicit kurzor attribútumok

A kurzorattribútumok értékei a velük végzett különféle műveletek előtt és után a táblázatban láthatók. 2.

Ha explicit kurzorattribútumokkal dolgozik, tartsa szem előtt a következőket:

• Ha megpróbálja elérni a %FOUND, %NOTFOUND vagy %ROWCOUNT attribútumot a kurzor megnyitása előtt vagy bezárása után, az Oracle INVALID CURSOR (ORA-01001) kivételt dob.
• Ha az eredmény sorkészlet üres a FETCH parancs első végrehajtása után, a kurzorattribútumok a következő értékeket adják vissza: %FOUND = FALSE , %NOTFOUND = TRUE és %ROWCOUNT = 0.
• A BULK COLLECT használatakor a %ROWCOUNT attribútum az adott gyűjteményekbe beolvasott sorok számát adja vissza.

2. táblázat. Kurzor attribútum értékei

Művelet	%MEGTALÁLT	%NEM TALÁLHATÓ	%NYITVA VAN	%ROWCOUNT
NYITÁS előtt	Kivétel ORA-01001	Kivétel ORA-01001	HAMIS	Kivétel ORA-01001
NYITÁS után	NULLA	NULLA	IGAZ	0
Az első FETCH előtt	NULLA	NULLA	IGAZ	0
Az első minta után FETCH	IGAZ	HAMIS	IGAZ	1
A későbbiek előtt FETCH	IGAZ	HAMIS	IGAZ	1
A következő FETCH után	IGAZ	HAMIS	IGAZ	Adatfüggő
Az utolsó FETCH előtt	IGAZ	HAMIS	IGAZ	Adatfüggő
Az utolsó FETCH után	IGAZ	HAMIS	IGAZ	Adatfüggő
ZÁRÁS előtt	HAMIS	IGAZ	IGAZ	Adatfüggő
ZÁRÁS után	Kivétel	Kivétel	HAMIS	Kivétel

Mindezen attribútumok használatát a következő példa szemlélteti:

Korábbi blogok többször is hoztak példát eljárások és függvények paramétereinek használatára. A paraméterek az információ átadásának eszközei a programmodulhoz és onnan. Helyes használat esetén hasznosabbá és rugalmasabbá teszik a modulokat.

A PL/SQL lehetővé teszi a paraméterek átadását a kurzoroknak. Ugyanazokat a funkciókat látják el, mint a programmodulok paraméterei, valamint néhány további funkciót.

• A kurzor újrahasználatának kiterjesztése. A WHERE záradékban szereplő, az adatkiválasztás feltételeit meghatározó merev kódolási értékek helyett paraméterek segítségével adhat át új értékeket a WHERE záradéknak a kurzor minden egyes megnyitásakor.
• A kurzor hatókörével kapcsolatos problémák megoldása. Ha a lekérdezésben paramétereket használunk a kódolt értékek helyett, akkor a kurzorsorok eredménykészlete nincs egy adott programhoz vagy blokkváltozóhoz kötve. Ha a programjában vannak beágyazott blokkok, akkor a legfelső szinten definiálhat egy kurzort, és használhatja beágyazott blokkokban, amelyekben deklarált változók vannak.

A kurzorparaméterek száma korlátlan. Az OPEN meghívásakor a kurzort minden paraméterre kell állítani (kivéve azokat a paramétereket, amelyeknek alapértelmezett értéke van).

Mikor kell a kurzornak paramétereket megadni? Az általános szabály itt ugyanaz, mint az eljárások és funkciók esetében: ha a kurzort várhatóan különböző helyeken és különböző értékekkel használják a WHERE záradékban, akkor meg kell határoznia egy paramétert. Hasonlítsuk össze a kurzorokat paraméterrel és anélkül. Példa paraméterek nélküli kurzorra:

CURSOR vicc_cur IS SELECT név, kategória, utolsó_használt_dátum FROM Viccek;

A kurzor eredményhalmaza tartalmazza a vicctáblázat összes bejegyzését. Ha csak a sorok egy részhalmazára van szükségünk, akkor a WHERE záradék szerepel a lekérdezésben:

CURSOR vicc_cur IS SELECT név, kategória, utolsó_használt_dátum FROM viccek WHERE kategória = "FÉRJ";

A feladat elvégzéséhez nem használtunk paramétereket, és nincs is szükség rájuk. Ebben az esetben a kurzor visszaadja az összes olyan sort, amely egy adott kategóriába tartozik. De mi van akkor, ha a kategória minden alkalommal megváltozik, amikor ehhez a kurzorhoz hozzáférünk?

Kurzorok paraméterekkel

Természetesen nem fogunk minden kategóriához külön kurzort definiálni – ez teljesen összeegyeztethetetlen az adatvezérelt alkalmazások fejlesztésének elvével. Csak egy kurzorra van szükségünk, de egy olyanra, amelynek kategóriáját meg tudjuk változtatni – és továbbra is visszaadja a szükséges információkat. És a legjobb (bár nem az egyetlen) megoldás erre a problémára egy paraméterezett kurzor meghatározása:

ELJÁRÁS magyarázat_vicc (fő_kategória_in joke_category.category_id%TYPE) IS /* || Kurzor a következő paraméterlistával: || egyetlen karakterlánc-paraméterből. */ CURSOR joke_cur (kategória_in VARCHAR2-BEN) IS SELECT név, kategória, utolsó_használt_dátum FROM Joke WHERE kategória = UPPER (kategória_ben); joke_rec joke_cur%ROWTYPE; BEGIN /* Most egy argumentum kerül átadásra a kurzornak a megnyitásakor */ OPEN joke_cur (főkategória_bemenete); FETCH joke_cur INTO joke_rec;

Mostantól a kurzor neve és az IS kulcsszó közötti opciók listája látható. A WHERE záradékban a kemény kódolt HUSBAND értéket az UPPER paraméterre (category_in) való hivatkozásra cseréltük. A kurzor megnyitásakor az értéket FÉRJ , férj vagy FÉRJ értékre állíthatja - a kurzor továbbra is működik. Annak a kategóriának a neve, amelyhez a kurzornak vissza kell adnia a vicctábla sorait, az OPEN utasításban (zárójelben) van megadva literálként, konstansként vagy kifejezésként. A kurzor megnyitásakor a SELECT parancs elemzésre kerül, és a paraméter hozzá van rendelve az értékhez. A sorok eredményhalmaza ezután meghatározásra kerül - és a kurzor készen áll a lekérésre.

Kurzor megnyitása paraméterekkel

Új kurzor nyitható bármely kategóriával:

OPEN joke_cur(Viccek_pkg.kategória); OPEN joke_cur("férj"); OPEN joke_cur("politikus"); OPEN joke_cur(Viccek_pkg.relation || "-IN-LOW");

A kurzorparamétereket leggyakrabban a WHERE záradékban használják, de a SELECT utasításban máshol is hivatkozhatunk rájuk:

DECLARE CURSOR joke_cur(category_in IN ARCHAR2) IS SELECT név, kategória_ben, utolsó_használt_dátum FROM vicc WHERE kategória = UPPER(kategória_be);

Ahelyett, hogy a kategóriát a táblázatból olvasnánk ki, egyszerűen behelyettesítjük a category_in paramétert a kijelölő listába. Az eredmény ugyanaz marad, mert a WHERE záradék a kiválasztási kategóriát a paraméterértékre korlátozza.

Kurzor paraméter hatóköre

A kurzorparaméter hatóköre erre a kurzorra korlátozódik. A kurzorparaméterre nem lehet hivatkozni a kurzorhoz társított SELECT parancson kívül. Az alábbi PL/SQL kódrészlet nem fordítható le, mert a program_neve nem helyi változó a blokkban. Ez egy formális kurzorparaméter, amely csak a kurzoron belül van definiálva:

KURSZÓ DEKLARÁZÁSA scariness_cur (program_neve VARCHAR2) IS SELECT SUM (ijesztő_szint) total_scary_level FROM mesék_a_kriptából WHERE prog_name = program_neve; BEGIN program_name:= "A LÉGZŐ MÚMIA"; /* Érvénytelen hivatkozás */ OPEN scariness_cur (program_neve); .... BEZÁR scariness_cur; VÉGE;

Kurzorparaméter módok

A kurzorparaméterek szintaxisa nagyon hasonló az eljárások és függvények szintaxisához - kivéve, hogy a kurzorparaméterek csak IN paraméterek lehetnek. A kurzor paraméterei nem állíthatók OUT vagy IN OUT értékre. Ezek a módok lehetővé teszik az eljárásokból származó értékek átadását és visszaadását, aminek nincs értelme a kurzor számára. Csak egyféleképpen lehet információt szerezni a kurzortól: lekérni a rekordot, és másolni az értékeket az INTO záradék oszloplistájából.

Alapértelmezett paraméterértékek

A kurzorparaméterekhez alapértelmezett értékek rendelhetők. Példa kurzorra alapértelmezett paraméterértékkel:

CURSOR emp_cur (emp_id_in NUMBER:= 0) IS SELECT munkavállalói_azonosító, emp_name FROM alkalmazott WHERE munkavállalói_azonosító = emp_id_in;

Mivel az emp_id_in paraméter alapértelmezett értéke van, a FETCH parancsban elhagyhatja az értéket. Ebben az esetben a kurzor 0 kóddal adja vissza az alkalmazottra vonatkozó információkat.

A DECLARE CURSOR parancs lehetővé teszi a rekordok soronkénti lekérését egy táblázatból manipulálás céljából. Ez lehetővé teszi a soronkénti feldolgozást az SQL által végzett hagyományos adatkészlet-feldolgozás helyett.

A legelső közelítésben, amikor kurzorral dolgozik, a következő lépéseket használjuk.

A kurzor a DECLARE paranccsal jön létre. A kurzor az OPEN paranccsal nyílik meg.

A kurzorműveletek a FETCH paranccsal hajthatók végre. A kurzort a CLOSE paranccsal zárjuk be.

A DECLARE CURSOR parancs egy SELECT utasítást ad meg. A SELECT utasítás által visszaadott minden sor külön-külön lekérhető és feldolgozható. A következő Oracle-példában a kurzor egy deklarációs blokkban van deklarálva számos más változóval együtt. Ezt követően a következő BEGIN…END mondatban a kurzor megnyílik, kijelölés történik rajta, és a kurzor bezárul.

CURSOR title_price_cursor IS SELECT title, price FROM titles

AHOL az ár NEM NULLA; title_price_val title_price_cursor ROWTYPE; új_ár SZÁM(10,2);

OPEN title_price_Cursor;

FELTÉTELEK cím_ár_cur-sor INTO cím_ár_értéke;

new_price:= "title_price_val.price" * 1,25 INSERT INTO new_title_price VALUES

(title_price_val. title, new_price) CLOSE title_price_cursor; VÉGE;

Mivel ez a példa PL/SQL-t használ, a legtöbb kódot nem magyarázzuk meg ebben a könyvben. A kurzor deklarációja azonban jól látható a DECLARE blokkban. Egy PL/SQL végrehajtható blokkban a kurzor inicializálása OPEN utasítással történik, az értékek FETCH utasítással kerülnek lekérésre, végül a kurzort egy CLOSE utasítással zárják le.

A SELECT utasítás a kurzor magja, ezért célszerű alaposan tesztelni, mielőtt belefoglalná a DECLARE CURSOR utasításba. A SELECT utasítás működhet egy mögöttes táblán vagy nézeten. Ezért a csak olvasható kurzorok nem frissíthető nézetekkel is működhetnek. A SELECT utasítás tartalmazhat olyan záradékokat, mint például ORDER BY, GROUP BY és HAVING, amennyiben ezek a záradékok nem frissítik a forrástáblát. Ha a kurzor FOR UPDATEként van definiálva, akkor javasolt az ilyen záradékok eltávolítása a SELECT utasításból.

A helyi kurzorokat gyakran használják a tárolt eljárások kimeneti paramétereiként. Ezért egy tárolt eljárásban definiálhat és feltölthet egy kurzort, és átadhatja az azt meghívó kötegelt feladatnak vagy tárolt eljárásnak.

A következő egyszerű DB2 példában deklarálunk egy kurzort, amely megkeresi a részlegszámokat, részlegneveket és menedzserszámokat az "XO1" admin_group csoportban.

DECLARE dept_cursor CURSOR

FOR SELECT részleg_nbr., részleg_neve, igazgató_nbr

WHERE admin_group="X01"

ORDER BY d "ept_name ASC, dept_nbr DESC, mgr_nbr DESC;

A következő példa a Microsoft SQL Serverhez deklarál és megnyit egy kurzort a kiadói táblázatban. A kurzor kiválasztja az első olyan rekordot a kiadói táblázatból, amely megfelel a SELECT utasításnak, és beszúrja egy másik táblába. Ezután továbblép a következő rekordra, majd a következőre, amíg az összes rekordot fel nem dolgozták. Végül a kurzor bezárul, és a memória felszabadul (a DEALLOCATE parancs csak a Microsoft SQL Serverben használatos).

DECLARE @publisher_name VARCHAR(20)

DECLARE pub_cursor CURSOR FOR SELECT pub_name FROM publishers WHERE ország "USA"

FETCH NEXT FROM pub_cursor INTO publisher_name

WHILE @s>FETCH_STATUS=0

INSERT INTO Foreign_publishers VALUES("j>kiadó_neve)

pub_cursor bezárása DEALLOCATE pub_cursor

Ebben a példában láthatja, hogyan mozog a kurzor a rekordkészletben. (Ez a példa csak ennek az elképzelésnek a bemutatására szolgál, mivel valójában van egy jobb módja ennek a feladatnak, nevezetesen az INSERT, SELECT utasítás.)

Kurzor SQL-ben, egy olyan terület az adatbázis memóriájában, amely az utolsó SQL utasítás tárolására szolgál. Ha az aktuális utasítás egy adatbázis-lekérdezés, akkor a lekérdezési adatkarakterlánc, amelyet aktuális értéknek vagy aktuális sornak neveznek, szintén a memóriában tárolódik. kurzor. A memória meghatározott területe el van nevezve, és az alkalmazásprogramok számára elérhető.

Az SQL szabványnak megfelelően, amikor a kurzorok a következő fő akciókat:

• teremtés ill kurzor deklaráció ;
• kurzor megnyitása, azok. feltöltése többszintű memóriában tárolt adatokkal;
• lekérni a kurzorrólÉs változás vele adatsorok;
• kurzor bezárása, ami után elérhetetlenné válik a felhasználói programok számára;
• a kurzor felszabadítása, azaz eltávolítás kurzor tárgyként, mert záró opcionálisan felszabadítja a hozzá tartozó memóriát.

Az SQL Server hármat támogat kurzor típusa:

• kurzorok Az SQL-t elsősorban triggereken, tárolt eljárásokon és parancsfájlokon belül használják;
• kurzorok szerverek működnek a szerveren, és megvalósítják az ODBC, OLE DB, DB_Library alkalmazásprogramozási felületét;
• kurzorok kliens implementálása magán az ügyfélen történik. A teljes eredménysort lekérik a szerverről, és helyben tárolják, ami felgyorsítja az adatfeldolgozási műveleteket a hálózati műveletek pazarlásának csökkentésével.

Kurzorvezérlés MS SQL Server környezetben

Kurzorvezérlés a következő parancsok végrehajtásával valósítható meg:

• DECLARE - hozzon létre vagy kurzor deklaráció ;
• NYISD KI- kurzor megnyitása, azaz adatokkal való kitöltése;
• FETCH- lekérni a kurzorrólÉs változás adatsorok a kurzor használatával;
• BEZÁRÁS- kurzor bezárása ;
• DEALLOCATE- a kurzor felszabadítása, azaz a kurzor törlése objektumként.

Kurzor deklaráció

Az SQL szabvány létrehozni kurzor a következő parancsot adjuk:

<создание_курсора>::= DECLARE cursor_name CURSOR FOR SELECT_utasítás ])]

Az INSENSITIVE kulcsszó használatával létrejön statikus kurzor. Adatváltozások nem engedélyezettek, sőt nem jelennek meg változtatások más felhasználók által készített. Ha az INSENSITIVE kulcsszó nincs jelen, egy dinamikus kurzor.

A SCROLL kulcsszó megadásakor a generált kurzor tetszőleges irányba görgethető, lehetővé téve bármilyen parancs alkalmazását minták. Ha ezt az argumentumot kihagyjuk, akkor kurzor lesz következetes, azaz megtekintése csak egy irányban lesz lehetséges – az elejétől a végéig.

A SELECT utasítás adja meg a SELECT lekérdezés törzsét, amely meghatározza a sorok eredményhalmazát kurzor.

Ha a FOR READ_ONLY argumentum meg van adva, a kurzor csak olvasható, és az adatok módosítása nem megengedett. Eltér a statikus, bár ez utóbbi szintén nem teszi lehetővé az adatok megváltoztatását. Csak olvasható kurzorként deklarálható dinamikus kurzor, amely megjelenik változtatások egy másik felhasználó készítette.

Teremtés kurzor a FOR UPDATE argumentummal lehetővé teszi a végrehajtást kurzor módosítási adatok vagy a megadott oszlopokban, vagy az oszlop_neve OF argumentum hiányában az összes oszlopban.

Az MS SQL Server környezetben a következő szintaxist fogadja el a create parancs kurzor:

<создание_курсора>::= DECLARE cursor_name CURSOR FOR SELECT_utasítás ]]

A LOCAL kulcsszó használatával létrejön egy helyi kurzor Olyan, amely csak az azt létrehozó csomagban, triggerben, tárolt eljárásban vagy felhasználó által meghatározott függvényben látható. Amikor egy csomag, trigger, eljárás vagy függvény befejeződik kurzor hallgatólagosan megsemmisült. Tartalom küldésére kurzor az azt létrehozó konstrukción kívül egy OUTPUT argumentumot kell hozzárendelni a paraméteréhez.

Ha a GLOBAL kulcsszó van megadva, akkor egy globális kurzor; az aktuális kapcsolat bezárásáig létezik.

A FORWARD_ONLY megadása létrehozza szekvenciális kurzor ; mintavétel adatok csak az első sortól az utolsóig terjedő irányban hajthatók végre.

A SCROLL megadása létrehozza görgethető kurzor; az adatok tetszőleges sorrendben és bármilyen irányban elérhetők.

A STATIC megadása létrehozza statikus kurzor.

A KEYSET megadása kulcskurzort hoz létre.

A DYNAMIC megadásával létrejön dinamikus kurzor.

Ha azért kurzor READ_ONLY adja meg az ezután létrehozott FAST_FORWARD argumentumot kurzor a gyors adatelérésre lesz optimalizálva. Ez az argumentum nem használható a FORWARD_ONLY és az OPTIMISTIC argumentumokkal együtt.

BAN BEN kurzor OPTIMISTIC argumentummal létrehozott tilos változásÉs sorok törlése amelyeket azután megváltoztattak kurzor megnyitása.

A TYPE_WARNING argumentum megadásával a szerver tájékoztatja a felhasználót az implicit típusváltozásról kurzor ha nem kompatibilis a SELECT lekérdezéssel.

A kurzor megnyitása

Mert kurzor megnyitásaés a létrehozás során a megadott adatokkal való feltöltése kurzor A SELECT lekérdezés a következő parancsot használja:

OPEN ((kurzor_neve ) |@kurzor_változónév)

Után kurzor megnyitása a hozzá tartozó SELECT utasítás végrehajtásra kerül, melynek kimenete a réteges memóriában tárolódik.

Adatok lekérése a kurzorról

Közvetlenül utána kurzor megnyitása tartalmát (a megfelelő lekérdezés eredményét) a következő paranccsal választhatjuk ki:

FETCH [ FROM ]((kurzor_neve )| @cursor_variable_name ) ]

A FIRST megadása a teljes eredménykészlet legelső sorát adja vissza kurzor, amely az aktuális sor lesz.

A LAST megadása a legutóbbi sort adja vissza kurzor. Ez lesz az aktuális sor is.

A NEXT megadása közvetlenül az aktuális sor utáni sort adja vissza a teljes eredményhalmazban. Most aktuálissá válik. A FETCH parancs alapértelmezés szerint ezt a módszert használja. minták vonalak.

A PRIOR kulcsszó az aktuális előtti sort adja vissza. Aktuálissá válik.

ABSOLUTE(sorszám | @sorszámváltozó) egy sort ad vissza az abszolút sorszámával a teljes eredményhalmazban kurzor. A sorszám megadható konstans segítségével vagy a sorszámot tároló változó neveként. A változónak egész adattípusúnak kell lennie. Mind a pozitív, mind a negatív értékek fel vannak tüntetve. Ha pozitív értéket ad meg, akkor a karakterlánc a készlet elejétől, a negatív érték a végétől számítódik. A kiválasztott sor az aktuális sor lesz. Ha null értéket ad meg, akkor nem ad vissza karakterláncot.

A RELATIVE argumentum (sorszám | @sorszám_változó) azt a karakterláncot adja vissza, amely az aktuális sor után megadott számú sor. Ha negatív értéket ad meg a sorok számának, akkor az a sor kerül visszaadásra, amelyik a megadott számú sor az aktuális előtt van. A null megadása az aktuális sort adja vissza. A visszaadott sor az aktuális sor lesz.

Nak nek globális kurzor megnyitása, a neve előtt a GLOBAL kulcsszóra van szükség. Név kurzor változó segítségével is megadható.

Az INTO @változó_neve [,...n] konstrukció megadja azoknak a változóknak a listáját, amelyek a visszaadott karakterlánc megfelelő oszlopértékeit tárolják. A változók megadásának sorrendjének meg kell egyeznie az oszlopok sorrendjével kurzor, és a változó adattípusa az oszlop adattípusa kurzor. Ha az INTO konstrukció nincs megadva, akkor a FETCH parancs viselkedése hasonlít a SELECT parancs viselkedésére - az adatok megjelennek a képernyőn.

A kurzor definiálva van. Típusainak és viselkedésének leírása található: statikus, dinamikus, szekvenciális és kulcskurzorok. Leírják a kurzorvezérlés alapelveit: kurzor létrehozása és megnyitása, adatok beolvasása, kurzor bezárása. Példák a kurzor programozására.

Kurzor fogalma

A relációs adatbázis-lekérdezés általában több adatsort (rekordot) ad vissza, de az alkalmazás egyszerre csak egy rekordot dolgoz fel. Még ha egyszerre több sorral is foglalkozik (például táblázatok formájában adatokat ad ki), ezek száma korlátozott. Ezenkívül az adatok módosításakor, törlésekor vagy hozzáadásakor a munkaegység a sor. Ebben a helyzetben a kurzor fogalma kerül előtérbe, és ebben az összefüggésben a kurzor egy sorra mutató mutató.

Az SQL-ben a kurzor az adatbázis-memória egy olyan régiója, amely az utolsó SQL-utasítás tárolására szolgál. Ha az aktuális utasítás egy adatbázis-lekérdezés, akkor a lekérdezési adatkarakterlánc, amelyet aktuális értéknek vagy aktuális kurzorsornak neveznek, szintén a memóriában tárolódik. A memória meghatározott területe el van nevezve, és az alkalmazásprogramok számára elérhető.

A kurzorokat általában az adatbázisban tárolt információk egy részhalmazának kiválasztására használják. Egyszerre egy kurzorsort ellenőrizhet az alkalmazás. A kurzorokat gyakran használják az eljárási nyelveken írt alkalmazásprogramokba ágyazott SQL-utasításokban. Ezek egy részét az adatbázis-kiszolgáló implicit módon hozza létre, míg másokat a programozók határoznak meg.

Az SQL szabványnak megfelelően a kurzorokkal végzett munka során a következő fő műveletek különböztethetők meg:

• teremtés ill kurzor deklaráció;
• kurzor megnyitása, azaz feltöltése többszintű memóriában tárolt adatokkal;
• lekérni a kurzorrólés adatsorok módosítása vele;
• kurzor bezárása, ami után elérhetetlenné válik a felhasználói programok számára;
• a kurzor felszabadítása, azaz a kurzor objektumként való törlése, mivel a bezárása nem feltétlenül szabadítja fel a hozzá tartozó memóriát.

A különböző megvalósításokban a kurzor definíciója eltérhet. Így például néha a fejlesztőnek kifejezetten fel kell szabadítania a kurzor számára lefoglalt memóriát. Után a kurzor felszabadítása a hozzá kapcsolódó memória is felszabadul. Ez lehetővé teszi a nevének újrafelhasználását. Más megvalósításokban kurzor bezárása a memória implicit módon felszabadul. Közvetlenül a gyógyulás után elérhetővé válik más műveletekhez: újabb kurzor megnyitása stb.

Egyes esetekben a kurzor használata elkerülhetetlen. Ezt azonban lehetőség szerint kerülni kell, és szabványos adatfeldolgozási parancsokkal kell dolgozni: SELECT , UPDATE , INSERT , DELETE . Amellett, hogy a kurzorok nem teszik lehetővé a módosítási műveletek végrehajtását a teljes adatmennyiségen, az adatfeldolgozási műveletek kurzorral történő végrehajtásának sebessége észrevehetően alacsonyabb, mint a szabványos SQL-eszközöké.

Kurzorok megvalósítása MS SQL Server környezetben

Az SQL Server háromféle kurzort támogat:

• Az SQL kurzorokat főként triggerekben, tárolt eljárásokban és szkriptekben használják;
• szerver kurzorok működnek a kiszolgálón, és megvalósítják az ODBC, OLE DB, DB_Library alkalmazásprogramozási felületét;
• a kliens kurzorok magán az ügyfélen vannak implementálva. A teljes eredménysort lekérik a szerverről, és helyben tárolják, ami felgyorsítja az adatfeldolgozási műveleteket a hálózati műveletek pazarlásának csökkentésével.

A különböző típusú többfelhasználós alkalmazások különböző típusú párhuzamos adathozzáférést igényelnek. Egyes alkalmazásoknak azonnali hozzáférésre van szükségük az adatbázis változásaival kapcsolatos információkhoz. Ez jellemző a jegyfoglalási rendszerekre. Más esetekben például a statisztikai adatszolgáltatási rendszerekben fontos az adatok stabilitása, mert ha folyamatosan módosulnak, akkor a programok nem lesznek képesek hatékonyan megjeleníteni az információkat. A különböző alkalmazásokhoz különböző kurzor-megvalósítások szükségesek.

Az SQL Server környezetben a kurzorok típusai különböznek az általuk biztosított képességek tekintetében. A kurzor típusát a létrehozás szakaszában határozzák meg, és nem módosítható. Egyes kurzortípusok képesek észlelni a többi felhasználó által az eredménykészletben szereplő sorokon végrehajtott módosításokat. Az SQL Server azonban csak a sor elérésének szakaszában követi nyomon az ilyen sorok változásait, és nem engedélyezi a módosítások módosítását a sor beolvasása után.

A kurzorok két kategóriába sorolhatók: egymást követőés görgethető. Egymás utáni lehetővé teszi az adatok kiválasztását csak egy irányban - az elejétől a végéig. Görgethető kurzorok nagyobb cselekvési szabadságot biztosít - mindkét irányban mozoghat, és a kurzor eredményhalmazának tetszőleges sorára ugorhat.Ha a program képes módosítani a kurzor által mutatott adatokat, akkor görgethetőnek és módosíthatónak nevezzük. A kurzorokról beszélve nem szabad megfeledkezni a tranzakciók elkülönítéséről. Amikor az egyik felhasználó módosít egy rekordot, a másik a saját kurzorával olvassa be, ráadásul ugyanazt a rekordot módosíthatja, ami szükségessé teszi az adatok integritásának megőrzését.

Az SQL Server támogatja a statikus, dinamikus, egymást követőés egy kulcskészlet vezérli.

A sémában statikus kurzor Az információkat egyszer beolvassa az adatbázisból, és pillanatfelvételként tárolja (valamilyen időpontban), így a másik felhasználó által az adatbázisban végrehajtott módosítások nem láthatók. Egy ideig kurzor megnyitása a szerver a teljes eredménykészletében szereplő összes soron zárolást kap. Statikus kurzor nem változik a létrehozás után, és mindig azt az adatkészletet jeleníti meg, amely a megnyitásakor létezett.

Ha más felhasználók megváltoztatják a kurzorban szereplő adatokat a forrástáblázatban, ez nem befolyásolja a statikus kurzor.

BAN BEN statikus kurzor Nem módosíthat, ezért mindig csak olvasható módban nyílik meg.

Dinamikus kurzoréletben tartja az adatokat, de ehhez hálózati és szoftvererőforrások szükségesek. Használata dinamikus kurzorok a forrásadatok teljes másolata nem jön létre, hanem csak akkor történik dinamikus kiválasztás a forrástáblázatokból, amikor a felhasználó hozzáfér bizonyos adatokhoz. A lekérés során a szerver zárolja a sorokat, és a felhasználó által a kurzor teljes eredménykészletén végrehajtott változtatások láthatóak lesznek a kurzorban. Ha azonban egy másik felhasználó változtatásokat hajtott végre azután, hogy a kurzor lekérte az adatokat, azok nem fognak megjelenni a kurzorban.

A kurzort egy sor billentyű vezérli, ezek között a szélsőségek között található. A rekordokat a mintavételkor azonosítják, és így nyomon követik a változásokat. Ez a fajta kurzor hasznos a visszagörgetés megvalósításához, így a sorok hozzáadása és törlése nem látható az információ frissítéséig, és az illesztőprogram kiválasztja a bejegyzés új verzióját, ha módosításokat hajt végre rajta.

Szekvenciális kurzorok ne engedje meg az adatok fordított irányú lekérését. A felhasználó csak a kurzor elejétől a végéig jelölhet ki sorokat. Szekvenciális kurzor nem tárolja az összes sor halmazát. Amint kijelölik őket a kurzorban, azonnal kiolvassák őket az adatbázisból, ami lehetővé teszi, hogy dinamikusan tükrözze a felhasználók által az INSERT , UPDATE , DELETE parancsokkal az adatbázisban végrehajtott változtatásokat. A kurzor az adatok legfrissebb állapotát mutatja.

Statikus kurzorok stabil nézetet biztosítanak az adatokról. Jók információs "raktár" rendszerekhez: jelentési rendszerek alkalmazásához vagy statisztikai és elemzési célokra. Kívül, statikus kurzor másoknál jobban megbirkózik a nagy mennyiségű adat mintavételével. Éppen ellenkezőleg, az elektronikus jegyvásárlási vagy -foglalási rendszerekben szükség van arra, hogy dinamikusan észleljék a frissített információkat a változások során. Ilyen esetekben használja dinamikus kurzor. Ezekben az alkalmazásokban az átvitt adatok mennyisége általában kicsi, az ezekhez való hozzáférés sorok (egyedi rekordok) szintjén történik. A csoportos hozzáférés nagyon ritka.

Kurzorvezérlés MS SQL Server környezetben

Kurzorvezérlés a következő parancsok végrehajtásával valósítható meg:

• DECLARE - hozzon létre vagy kurzor deklaráció;
• NYISD KI- kurzor megnyitása, azaz adatokkal való kitöltése;
• FETCH- lekérni a kurzorrólés adatsorok megváltoztatása kurzorral;
• BEZÁRÁS- kurzor bezárása;
• DEALLOCATE- a kurzor felszabadítása, azaz a kurzor törlése objektumként.

Kurzor deklaráció

Az SQL szabvány a következő parancsot adja a kurzor létrehozásához:

Az INSENSITIVE kulcsszó használatával létrejön statikus kurzor. Adatváltozások nem engedélyezettek, továbbá a más felhasználók által végzett módosítások nem jelennek meg. Ha az INSENSITIVE kulcsszó nincs jelen, egy dinamikus kurzor.

A SCROLL kulcsszó megadásával a generált kurzor tetszőleges irányba görgethető, lehetővé téve bármilyen kiválasztási parancs alkalmazását. Ha ezt az argumentumot kihagyjuk, a kurzor a következő lesz következetes, azaz megtekintése csak egy irányban lesz lehetséges – az elejétől a végéig.

A SELECT utasítás adja meg a SELECT lekérdezés törzsét, amely a kurzorsorok eredményhalmazának meghatározására szolgál.

A FOR READ_ONLY argumentum megadása csak olvasható kurzort hoz létre, és nem teszi lehetővé az adatok módosítását. Ez különbözik a statikustól, bár az utóbbi szintén nem teszi lehetővé az adatok megváltoztatását. Csak olvasható kurzorként deklarálható dinamikus kurzor, amely egy másik felhasználó által végrehajtott módosításokat jeleníti meg.

A FOR UPDATE argumentumú kurzor létrehozása lehetővé teszi a kurzorban való végrehajtást adatváltozás vagy a megadott oszlopokban, vagy az oszlopnév OF argumentum hiányában az összes oszlopban.

Az MS SQL Server környezetben a kurzorlétrehozó parancs következő szintaxisa elfogadott:

<создание_курсора>::= DECLARE cursor_name CURSOR FOR SELECT_utasítás ]]

A LOCAL kulcsszó használatával helyi kurzor jön létre, amely csak az azt létrehozó csomagban, triggerben, tárolt eljárásban vagy felhasználó által meghatározott függvényben látható. Amikor egy csomag, trigger, eljárás vagy függvény leáll, a kurzor implicit módon megsemmisül. Ha a kurzor tartalmát az azt létrehozó konstrukción kívül szeretné átadni, egy OUTPUT argumentumot kell hozzárendelnie a paraméteréhez.

Ha a GLOBAL kulcsszó van megadva, egy globális kurzor jön létre; az aktuális kapcsolat bezárásáig létezik.

A FORWARD_ONLY megadása létrehozza szekvenciális kurzor; adatokból csak az első sortól az utolsóig terjedő irányban lehet mintát venni.

A SCROLL megadása létrehozza görgethető kurzor; az adatok tetszőleges sorrendben és bármilyen irányban elérhetők.

A STATIC megadása létrehozza statikus kurzor.

A KEYSET megadása kulcskurzort hoz létre.

A DYNAMIC megadásával létrejön dinamikus kurzor.

Ha megadja a FAST_FORWARD argumentumot egy READ_ONLY kurzorhoz, a generált kurzor a gyors adatelérésre lesz optimalizálva. Ez az argumentum nem használható a FORWARD_ONLY és az OPTIMISTIC argumentumokkal együtt.

Az OPTIMISTIC argumentummal létrehozott kurzor megakadályozza az azóta módosított sorok módosítását és törlését. kurzor megnyitása.

A TYPE_WARNING argumentummal a szerver tájékoztatja a felhasználót a kurzortípus implicit változásáról, ha az nem kompatibilis a SELECT lekérdezéssel.

A kurzor megnyitása

Mert kurzor megnyitásaés a SELECT lekérdezési kurzor létrehozásakor a megadott adatokkal kitöltve a következő parancsot használjuk:

Után kurzor megnyitása a hozzá tartozó SELECT utasítás végrehajtásra kerül, melynek kimenete a réteges memóriában tárolódik.

Adatok lekérése a kurzorról

Közvetlenül utána kurzor megnyitása tartalmát (a megfelelő lekérdezés eredményét) a következő paranccsal választhatjuk ki:

A FIRST megadása a kurzor teljes eredménykészletének legelső sorát adja vissza, amely az aktuális sor lesz.

A LAST megadása a kurzor legutóbbi sorát adja vissza. Ez lesz az aktuális sor is.

A NEXT megadása közvetlenül az aktuális sor utáni sort adja vissza a teljes eredményhalmazban. Most aktuálissá válik. Alapértelmezés szerint a FETCH parancs ezt a módszert használja a sorok lekérésére.

A PRIOR kulcsszó az aktuális előtti sort adja vissza. Aktuálissá válik.

Érv ABSZOLÚT (sor_szám | @sor_szám_változó) egy sort ad vissza az abszolút sorszámával a kurzor teljes eredményhalmazában. A sorszám megadható konstans segítségével vagy a sorszámot tároló változó neveként. A változónak egész adattípusúnak kell lennie. Mind a pozitív, mind a negatív értékek fel vannak tüntetve. Ha pozitív értéket ad meg, akkor a karakterlánc a készlet elejétől, a negatív érték a végétől számítódik. A kiválasztott sor az aktuális sor lesz. Ha null értéket ad meg, akkor nem ad vissza karakterláncot.

Érv RELATÍV (sor_száma | @sor_szám_változó) azt a karakterláncot adja vissza, amely a megadott számú sor után van az aktuális után. Ha negatív értéket ad meg a sorok számának, akkor az a sor kerül visszaadásra, amelyik a megadott számú sor az aktuális előtt van. A null megadása az aktuális sort adja vissza. A visszaadott sor az aktuális sor lesz.

Nak nek globális kurzor megnyitása, a neve előtt a GLOBAL kulcsszóra van szükség. A kurzor neve változó használatával is megadható.

Építés alatt INTO @változónév [,...n] meg van adva egy változólista, amelyben a visszaadott sor megfelelő oszlopértékei kerülnek tárolásra. A változók sorrendjének meg kell egyeznie a kurzorban lévő oszlopok sorrendjével, a változó adattípusának pedig meg kell egyeznie a kurzoroszlop adattípusával. Ha az INTO konstrukció nincs megadva, akkor a FETCH parancs viselkedése hasonlít a SELECT parancs viselkedésére - az adatok megjelennek a képernyőn.

Adatok módosítása és törlése

A kurzor használatával történő módosításokhoz ki kell adnia egy UPDATE parancsot a következő formátumban:

A kurzor aktuális sorának több oszlopa módosítható egy műveletben, de mindegyiknek ugyanahhoz a táblához kell tartoznia.

Az adatok kurzorral történő törléséhez használja a DELETE parancsot a következő formátumban:

Ennek eredményeként a kurzorban beállított áramvonal törlődik.

A kurzor bezárása

A bezárás után a kurzor elérhetetlenné válik a program felhasználói számára. Záráskor a működése során beállított összes zár eltávolításra kerül. A bezárás csak nyitott kurzorokra alkalmazható. zárva, de nem felszabadított kurzorújra kinyitható. A megnyitatlan kurzor bezárása nem megengedett.

A kurzor felszabadítása

A kurzor bezárása opcionálisan felszabadítja a hozzá tartozó memóriát. Egyes megvalósításokban kifejezetten fel kell oldania a DEALLOCATE utasítással. Után a kurzor felszabadítása memória is felszabadul, és a kurzor neve újra felhasználható.

A kurzor végének elérésének szabályozásához ajánlott a @@FETCH_STATUS függvény használata

A @@FETCH_STATUS függvény a következőket adja vissza:

0, ha a letöltés sikeres volt;

1, ha a lehívás a kurzoron kívüli sor lekérésére tett kísérlet miatt sikertelen volt;

2, ha a lekérés egy törölt vagy módosított sor elérési kísérlete miatt sikertelen volt.

DECLARE @id_kl INT, @firm VARCHAR(50), @fam VARCHAR(50), @message VARCHAR(80), @nam VARCHAR(50), @d DATETIME, @p INT, @s INT SET @s=0 NYOMTATÁS " Bevásárlólista" DECLARE klient_cursor CURSOR LOCAL FOR SELECT Ügyfélazonosító, Vállalat, Vezetéknév FROM Ügyfél WHERE Város="Moszkva" ORDER BY Cég, Vezetéknév OPEN klient_cursor ELÉRÉS KÖVETKEZŐ A klient_cursor INTO @id_kl, @firm, @fam CH_STATUS @@FET =0 BEGIN SELECT @message="Ügyfél "+@fam+ " Cég "+ @firm PRINT @üzenet SELECT @message="Terméknév Dátum Vásárlási költség" PRINT @üzenet NYOMTATÁSA tovar_cursor KURSZOR A KIVÁLASZTÁSHOZ Cikknév, Ügylet.Dátum, Cikk .Ár* Tranzakció Mennyiség, mint költség AZ Áru BELSŐ CSATLAKOZTATÁSA Tranzakció az árura. ItemID=Trade.ItemID WHERE Trade.CustomerID=@id_kl OPEN tovar_cursor FETCH NEXT FROM FROM tovar_cursor INTO @nam, @d, @p IF @@FETCH_STATUS<>0 NYOMTATÁS " Nincs vásárlás" WHILE @@FETCH_STATUS=0 BEGIN SELECT @message=" "+@nam+" "+ CAST(@d AS CHAR(12))+" "+ CAST(@p AS CHAR(6)) NYOMTATÁS @message SET @s=@s+@p ELKÉRÉS KÖVETKEZŐ A tovar_cursortól BE @nam, @d, @p VÉGE CLOSE tovar_cursor FELVONÁSA tovar_cursor SELECT @message="Teljes költség "+ CAST(@s AS CHAR(6)) PRINT @message -- ugrás a következő kliensre -- HOZZÁ EL A KÖVETKEZŐ klient_cursor AZ @id_kl, @firm, @fam BEÁLLÍTÁSA VÉGE klient_cursor A klient_cursor LETÖLTÉSE 13.6. példa. Kurzor a moszkvai ügyfelek által vásárolt áruk listájának és teljes költségének megjelenítéséhez.

13.7. példa. Görgethető kurzor fejlesztése moszkvai ügyfelek számára. Ha a telefonszám 1-gyel kezdődik, távolítsa el az adott számmal rendelkező ügyfelet, és az első kurzorbevitelben cserélje ki a telefonszám első számjegyét 4-re.

BEJELENTKEZÉS @cég VARCHAR(50), @fam VARCHAR(50), @tel VARCHAR(8), @üzenet VARCHAR(80) "Ügyfelek listája" NYOMTATÁSA kliens_kurzor KURSZOR GLOBÁLIS GÖRGŐBILLENTYŰ KIVÁLASZTÁSÁRA VÁLASZTOTT Vállalat, Vezetéknév, Telefon Az ügyféltől WHERE Város ="Moszkva" RENDELÉS VÁLLALAT SZERINT, Vezetéknév FRISSÍTÉSHEZ MEGNYITÁS klient_cursor LÉPÉS KÖVETKEZŐBŐL klient_cursor INTO @firm, @fam, @tel WHILE @@FETCH_STATUS=0 KEZDÉS KIVÁLASZT @message="Kliens "+@fam+" Company "+ @firm " Phone "+ @tel PRINT @üzenet -- ha a telefonszám 1-gyel kezdődik, -- törölje a klienst ezzel a számmal IF @tel LIKE '1%' TÖRLÉS Kliens WHERE CURRENT OF klient_cursor EGYÉB -- ugrás a következő klienshez FETCH NEXT FROM klient_cursor INTO @firm, @fam, @tel VÉGE FETCH ABSOLUTE 1 FROM klient_cursor INTO @firm, @fam, @tel -- az első bejegyzésben cserélje ki az első számjegyet a -- telefonszámban 4 UPDATE Client SET Phone='4' + JOBBRA(@ tel,LEN(@tel)-1)) WHERE AZ ügyfél_kurzor AKTUÁLIS KIVÁLASZTÁSA @message="Ügyfél "+@fam+" Cég "+ @firm " Telefon "+ @tel NYOMTATÁS @üzenet BEZÁR klient_cursor A klient_kurzor FELTÉTELÉSE 13.7. példa. Görgethető kurzor moszkvai ügyfelek számára.

13.8. példa. Használat kurzort egy eljárás kimeneti paramétereként. Az eljárás visszaad egy adatkészletet - az áruk listáját.

Az eljárás meghívása és az adatok kinyomtatása a kimeneti kurzorból a következőképpen történik:

DECLARE @my_cur CURSOR DECLARE @n VARCHAR(20) EXEC my_proc @cur=@my_cur OUTPUT FETCH NEXT FROM @my_cur INTO @n SELECT @n WHILE (@@FETCH_STATUS=0) INDÍTSA KÖVETKEZŐ LEHETSÉGET @my_cur @n @n VÉGE BEZÁR @my_cur FELTÉTELEZÉS @my_cur

1) Kurzor koncepció
Az interaktív SQL-ben nincs különbség az egysoros és a többsoros lekérdezések között. A beágyazott SQL-ben ezek a lekérdezések eltérően hajtódnak végre. Az egysoros lekérdezések egy sort adnak vissza, és már megvizsgáltuk. Ha egy lekérdezés egynél több sort eredményez, a beágyazott SQL-nek lehetővé kell tennie az alkalmazás számára, hogy soronként lekérje a lekérdezés eredményeit. Ehhez kurzorokat használnak. A kurzor egy lekérdezéshez társított változó. Értéke minden olyan sor, amelyik kielégíti a lekérdezést. A változókhoz hasonlóan a kurzorokat is deklarálni kell használatuk előtt. A nézetekkel ellentétben a kurzorokat soronkénti feldolgozásra tervezték.

2) Kurzor deklaráció

KIJELENT [{}] [[NEM] TEKERCS] KURZOR [{NÉLKÜL} TART] FOR [FOR {CSAK OLVASÁS | FRISSÍTÉS [NAK,-NEK ]}]

3) Kulcsszavak
. ÉRZÉKENY|ÉRZÉKENY|ÉRZÉKENY– az eredményhalmaz változásai láthatók | tiltott (az adatkészlet másolatával rögzítve)|A DBMS maga dönti el, hogy készít-e másolatot (alapértelmezés szerint működik).
. TARTÁS NÉLKÜL– levelek nyitva | bezárja a kurzort, ha COMMIT utasítást észlel.
. TEKERCS– [tiltja] az eredménysorok véletlen sorrendű lekérését.
. CSAK OLVASÁSRA– csak olvasható kurzort határoz meg.
. FRISSÍTÉSÉHEZ– Csak a megadott oszlopok frissítését blokkolja.

4) Kurzor deklaráció az SQL Serverben

KIJELENT KURZOR [HELYI|GLOBÁLIS] [FORWARD_ONLY|GÖRGETÉS] [STATIC|KEYSET|DINAMIKUS|GYORS_FORWARD] [READ_ONLY|SCROLL_LOCKS|OPTIMISTA] FOR [FRISSÍTÉSHEZ [NAK,-NEK ]]

. STATIKUS– Meghatároz egy kurzort, amely ideiglenes másolatot hoz létre az adatokról a kurzor általi használatra. Minden kurzorlekérdezés a tempdb-ben megadott ideiglenes táblára hivatkozik, így az alaptáblázatok módosításai nem befolyásolják a kurzorhoz tartozó selectek által visszaadott adatokat, és maga a kurzor sem enged változtatásokat.
. KEYSET– Megadja, hogy a kurzorban lévő tagság vagy sorok sorrendje nem módosul a megnyitás után. A sorokat egyedileg azonosító kulcskészlet a tempdb-adatbázis kulcskészletének táblájába van beágyazva.
. DINAMIKUS– Meghatároz egy kurzort, amely megjeleníti a kurzor megtekintése közben az eredményhalmaz soraiban végrehajtott összes adatmódosítást. Az egyes mintákban az adatértékek, a sorrend és a sorok tagsága változhat. Az ABSZOLÚT kiválasztási opciót a dinamikus kurzorok nem támogatják.
. ELŐREPÖRGETÉS– Egy FORWARD_ONLY, READ_ONLY kurzort ad meg, amelyhez a teljesítményoptimalizálás engedélyezve van. A FAST_FORWARD opció nem adható meg a SCROLL vagy FOR_UPDATE opciókkal.
. SCROLL_LOCKS– Azt jelzi, hogy a kurzorral végzett pozicionált frissítések vagy törlések garantáltan sikeresek lesznek. Az SQL Server zárolja a sorokat, amikor beolvasásra kerülnek a kurzorba, így biztosítva, hogy későbbi módosításokhoz elérhetők legyenek. A SCROLL_LOCKS beállítás nem adható meg a FAST_FORWARD vagy a STATIC opcióval.
. OPTIMISTA– Megadja, hogy a kurzoron keresztül végrehajtott pozicionált frissítések vagy törlések nem hajthatók végre, ha a sor a kurzorba való beolvasás óta frissült. Az SQL Server nem zárolja a sorokat, amikor beolvassák a kurzorba. Ehelyett egy időbélyeg-oszlopot (vagy ellenőrző összeget, ha a táblázatban nincs időbélyegzőoszlop) összehasonlít a rendszer annak meghatározására, hogy a sor megváltozott-e a kurzorba való beolvasás óta. Ha egy sort módosítottak, akkor a pozíció megváltoztatása vagy törlése nem lehetséges. Az OPTIMISTIC beállítás nem adható meg a FAST_FORWARD opcióval.

5) A kurzor megnyitása

6) Vonja ki a sorokat a kurzorból

FETCH [{KÖVETKEZŐ|ELŐZŐ|ELSŐ|UTOLSÓ|{ABSZOLÚT|RELATÍV }}]
TÓL TŐL BA

7) Kurzor pozicionálási lehetőségek
. KÖVETKEZŐ|ELŐZŐ|ELSŐ|UTOLSÓ– az eredményhalmaz következő|előző|első|utolsó sorához.
. RELATÍV±N– az aktuális vonalhoz képest pozitív vagy negatív eltolású vonalra.
. ABSZOLÚT±N– a kurzor elejétől vagy végétől egy kifejezetten meghatározott abszolút pozíciószámú sorra.

jegyzet: Az SQL Serverben az @N egész szám változó megengedett N helyett.

8) A kurzor bezárása

9) Megjegyzések a kurzorokhoz
. Ha a kurzor egynél több sort tartalmaz, akkor rendszeresíteni kell egy hurkot az adatok kinyeréséhez, időszakos ellenőrzéssel, hogy elérték-e az utolsó sort.
. A táblázatokkal és nézetekkel ellentétben a kurzorsorok vagy kifejezetten egy szakasz használatával vannak rendezve RENDEZÉS, vagy az adott DBMS-ben elfogadott egyezményeknek megfelelően.
. A kurzorok a táblázatokból sorcsoportok kiválasztására is szolgálnak, amelyek egyenként frissíthetők vagy törölhetők.
. Ahhoz, hogy a kurzor frissíthető legyen, ugyanazoknak a feltételeknek kell megfelelnie, mint egy nézetnek, azaz nem tartalmazhat szakaszokat UNION, ORDER BY, GROUP BY, DISTINCT.

10) Példa adatok törlésére a kurzorból

exec sql deklarálja a Cur1 kurzort az Ügyfél * kiválasztásához
ahol Értékelés
// nyomtatás (@f1+' '+convert(Varchar(5),@f2))
exec sql törlés az Ügyfélből
ahol Cur1 árama; ) – Vegye ki a kurzorból a törölni kívánt adatokat
not_done:
exec sql kurzor bezárása Cur1; - zárja be a kurzort
kijárat();

11) Példa a jutalék növekedésére

exec sql deklarálja a kurzort CurCust for select * from SalesPeople
ahol SNum in (Válasszon SNum from Customer, ahol Értékelés=300); - Adja meg a kurzort
exec sql nyitott kurzor CurCust; - Futtassa a kurzort
while (sqlca.sqlcode==0) ( - Hozzon létre egy ciklust a táblázat adatainak frissítéséhez
exec sql fetch CurCust into:Id_num, :SalesPerson, :Loc, :Comm;
exec sql update A SalesPeople Comm=Comm+.01 értéket állítja be, ahol aktuális
a CurCust; ) – A frissítendő adatok a kurzorból származnak
exec sql kurzor bezárása CurCust; - zárja be a kurzort

SELECT S.Name, MAX(S.City) AS Város, SUM(O.Amt) AS Amt FROM SalesPeople S BELSŐ CSATLAKOZÁS Rendelések O ON S.SNum=O.SNum CSOPORT BY S.Name ORDER BY 2

NYILVÁNÍTÁSA Cur1 GÖRGŐZŐ KURSZOR FOR SELECT S. Name, MAX(S.City) AS Város, SUM(O.Amt) AS Amt FROM SalesPeople S BELSŐ CSATLAKOZÁS Rendelések O ON S.SNum=O.SNum CSOPORT S.NÉV SZERINT 2 RENDELÉS
NYITÁS Cur1
HOZZÁ EL A KÖVETKEZŐT Cur1-ről
WHILE @@FETCH_STATUS=0
KEZDŐDIK
HOZZÁ EL A KÖVETKEZŐT Cur1-ről
VÉGE
ZÁRÁS Cur1
FELVONÁSA Cur1