Kurzorok. DECLARE CURSOR parancs általános szabályok Az SQL kurzorok lebonyolítása

A T-SQL kódomban mindig halmazalapú műveleteket használok. Azt mondták nekem, hogy az SQL Server az ilyen típusú műveletek feldolgozására készült, és gyorsabbnak kell lennie, mint a soros feldolgozásnak. Tudom, hogy léteznek kurzorok, de nem tudom, hogyan kell használni őket. Tudsz adni néhány kurzor példát? Tudna adni valami útmutatást, hogy mikor kell kurzort használni? Feltételezem, hogy a Microsoft valamiért belevette őket az SQL Serverbe, így kell lennie egy helynek, ahol hatékonyan használhatók.

megoldás

Egyes körökben a kurzorokat soha nem használják, másokban végső megoldásként, más csoportokban pedig rendszeresen használják őket. Mindegyik táborban más-más okuk van a kurzorhasználattal kapcsolatos álláspontjukra. Függetlenül attól, hogy a kurzorokkal állsz, valószínűleg bizonyos körülmények között van helye, másokban nem. Tehát a kódolási technikának, majd az adott probléma megértésének a függvénye, hogy eldöntse, megfelelő-e a kurzoralapú feldolgozás vagy sem. csináld a következőt:

Nézz meg egy példa kurzort
Bontsa fel a kurzor összetevőit
Adjon további kurzorpéldákat
Elemezze a kurzor használatának előnyeit és hátrányait

Hogyan hozzunk létre SQL Server kurzort

Az SQL Server-kurzor létrehozása következetes folyamat, így a lépések megtanulása után könnyen megkettőzheti azokat különböző logikai készletekkel az adatok hurkolásához. Nézzük végig a lépéseket:

Először deklarálja a szükséges változókat a logikában.
Másodszor deklarálja a kurzort egy adott névvel, amelyet a logikában fog használni. Ezt azonnal követi a kurzor megnyitása.
Harmadszor, lekér egy rekordot a kurzorból az adatfeldolgozás megkezdéséhez.
Negyedszer, az adatfolyamat, amely minden logikakészletre egyedi. Ez lehet beszúrás, frissítés, törlés stb. minden egyes lekért adatsorhoz. Ez a legfontosabb logikakészlet ebben a folyamatban, amelyet minden sorban végrehajtanak.
Ötödször, lekéri a következő rekordot a kurzorról, ahogy a 3. lépésben tette, majd a 4. lépést ismételje meg a kiválasztott adatok feldolgozásával.
Hatodszor, az összes adat feldolgozása után bezárja a kurzort.
Utolsó és fontos lépésként fel kell szabadítania a kurzort az SQL Server által tárolt összes belső erőforrás felszabadításához.

Innentől kezdve tekintse meg az alábbi példákat, hogy megtudja, mikor és hogyan kell használni az SQL Server kurzorait.

Példa SQL Server kurzorra

Íme egy példa kurzor a tippből. Egyszerű szkript az összes olyan SQL Server-adatbázis biztonsági mentéséhez, ahol a biztonsági mentések soros módon készülnek:

DECLARE @név VARCHAR(50) -- adatbázisnév DECLARE @elérési út VARCHAR(256) -- mentési fájlok elérési útja DECLARE @fájlnév VARCHAR(256) -- fájlnév biztonsági mentéshez DECLARE @fileDate VARCHAR(20) -- a SET fájlnévhez használatos @path = "C:\Backup\" SELECT @fileDate = CONVERT(VARCHAR(20),GETDATE(),112) DECLARE db_cursor CURSOR FOR SELECT név FROM MASTER.dbo.sysdatabases WHERE név NOT IN ("master","modell" ","msdb","tempdb") MEGNYITÁSA db_kurzor MEGNYITÁSA KÖVETKEZŐ A db_kurzorból @name WHILE @@FETCH_STATUS = 0 BEÁLLÍTÁS KEZDÉSE @fileName = @útvonal + @név + "_" + @fileDate + ".BAK" BIZTONSÁGI ADATBÁZIS @ név A LEMEZRE = @fájlnév FELTÉTEL KÖVETKEZŐ A db_cursor INTO @név VÉGE ZÁRÁSA db_cursor FELTÉTELEZÉSE db_kurzor

Az SQL Server kurzor összetevői

A fenti példa alapján a kurzorok a következő összetevőket tartalmazzák:

DECLARE utasítások - A kódblokkban használt változók deklarálása
SET\SELECT utasítások - Inicializálja a változókat egy adott értékre
DECLARE CURSOR utasítás – Töltse ki a kurzort a kiértékelendő értékekkel
- MEGJEGYZÉS – A DECLARE CURSOR FOR utasításban azonos számú változó található, mint a SELECT utasításban. Ez lehet 1 vagy több változó és kapcsolódó oszlopok.
OPEN utasítás – Nyissa meg a kurzort az adatfeldolgozás megkezdéséhez
FETCH NEXT utasítások – Rendelje hozzá a kurzorból a változókhoz a konkrét értékeket
- MEGJEGYZÉS – Ezt a logikát a WHILE utasítás előtti kezdeti sokasághoz, majd a folyamat minden ciklusához használják a WHILE utasítás részeként.
WHILE utasítás - Az adatfeldolgozás megkezdésének és folytatásának feltétele
BEGIN...END utasítás – A kódblokk eleje és vége
- MEGJEGYZÉS - Az adatfeldolgozás alapján több BEGIN...END utasítás is használható
Adatfeldolgozás - Ebben a példában ez a logika az adatbázis biztonsági mentését szolgálja egy adott elérési útra és fájlnévre, de ez lehet bármilyen DML vagy adminisztrációs logika.
CLOSE utasítás - Feloldja az aktuális adatokat és a kapcsolódó zárolásokat, de lehetővé teszi a kurzor újbóli megnyitását
DEALLOCATE utasítás - Megsemmisíti a kurzort

Ajánlott irodalom

További információ az SQL Server kurzorokról és azok alternatíváiról:

További SQL Server kurzor példák

A fenti példában a biztonsági mentések kurzoron keresztül kerülnek kiadásra, tekintse meg az alábbi tippeket, amelyek a kurzor alapú logikát hasznosítják:

Parancsfájl az SQL Server idegenkulcs-megszorításainak letiltásához, engedélyezéséhez, eldobásához és újbóli létrehozásához

SQL Server kurzorelemzés

Az alábbi elemzés célja, hogy betekintést nyújtson különböző forgatókönyvekbe, ahol a kurzor alapú logika előnyös lehet, vagy nem:

Online tranzakciófeldolgozás (OLTP) – A legtöbb OLTP-környezetben a SET-alapú logika a legésszerűbb a rövid tranzakciókhoz. Csapatunk belefutott egy harmadik féltől származó alkalmazásba, amely minden feldolgozáshoz kurzorokat használ, ami problémákat okozott, de ez ritka eset. A SET alapú logika általában több mint megvalósítható, és kurzorokra ritkán van szükség.
Jelentéskészítés – A jelentések kialakítása és az alapul szolgáló terv alapján a kurzorokra jellemzően nincs szükség. Csapatunk azonban olyan jelentési követelményekbe ütközött, ahol a hivatkozási integritás nem létezik az alapul szolgáló adatbázisban, és kurzort kell használni a jelentési értékek helyes kiszámításához. Ugyanezt a tapasztalatot szereztük, amikor a downstream folyamatokhoz szükséges adatokat kellett összesíteni, a kurzor alapú megközelítés gyorsan kidolgozott, és az igények kielégítésére elfogadható módon teljesített.
Soros feldolgozás – Ha egy folyamatot sorozatosan kell végrehajtania, a kurzorok egy életképes megoldás.
Adminisztrációs feladatok - Sok adminisztrációs feladatot soros módon kell végrehajtani, ami jól illeszkedik a kurzor alapú logikába, de más rendszer alapú objektumok is léteznek az igény kielégítésére. Bizonyos esetekben a kurzorokat a folyamat befejezéséhez használják.
Nagy adatkészletek – Nagy adatkészletek esetén a következők bármelyikébe ütközhet:
- Előfordulhat, hogy a kurzor alapú logika nem felel meg a feldolgozási igényeknek.
- A minimális memóriával rendelkező kiszolgálókon végzett nagy halmazalapú műveletek esetén előfordulhat, hogy az adatok lapozgatnak, vagy monopolizálhatják az SQL Servert, ami időigényes versengést és memóriaproblémákat okozhat. Mint ilyen, a kurzor alapú megközelítés kielégítheti az igényt.
- Egyes eszközök eleve gyorsítótárazzák az adatokat a burkolatok alatt lévő fájlba, így a memóriában lévő adatok feldolgozása ténylegesen megtörténhet, vagy nem.
- Ha az adatok feldolgozhatók egy átmeneti SQL Server-adatbázisban, akkor a termelési környezetre gyakorolt hatás csak a végső adatok feldolgozásakor jelentkezik. A staging szerveren lévő összes erőforrás felhasználható az ETL folyamatokhoz, majd a végső adatok importálhatók.
- Az SSIS támogatja az adatkészletek kötegelését, ami megoldhatja azt az általános igényt, hogy egy nagy adatkészletet jobban kezelhető méretekre bontsanak, és jobban teljesítsenek, mint a kurzorral történő soronkénti megközelítés.
- A kurzor vagy az SSIS-logika kódolásától függően lehetséges lehet az újraindítás a meghibásodás helyén egy
- Ismételjen meg egy köteget a GO paranccsal
Következő lépések
- Amikor egy adatfeldolgozási döntés előtt áll, határozza meg, hol áll az SQL Server kurzorhasználatával. Lehet, hogy van helyük az Ön alkalmazásában vagy működési folyamataiban, de lehet, hogy nem. Egy feladat végrehajtásának számos módja van, ezért a kurzor használata ésszerű alternatíva lehet, vagy sem. Te légy a bíró.
- Ha problémákba ütközik egy másik kódolási technikával, és gyorsan el kell végeznie valamit, a kurzor használata életképes alternatíva lehet. Előfordulhat, hogy az adatok feldolgozása tovább tart, de a kódolási idő sokkal rövidebb lehet. Ha egyszeri vagy éjszakai feldolgozása van, akkor ez megoldhatja a trükköt.
- Ha a kurzorok kerülik a környezetet, mindenképpen válasszon egy másik használható alternatívát. Csak győződjön meg arról, hogy a folyamat nem okoz más problémákat. Például, ha egy kurzort használnak, és sorok millióit dolgozzák fel, akkor ez esetleg kiüríti az összes adatot a gyorsítótárból, és további vitákat okoz? Vagy nagy adathalmaznál az adatokat lemezre lapozzák vagy ideiglenes könyvtárba írják?
- A kurzor alapú megközelítés és más alternatívák értékelése során tisztességesen hasonlítsa össze a technikákat az idő, a versengés és a szükséges erőforrások tekintetében. Remélhetőleg ezek a tényezők elvezetik Önt a megfelelő technikához.

Könnyen megtörténhet, hogy egy egyszerű ügyfélkérésre több százezer sorból álló válogatás lesz a válasz, ami a legtöbb ügyfél számára emészthetetlen. Ebben az esetben az ügyfelekkel való interakció problémájának megoldása a kurzorok használata univerzális mechanizmusként a szerver és a kliens közötti adatcseréhez. A kurzorok az eredményül kapott adatkészlettel (a lekérdezés eredményével) működnek együtt, és további lehetőségeket biztosítanak a felhasználóknak az adatfeldolgozáshoz:

A kurzorok lehetővé teszik a táblázatsorokkal való munkát, ha megadják a sorszámukat az adatkészletben;

A kurzorok lehetővé teszik összetett adatmódosítási műveletek végrehajtását, például amikor egy oszlop értékének megváltoztatásához más oszlopok értékeinek ismételt elérése szükséges.

A kurzor életciklusa:

Kurzor létrehozása: KIJELENT<имя курсора>[Érzéketlen] [SCROLL] CURSOR FOR< SELECT -оператор>( CSAK OLVASÁSRA | FRISSÍTÉS )

Itt az INSENSITIVE kulcsszó azt jelenti, hogy a kurzor statikus lesz (az adatok pillanatképe), míg alapértelmezés szerint a kurzor dinamikus (a kijelölés minden alkalommal megtörténik, amikor a sorhoz hozzáfér). A SCROLL kulcsszó azt jelenti, hogy a kurzor bármilyen irányba görgethető, ellenkező esetben a kurzor "szekvenciálisan" jön létre.

Kurzor megnyitása: NYITOTT[GLOBÁLIS]<имя курсора>. A GLOBAL-ként megadott kurzor nem törlődik automatikusan, amikor az eljárás vagy csomag, amelyből meghívták, leáll.

Olvasásadat : FETCH [[ KÖVETKEZŐ | ELŐZETES | ELSŐ | utolsó | ABSZOLÚT n | RELATÍV n ] TÓL ] [ GLOBÁLIS ]<имя курсора>[ INTO @ változó _ neve , …]. Az SQL Server 2000 csak egy sor kiolvasását teszi lehetővé a kurzorból. Az ELSŐ kulcsszó a kurzor első sorának visszaadása; LAST - a kurzor utolsó sora; NEXT - az aktuális után következő sor, a visszaadott sor lesz az aktuális; PRIOR - az előző az aktuális előtt; ABSOLUTE n - egy karakterláncot ad vissza a kurzorban lévő abszolút sorszámával; RELATIVE - n sor az aktuális után. Az oszlopadatok az egyes megadott változókban a felsorolás sorrendjében kerülnek tárolásra.

Adatváltozás: végrehajt egy UPDATE parancsot a kurzorokkal való együttműködésre tervezett szintaxissal.

Adatok törlése: végrehajt egy DELETE parancsot a kurzorokkal való együttműködésre tervezett szintaxissal.

Kurzor bezárása: BEZÁRÁS[GLOBÁLIS]<имя курсора>

A kurzor felszabadítása: FELHASZNÁLÁS [ GLOBÁLIS ]<имя курсора>

Példa a kurzorra:

DECLARE fo_curs CURSOR STATIC FOR

SELECT name_eng from ORDER BY name_eng

DECLARE @name varchar(50)

ELŐSZÖR A fo_curs-tól a @névbe

WHILE @@FETCH_STATUS=0

FETCH NEXT FROM fo_curs INTO @name

A fo_curs FELTÉTELEZÉSE

2.7. Adatbiztonság és integritás biztosítása a Microsoft SQL Serverben. Adatbázis-kezelés. Szerepek. Jogok hozzárendelése a felhasználókhoz (GRANT, DENY, REVOKE). Adatvédelem módszerei és technológiái az SQL Serverben.

SQL Server biztonság és adminisztráció. .

A DBMS fő feladata az adatok integritásának és konzisztenciájának biztosítása a kiválasztott témakörön belül. A probléma megoldásában a rendszert akadályozó tényezők egyike a felhasználók tevékenysége, akik véletlenül vagy szándékosan megpróbálják megsemmisíteni az adatstruktúrát vagy magát az adatot megváltoztatni. Ezért a DBMS-t nem csak a fizikai hibáktól kell védeni, hanem azoktól a felhasználóktól is, akik nem megfelelőek a megvalósítandó feladatokhoz. Ehhez olyan biztonsági rendszert kell megtervezni és az adatbázishoz csatlakoztatni, amely megakadályozza, hogy a felhasználók hatáskörüket meghaladó műveleteket hajtsanak végre.

Adatbázis-kezelés

Adatbázis létrehozásához TSQL használatával a CREATE DATABASE parancsot kell használni, de általában az SQL Server Management Studiot használják erre a célra. Az SQL Serverben jó néhány adatbázis-művelet van definiálva: fájlméretek növelése (csökkentése), konfiguráció megváltoztatása (ALTER parancs), csatolás és leválasztás, tulajdonjog átruházása, név megváltoztatása, tulajdonságok megtekintése és végül törlés (DROP DATABASE).

A legtöbb adatbázis-kiszolgálóhoz hasonlóan az SQL Serverben is van egy felhasználó teljes rendszergazdai jogosultságokkal – ez az Rendszergazda vagy "sa". A szerver kezdeti telepítése után a sa jelszó üres. Az új adatbázist létrehozó felhasználó automatikusan annak tulajdonosa lesz ('dbo" - Adatbázis tulajdonos). Az adatbázis létrehozásakor a "vendég" felhasználó is meghatározásra kerül. Ha a felhasználói fiók nincs kifejezetten egy adott adatbázis-felhasználóhoz rendelve , a felhasználó implicit hozzáférést kap a vendég vendégnév használatával. A vendég általában tilos.

Az objektumot az adatbázisban létrehozó felhasználó automatikusan az objektum tulajdonosává válik, és senki, beleértve a dbo-t és az sa-t sem használhatja az objektumot mindaddig, amíg a tulajdonos jogokat nem ad neki. De ahhoz, hogy a felhasználó létrehozhasson egy objektumot, az adatbázis tulajdonosának először meg kell adnia neki a megfelelő jogokat.

Szerep lehetővé teszi az azonos funkciókat ellátó felhasználók kombinálását az adminisztráció egyszerűsítése érdekében. A szerepek beépítettek és egyediek. A beépített szerepkörök kiszolgáló- és adatbázisszinten valósulnak meg. Az alábbiakban egy táblázat található az adatbázisok beépített szerepeiről:

db_tulajdonos. Minden joggal rendelkezik az adatbázisban

db_accessadmin. Hozzáadhat vagy eltávolíthat felhasználókat

db_securityadmin. Kezeli az összes engedélyt, objektumot, szerepkört és felhasználót

db_ddladmin. Minden DDL parancsot végrehajthat, kivéve a GRANT, DENY, REVOKE

db_backupoperator. Archiválási parancsokat tud végrehajtani. adat

db_adatreader. Megtekinthető. bármely tábla bármely adata

db_adatíró. Talán egy módosítás. bármely tábla bármely adata

db_denydatareader. Tiltott Kilátás szerelem adatok bármelyikben táblázatok

db_denydatawriter. Tilos bármilyen adat módosítása a táblákban

Jogok hozzárendelése a felhasználókhoz. Az SQL Server biztonságának alapja (1) fiókok; (2) felhasználók (felhasználók); (3) szerepek; (4) csoportok.

Amikor egy felhasználó csatlakozik az SQL Serverhez, az általa végrehajtható műveleteket a felhasználóként és egy szerepkör tagjaként számára biztosított jogok határozzák meg. A jogokat a DBMS-rendszergazda, az adatbázis tulajdonosa vagy egy adott adatbázis-objektum tulajdonosa adja. Az adatbázisjogok három kategóriába sorolhatók: (1) adatbázis-objektumokhoz való hozzáférési jogok; (2) TSQL-parancsok végrehajtásának jogai; (3) implicit jogok. A szerver lehetővé teszi a tulajdonjog átruházását egyik felhasználóról a másikra.

A következő parancsok használhatók az adatbázis-objektumok eléréséhez szükséges felhasználói engedélyek kezelésére:

GRANT( MINDEN |< вид действия >,…}

( TOVÁBB (<имя таблицы или представления>} [(<имя столбца>,…)]

| TOVÁBB (< имя хранимой процедуры >}

| TOVÁBB (< имя пользовательской функции >}

TO ( NYILVÁNOSSÁGI |<имя объекта системы безопасности>,…}

[ AS<имя группы> | <имя роли>]

– jogokat rendel a felhasználókhoz, ahol

ALL - a felhasználó minden lehetséges engedélyt megkap, ellenkező esetben adja meg

<вид действия>– a felhasználó rendelkezésére álló műveletekhez való jogok, nevezetesen:

KIVÁLASZTÁS - megtekintéshez, táblázat oszlopához és táblázathoz (nézet)

INSERT - hozzáadáshoz, a táblázat (nézet) egészéhez

FRISSÍTÉS - módosításhoz, táblázat oszlopához és táblázathoz (nézet)

TÖRLÉS - a törléshez, a táblázat (nézet) egészéhez

EXECUTE – tárolt eljárások végrehajtása

REFERENCIÁK - a megadott objektumra való hivatkozás képessége (az idegen kulcsban szerepeltetni kell).

<имя объекта системы безопасности>– SQL Server fiókok, Windows tartomány felhasználók; NYILVÁNOS – minden felhasználó számára.

GRANT OPCIÓVAL – Lehetővé teszi az aktuálisan engedélyezett felhasználó számára, hogy hozzáférési jogokat rendeljen az objektumhoz más felhasználókhoz.

MINT<имя группы> | <имя роли>– egy felhasználó részvétele olyan szerepkörben, amely lehetőséget kap arra, hogy jogokat adjon más felhasználóknak.

NYILVÁNOSSÁGRA NYILVÁNOSSÁGRA NYILVÁNOSSÁGRA NYILVÁNÍTOTT KIVÁLASZTÁS A szerzőket

A szerzők BESZÁMÍTÁSA, FRISSÍTÉSE, TÖRLÉSE NYÚJTÁSA Mary, John, Tom részére

GRANT KIVÁLASZTÁS A Terv_adatai között a könyveléshez A TÁMOGATÁSI OPCIÓVAL

A Plan_Data KIVÁLASZTÁSÁNAK MEGBÍZÁSA A Jack AS Számvitelnek

Jack nem a Számviteli szerepkörben van, de valaki ebben a szerepkörben megadhatja a jogot

TAGADNI( MINDEN |< вид действия >,…}

( TOVÁBB (<имя таблицы или представления>} [(<имя столбца>,…)]

| TOVÁBB (<имя хранимой процедуры>}

| TOVÁBB (<имя пользовательской функции>}

TO ( NYILVÁNOSSÁGI |<имя объекта системы безопасности>,…}

– hozzáférés megtagadva a felhasználók adatbázis-objektumokhoz. A CASCADE nem csak ettől a felhasználótól vonja meg a jogokat, hanem mindenkitől is, akinek jogokat adott.

Példa (be tiltsa le a parancs végrehajtását TSQL):

A TÁBLÁZAT LÉTREHOZÁSÁNAK MEGTAGADÁSA Jack CASCADE-NEK

Parancs VISSZAVONÁS az adatbázis-objektumokhoz való hozzáférés implicit megtagadására szolgál. A szintaxis megegyezik a DENY paranccsal. Az implicit megtagadás hasonló a hozzáférés megtagadásához, azzal a különbséggel, hogy csak azon a szinten lép érvénybe, amelyen meghatározásra került. Példa: Jack felhasználó, aki a GoodUsers szerepkör tagja, hozzáférést kapott az XFiles táblához. Ha a GoodUsers szerepkör a REVOKE funkcióval megtagadja a hozzáférést ehhez a táblához, a Jack felhasználó továbbra is hozzáférhet ehhez a táblához, mivel a jogosultságai kifejezetten meghatározottak. Ha személyesen kéri a REVOKE-ot, elveszíti az XFiles-hez való hozzáférési jogát.

A szerepeknek adott engedélyeket a tagok öröklik. Ha egy felhasználó hozzáférést kap egy objektumhoz az egyik szerepkörben való tagságon keresztül, de egy másikban megtagadják, akkor a hozzáférési ütközés mindig a megtagadás javára oldódik fel.

Adatvédelmi technológiák az MS SQL Serverben

1.Mechanizmus ellenőrző pontok– ~60 másodperc után generált ellenőrzőpontok a frissített oldalak lemezre írásához (az ellenőrzőpont a CHECKPOINT paranccsal kényszeríthető).

2. Beépített és külső mechanizmusok az adatbázis sértetlenségének ellenőrzésére (automatikusan indul, vagy a DBCC segédprogramhoz hasonlóan - Database Consistency Checker - manuálisan).

3. Adatbázisfájlok fizikai sokszorosítása (ha megengedett) az operációs rendszer segítségével (beleértve a tükrözött merevlemezek mechanizmusát is).

4. Adatbázisok és tranzakciós naplók biztonsági mentése - adatbázis dump írásával egy biztonsági mentési eszközre (mágneses szalag vagy merevlemez).

5. Replikáció - az információk megkettőzésének lehetősége az egyik SQL szerverről a másikra történő időszakos (bizonyos esetekben - szinkron) átvitel révén.

6. A kliens és a szerver közötti forgalom titkosítása, valamint az adatbázis-objektumokkal való munkához használt kódok titkosítása (tárolt eljárások, triggerek stb.)

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), számuk 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 implicit módon az adatbázis-kiszolgáló 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.

Különböző megvalósításokban a kurzor meghatározása némi eltérést mutathat. Í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ásokra van szükség.

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 adatintegritás 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 módosítjá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ó módosításokat végzett 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 adatbázisban végrehajtott változtatásokat az INSERT , UPDATE , DELETE parancsokkal. 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 a változások során dinamikusan észleljék a frissített információkat. 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. Adatok változásai nem engedélyezettek, ráadásul 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ó meg van adva, 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 irányból 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énykészletben. 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 (sorszá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 lesz az aktuális sor. Ha null értéket ad meg, akkor nem ad vissza karakterláncot.

Érv RELATÍV (sorszám | @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ára, 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ó.

A tervezésben 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 is 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 közben 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 KURSZOR HELYI KIVÁLASZTÁSHOZ Ü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 ELKÉRÉS A KÖVETKEZŐ A klient_cursor INTO @id_kl, @firm, @fam CH_STATUS @@FETCH_STATUS =0 BEGIN SELECT @message="kliens" [e-mail védett]+ "Vállalat"+ @cég NYOMTATÁS @üzenet KIVÁLASZTÁS @message="Termék neve Vásárlási dátum ára" NYOMTATÁS @üzenet tovar_kurzor KIJELENTÉSE A KIVÁLASZTÁSHOZ Cikknév, Kereskedés.Dátum, Cikk.Ár*Kereskedés.Mennyiség, mint költség A cikk BELSŐ CSATLAKOZTATÁSÁHOZ Tranzakció árukra. ItemCode=Deal.ItemCode WHERE Deal.CustomerCode [e-mail védett] _kl OPEN tovar_cursor FETCH NEXT FROM tovar_cursor INTO @nam, @d, @p IF @@FETCH_STATUS<>0 NYOMTATÁS "Nincs vásárlás" WHILE @@FETCH_STATUS=0 KEZDŐ KIVÁLASZTÁS @message=" " [e-mail védett]+" "+ CAST(@d AS CHAR(12))+" "+ CAST(@p AS CHAR(6)) PRINT @message SET @ [e-mail védett][e-mail védett] FETCH NEXT FROM FROM tovar_cursor INTO @nam, @d, @p VÉGE CLOSE tovar_cursor FELSZABADÍTÁSA tovar_cursor SELECT @message="Teljes költség "+ CAST(@s AS CHAR(6)) NYOMTATÁS @üzenet -- ugrás a következő ügyfélre-- KÖVETKEZŐ FELTÉTEL A kliens_kurzortól AZ @id_kl, @firm, @fam BEÁLLÍTÁSA VÉGE klient_cursor ügyfél_kurzor 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 NYOMTATÁSA klient_kurzor KURSZOR GLOBÁLIS GÖRGŐBILLENTYŰ KIVÁLASZTÁSÁRA VÁLLALATHOZ, Vezetéknév, Telefon Az ügyféltől WHERE City ="Moszkva" RENDELÉS CÉG, Vezetéknév FRISSÍTÉSHEZ MEGNYITÁSA klient_cursor KÖVETKEZŐ LÉPÉS A klient_cursortól A @firm, @fam, @tel WHILE @@FETCH_STATUS=0 KEZDÉS KIVÁLASZTÁS @message="Ügyfél" [e-mail védett]+ "Cég" [e-mail védett]" Telefon "+ @tel NYOMTATÁS @üzenet -- ha a telefonszám 1-gyel kezdődik -- az adott számmal rendelkező kliens törlése 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 @cég, @fam, @tel VÉGE FELTÉTEL 1 ABSZOLÚT klient_kurzortól @firm, @fam, @tel -- az első bejegyzésben a -- telefonszám első számjegyét cserélje ki 4 UPDATE Client SET Phone='4' + RIGHT( @tel,LEN(@tel)-1)) WHERE CURRENT OF klient_cursor SELECT @message="Kliens " [e-mail védett]+" Cég "+ @cég " Telefon "+ @tel NYOMTATÁS @üzenet BEZÁR klient_cursor kliens_kurzor LETÖLTÉSE 13.7. példa. Görgethető kurzor moszkvai ügyfelek számára.

Példa 13.8. 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 @ [e-mail védett] _cur OUTPUT FETCH NEXT FROM @my_cur INTO @n KIVÁLASZT @n WHILE (@@FETCH_STATUS=0) INDÍTSA KÖVETKEZŐ LETÖLTÉS @my_cur INTO-BÓL @n SELECT @n VÉGE CLOSE @my_cur DEALLOCATE @my_cur

Rebeca M. Riordan "Kurzorok a Transact-SQL-ben"

Internetes Informatikai Egyetem

http://www.INTUIT.ru

Képzés: "Programozás Microsoft SQL Server 2000-ben"

A kurzor egy speciális ideiglenes SQL objektum, amelyet programokban és tárolt eljárásokban való használatra terveztek. Segítségével a lekérdezési sorok eredményhalmazát végigcsikorgathatja, külön-külön elolvashatja és feldolgozhatja annak minden sorát. A tárolt eljárásokban kurzorok segítségével összetett számításokat hajthat végre, amelyeket a SELECT utasítás szintaxisával nehéz kifejezni. Az óra bő elméleti anyagát nagyon jó példák egészítik ki. Különös tekintettel a CURSOR_STATUS függvény alkalmazására, a @@CURSOR_ROWS és @@FETCH_STATUS változók leírására és még sok másra.

Tanulni fogsz:

kurzort deklarálni;
kurzor megnyitása;
kurzor bezárása;
engedje el a kurzort;
használjon egy egyszerű FETCH parancsot;
karakterlánc beolvasása változókba;
válasszon ki egy karakterláncot az abszolút pozíciója alapján;
válasszon egy sort a relatív helyzete alapján;
helyzetmódosítás végrehajtása;
helyzeti törlés végrehajtása;
használja a @@CURSOR_ROWS globális változót a kurzorkészletben lévő sorok számának meghatározásához;
használja a @@FETCH_STATUS globális változót a FETCH parancs eredményének meghatározásához;
használja a CURSOR_STATUS függvényt a kurzor állapotának lekérdezéséhez.

A relációs adatbázisok egyik jellemző tulajdonsága, hogy a műveleteket sorhalmazokon hajtják végre. Egy halmaz lehet üres vagy csak egy sort tartalmazhat, de akkor is halmaznak számít. Ez egy szükséges és hasznos tulajdonság a relációs műveletekhez, de néha kényelmetlen lehet az alkalmazások számára.

Például, mivel nincs mód egy adott sorra mutatni egy halmazban, nehéz lehet a sorokat egyenként bemutatni a felhasználónak. Annak ellenére, hogy a Transact-SQL által a szabványos SQL nyelvhez biztosított kiterjesztések sokkal nagyobb programozási teljesítményt tesznek lehetővé, még mindig vannak olyan műveletek, amelyeket nehéz, időigényes vagy akár lehetetlen végrehajtani a meghatározott elvek alapján.

Az ehhez hasonló helyzetek kezelésére az SQL kurzorokat biztosít. A kurzor egy olyan objektum, amely egy halmaz egy sorára mutat. A létrehozott kurzor természetétől függően mozgathatja a kurzort a készleten belül, és módosíthatja vagy törölheti az adatokat.

A kurzorok fogalma

A Microsoft SQL Server valójában két különböző típusú kurzort támogat: a Transact-SQL kurzorokat és az API kurzorokat (alkalmazásprogramozási felület kurzorait). Az API kurzorok Microsoft ActiveX Data Objects (ADO), OLE DB, ODBC vagy DB-Library alkalmazásban jönnek létre. Ezen API-k mindegyike kissé eltérő funkciókat támogat, és eltérő szintaxist használ. Itt nem tárgyaljuk részletesen a Cursors API-t; Ha használni kívánja őket, kérjük, olvassa el az API vonatkozó dokumentációját és a használni kívánt programozási nyelvet.

A Transact-SQL kurzorok a DECLARE CURSOR paranccsal hozhatók létre. Mind a kurzorobjektumnak, mind a sorkészletnek, amelyre mutat, léteznie kell a szerveren. Az ilyen kurzorokat szerverkurzoroknak nevezzük. Ha az SQL Serverhez hálózaton keresztül csatlakoztatott alkalmazásból származó kiszolgálókurzort használ, minden kurzorművelet kétirányú hálózati kommunikációt igényel. A kiszolgálókurzorokat támogató kurzor API-könyvtárak támogatják az ügyfélrendszeren található klienskurzort is, és gyorsítótárazza az általa feldolgozott karakterláncokat az ügyfélen.

A kurzor által mutatott sorok halmazát a SELECT paranccsal határozzuk meg. Transact-SQL kurzor létrehozásakor számos korlátozás vonatkozik a SELECT utasításra:

a SELECT parancs nem adhat vissza több eredményhalmazt;

a SELECT parancs nem tartalmazhat INTO záradékot egy új tábla létrehozásához;

a SELECT parancs nem tartalmazhat az eredmények összesítésére használt COMPUTE vagy COMPUTE BY záradékot. (Azonban tartalmazhat összesítő függvényeket, például AVG-t.)

A kurzor jellemzői

A Transact-SQL többféle kurzort támogat. Az egyes kurzorok különböző jellemzőinek kitalálása meglehetősen fárasztó feladat, de könnyebbé tehető, ha minden kurzortípusnál figyelembe veszünk három többé-kevésbé független jellemzőt: a forrásadatok változásainak tükrözésének képességét, a több sor közötti görgetés és több sor módosításának lehetősége.

A változás tükröződése

A kurzor azon képességét, hogy tükrözze az adatok változásait, kurzorérzékenységnek nevezzük. Tegyük fel, hogy létrehozott egy kurzort egy utasításhoz:

SELECT * FROM Oils WHERE Left(OilName, 1) = "B" Az aromaterápiás adatbázis négy sort ad vissza, amint az 1. ábrán látható. Ha a kurzor használata közben valaki Leírás értéket ad a Bergamot elemhez, vagy karakterláncot ad hozzá a Bayberry elemhez, mi történik azzal a karakterlánc-készlettel, amelyre a kurzor mutat?

Rizs. 1. Az aromaterápiás adatbázis négy B betűvel kezdődő sort tartalmaz.

A kurzor létrehozásakor kétféle érzékenység határozható meg egymástól függetlenül: a halmazban szereplő sorok módosítása (halmaztagság), illetve, hogy a változtatások megjelennek-e az eredeti sorokban.

görgetés

A kurzor második jellemzője az előre és hátra, vagy csak előre görgetés képessége. Itt van egy ősi programozási dilemma: a sebesség kontra rugalmasság. A szekvenciális kurzorok (csak előre) sokkal gyorsabbak, de kevésbé rugalmasak.

Frissítés

A kurzorok osztályozására használt utolsó jellemző a sorok kurzor általi frissítésének képessége. Ismétlem, a csak olvasható kurzorok általában jobban teljesítenek, de kevésbé rugalmasak.

Kurzortípusok

A Transact-SQL négy különböző típusú kurzort támogat: statikus, kulcsos, dinamikus és gyors hozzáférésű vagy "tűztömlő" kurzort. Minden kurzortípus különböző adatokat tárol azokról a sorokról, amelyekre mutat, és minden kurzortípus az előző részben tárgyalt jellemzők különböző kombinációival rendelkezik.

Statikus kurzorok

A statikus kurzor pillanatképet készít a SELECT utasításban megadott adatokról, és eltárolja a tempdb adatbázisban. Nem "érzi" a struktúra vagy az adatértékek változásait, és mivel az esetleges módosítások csak a másolatban jelennek meg, ez a kurzor mindig csak olvasható módban nyílik meg. A statikus kurzorok azonban deklarálhatók szekvenciálisnak vagy görgethetőnek.

Kulcs kurzorok

A kulcskurzor csak azokat az oszlopokat másolja a tempdb-be, amelyek egyedileg azonosítják az egyes sorokat. A kulcskurzor deklarálásához a SELECT utasítás definíciójában szereplő minden táblának rendelkeznie kell egy egyedi indexszel, amely meghatározza a másolandó készletet - a kulcsot.

A kulcskurzorok módosíthatók vagy csak olvashatók lehetnek. Lehetnek görgethetőek vagy szekvenciálisak is.

A kulcskurzorban való tagság a kurzor deklarálásakor rögzítésre kerül. Ha a kurzor nyitott állapotában olyan karakterlánc kerül hozzáadásra, amely megfelel a kiválasztási feltételnek, akkor az nem kerül a halmazba. Az előző példánkban, ahol a LEFT(OilName, 1) = "B" volt a szűrési feltétel, a "Bayberry" OilName mező értékével új sor nem kerül hozzáadásra a kurzor hatóköréhez kapcsolódó sorokhoz. .

Hasonlóképpen, ha olyan karakterláncot módosítanak, amely nem felel meg a beállított tagsági feltételnek, például a „Basil” „Kumquat” értékre cserélve, a karakterlánc továbbra is a halmaz tagja marad. Még ha egy sor törlődik is, az továbbra is a halmaz tagja, de az SQL Server NULL értéket ad vissza minden oszlopértékre.

Bár a kurzor beállított tagsága a kurzor megnyitása után is rögzített marad, a forrástáblázatokban végrehajtott adatértékek módosításai ennek ellenére tükröződnek. Például a Bergamot karakterlánc Leírás mező értékének megváltoztatását a kurzor adja vissza. A kulcskészlet értékeinek változásai azonban csak akkor jelennek meg a kurzorokban, ha azok a kurzoron belül történnek. Folytatva az előző példát, ha az OilName mező értékét "Basil"-ről "Kumquat"-ra változtatták a kurzoron belül, a kurzor a "Kumquat"-ot adja vissza. Ha a módosítást egy másik felhasználó hajtotta végre, a kurzor továbbra is a "Basil"-t adja vissza.

Tanács. Ahogy a következő részben látni fogjuk, a kurzor létrehozása és a kurzor megnyitása különböző műveletek. A kulcskurzor tartalmának frissítéséhez bezárhatja, majd újra megnyithatja.

Dinamikus kurzorok

A dinamikus kurzor úgy viselkedik, mintha a SELECT utasítást minden egyes sor elérésekor újra végrehajtaná. (Valójában a dolgok egy kicsit másképp működnek, de ez az ábrázolás lehetővé teszi a dinamikus kurzorok működésének jobb megítélését.) A dinamikus kurzorok a forrásadatok tagságával és értékeivel kapcsolatos változásokat tükrözik, függetlenül attól, hogy ezek a változtatások a kurzort, vagy egy másik felhasználó írta be.

A dinamikus kurzoroknak van egy korlátozása: a kurzor meghatározásához használt SELECT utasítás csak akkor tartalmazhat ORDER BY záradékot, ha van olyan index, amely tartalmazza az ORDER BY záradékban használt oszlopokat. Ha egy kulcskurzort egy ORDER BY záradékkal deklarál, amely nem működik indexen, az SQL Server a kurzort kulcskurzorrá alakítja.

Gyors hozzáférésű kurzorok

Az SQL Server támogatja a nem görgethető, csak olvasható kurzor speciális, optimalizált formáját. Az ilyen típusú kurzort a FAST_FORWARD kulcsszó deklarálja, és leggyakrabban "tűztömlő" kurzornak nevezik.

A tűzkurzorok nagyon hatékonyak, de használatuknak két fontos korlátja van. Először is, ha szöveges, ntext- vagy képoszlopokat és a TOP kifejezést használta a kurzordefiníciós SELECT utasításban, az SQL Server a kurzort kulcskurzorrá alakítja.

Másodszor, ha a kurzor meghatározásához használt SELECT utasítás tartalmaz triggereket és olyan táblákat, amelyek nincsenek, akkor a kurzor statikussá alakul. A triggerek olyan Transact-SQL-parancsfájlok, amelyeket a kiszolgáló automatikusan végrehajt, amikor a Data Manipulation Language (DML) utasításokat tartalmazó táblázat alapján hajtják végre. A triggereket részletesebben a 29. leckében fogjuk megvizsgálni, de most koncentráljunk a következőre: ha valaki triggert ad a kurzor által használt táblák egyikéhez, az alkalmazás hirtelen leállhat, mert az SQL Server gyorsabban konvertál kurzort egy lassabbra.

Kurzorok használata

A kurzorok használata olyan, mint a helyi változók használata – deklarálja őket, beállít egy értéket, majd használja őket. A helyi változókkal ellentétben azonban, amelyek automatikusan megsemmisülnek, ha kikerülnek a hatókörből, kifejezetten fel kell szabadítania a kurzor által használt sorokat, majd meg kell semmisítenie a kurzort.

Kurzorok létrehozása

A kurzor használatának első lépése annak létrehozása. A Transact-SQL kurzorok a DECLARE CURSOR utasítással jönnek létre.

Figyelem! Az SQL Server két különböző módszert támogat a kurzorok létrehozására: az SQL-92 szintaxis és a Transact-SQL szintaxis használatával. Az SQL-92 szintaxis megfelel az ANSI szabványnak, de kevesebb funkcionalitással rendelkezik, mint az itt tárgyalt Transact-SQL szintaxis.

A DECLARE CURSOR utasítás szintaxisa a következő:

DECLARE cursor_name CURSOR

[láthatóság]

[tekercs]

[zár]

FOR select_operator

Felhívjuk figyelmét, hogy a kurzor jellemzőit meghatározó összes paraméter - láthatóság, típus stb. - nem kötelezőek. Ezeknek a beállításoknak az alapértelmezett értékei összetettek, és meghatározhatják, hogy miként kell együttműködni a forrásrekordokkal vagy nézetekkel, illetve az adatbázissal való munkavégzés lehetőségeivel. Annak érdekében, hogy a kezelő könnyebben olvasható legyen, jobb, ha kifejezetten beállítja az összes szükséges paramétert. Így pontosan tudni fogja, mit fog kapni.

A kurzor láthatóságát a LOCAL vagy GLOBAL kulcsszavak határozzák meg, amelyeknek ugyanaz a hatása, mint a @local_table vagy @@global_table kulcsszavaknak az ideiglenes táblák deklarálásakor.

Tanács. Az SQL Server bezárja és felszabadítja a helyi kurzort, ha az kilép a hatókörből (láthatóság), de a legjobb, ha ezt mindig kifejezetten megteszi.

A scroll opció lehetővé teszi a FORWARD_ONLY és a SCROLL kulcsszavak használatát, amelyek rendre azt a lehetőséget adják meg, hogy csak az elejétől a végéig, vagy bármely irányba mozogjunk.

A type paraméter határozza meg a létrehozandó kurzor típusát. Az érvényes kulcsszavak: STATIC, KEYSET, DYNAMIC és FAST_FORWARD. A FAST_FORWARD típusparaméter és a FORWARD_ONLY görgetőparaméter kölcsönösen kizárják egymást.

A zárolási opció határozza meg, hogy a sorokat módosíthatja-e a kurzor, és ha igen, akkor más felhasználók módosíthatják-e azokat. A READ_ONLY kulcsszó használata esetén a kurzor nem tud módosítani az eredeti adatokon. Más felhasználók azonban módosíthatják az adatokat, vagy Ön is megteheti ezt az UPDATE utasítás segítségével. Ha zárolási paraméterként a SCROLL_LOCKS van megadva, a frissítéseket csak a kurzor tudja végrehajtani. Az összes többi UPDATE utasítás, akár ugyanabban a csomagban, akár más felhasználók által biztosított, meghiúsul.

Az utolsó zárolási opció, az OPTIMISTIC, lehetővé teszi a sorok frissítését a kurzoron belül és kívül egyaránt. Ez a legrugalmasabb lehetőség, de mindig fennáll annak az esélye, hogy a kurzor által végrehajtott módosítás sikertelen lesz, ha a sort módosították, mióta a kurzor elolvasta.

A TYPE_WARNING paraméter arra utasítja az SQL Servert, hogy küldjön figyelmeztető üzenetet az ügyfélnek, ha a kurzortípust a megadott típusról egy másik típusra konvertálják. Ez akkor lehetséges, ha olyan kurzort deklarál, amely nem támogatja az adott SELECT utasítást.

A FOR záradékban megadott select_operator paraméter szükséges. Meghatározza a kurzorkészletben szereplő sorokat.

A FOR UPDATE záradék nem kötelező. A kurzorok alapértelmezés szerint módosíthatók, hacsak a READ_ONLY nincs beállítva, de érdemes ezt a kifejezést használni, hogy biztosak legyünk az eredményben. Az oszlopnevek OF záradékával megadhatja azokat a sorokat, amelyeknél engedélyezi a módosítást. Ha kihagyja az oszlopnevek OF szakaszát, akkor a módosítás a SELECT utasításban megadott összes oszlopon végrehajtható.

Kurzorváltozók

A Transact-SQL lehetővé teszi a CURSOR típusú változók deklarálását. Ebben az esetben a szabványos DECLARE szintaxis nem hoz létre kurzort; kifejezetten be kell állítania a kurzor változóját a SET kulcsszó használatával.

DECLARE myCursor CURSOR

FOR SELECT OilName FROM Oils

DECLARE @myCursorVariable CURSOR

SET @myCursorVariable = myCursor

Ez a szintaxis akkor hasznos, ha különböző kurzorokhoz rendelhető változókat szeretne létrehozni. Erre akkor lehet szükség, ha általános eljárást hoz létre a különböző eredményhalmazokkal való munkavégzéshez.

Deklarálhat egy kurzorváltozót, majd használhatja közvetlenül kurzor létrehozására.

DECLARE @myCursorVariable KURSOR BEÁLLÍTÁSA @myCursorVariable = KURSZOR HELYI GYORS ELŐRE FORRÁS AZ OLAJNEV KIVÁLASZTÁSÁHOZ OLAJBÓL

Ezzel a szintaxissal a kurzornak nincs azonosítója, és csak változón keresztül lehet rá hivatkozni.

A kurzor megnyitása

A kurzordeklaráció létrehoz egy kurzorobjektumot, de nem hoz létre rekordkészletet, amelyet a kurzor kezelni fog (a kurzorkészlet). A kurzorkészlet nem jön létre, amíg meg nem nyitja a kurzort. A DECLARE CURSOR utasítás meglehetősen bonyolult szintaxisa után az utasítás szintaxisa meglehetősen átlátszónak tűnik:

OPEN kurzor_vagy_változó

A GLOBAL kulcsszó segít elkerülni az ütközéseket: ha a LOCAL kulcsszóval deklarált kurzor és a GLOBAL kulcsszóval deklarált kurzor azonos azonosítóval rendelkezik, a kurzorra mutató hivatkozások alapértelmezés szerint a helyi kurzorra vonatkoznak, hacsak nem használja a GLOBAL kulcsszót. Más hasonló esetekben a legjobb, ha kifejezetten megadja a kulcsszót, ha globális kurzort nyit meg.

A kurzor bezárása

Ha befejezte a kurzor használatát, be kell zárnia. A CLOSE utasítás felszabadítja a kurzorkészlet karbantartásához használt erőforrásokat, és feloldja a sorokon lévő zárolásokat is, ha a DECLARE utasításban a SCROLLOCKS beállítást használta. A CLOSE parancs szintaxisa szinte megegyezik az OPEN utasítás szintaxisával - csak a kulcsszó változik:

kurzor_vagy_változó ZÁRÁSA

A kurzor felszabadítása

A kurzor létrehozási sorrendjének utolsó utasítása a DEALLOCATE utasítás. A szintaxisa is egyszerű:

A kurzor_vagy_változó FELTÉTELEZÉSE

Azonban van itt egy finomság: a DEALLOCATE utasítás törli az azonosítót vagy a kurzorváltozót, de magát a kurzort nem feltétlenül. Maga a kurzor mindaddig nem törlődik, amíg az összes rá hivatkozó azonosító fel nem szabadul, vagy le nem jár (ha kívül esik a hatókörön). Vegye figyelembe a következő példákat:

Kurzor létrehozása DECLARE myCursor CURSOR KEYSET READ_ONLY FOR SELECT * FROM Olajok -- Kurzorváltozó létrehozása DECLARE @cursorVariable CURSOR -- Kurzorbejegyzések készletének létrehozása OPEN myCursor -- Változó hozzárendelése a kurzorhoz SET @cursorVariable = myCursor -- Release a Cursor kurzor FELTÉTELEZÉS myCursor

A kurzor felszabadítása után a myCursor azonosító már nincs társítva a kurzorkészlethez, de mivel a kurzorkészletre továbbra is hivatkozik a @cursorVariable változó, a kurzor és a kurzorkészlet nem szabadul fel. Hacsak nem szabadítja fel kifejezetten a kurzorváltozót is, a kurzor és a kurzorkészlet mindaddig létezni fog, amíg a változó le nem jár.

Stringek kezelése a kurzorral

A kurzorok önmagukban nem lennének érdekesek, ha nem tudna velük valamit csinálni. A Transact-SQL három különböző kurzorparancsot támogat: FETCH, UPDATE és DELETE.

A FETCH parancs lekéri a megadott karakterláncot a kurzorsorok halmazából. A legegyszerűbb formában a FETCH parancs szintaxisa a következő:

FETCH kurzor_vagy_változó

Ez a rekordformátum a kurzor pozíciójában lévő sort adja vissza (az aktuális sort).

Használjon egyszerű FETCH parancsot

Keresse meg az SQL 2000 Step by Step mappát a gyökérkönyvtárban, jelölje ki a SimpleCursor nevű szkriptet, és kattintson a Megnyitás gombra.
A Query Analyzer betölti a szkriptet a Query ablakba.

Tanács. Talán észrevette, hogy ez a szkript tovább tart, mint a megfelelő SELECT utasítás. A helyzet az, hogy a kurzor létrehozása és megnyitása további időt igényel. Soha ne használjon kurzort, ha egy SELECT utasítás elegendő a feladat elvégzéséhez.

A FETCH parancs nem csak egy karakterláncot tud közvetlenül visszaadni, hanem lehetővé teszi a visszaadott oszlop értékeinek változókban való tárolását is. Ha egy FETCH parancs eredményét változóban szeretné tárolni, használja a következő szintaxist:

FETCH cursor_or_variable INTO variable_list

A változó_lista a változóazonosítók vesszővel elválasztott listája. A FETCH parancs végrehajtása előtt deklarálnia kell a változókat. A varlistnak tartalmaznia kell egy változót a kurzort meghatározó SELECT utasításban megjelenő minden oszlophoz. A változó adattípusának meg kell egyeznie az oszlop adattípusával, vagy kompatibilisnek kell lennie azzal.

Válassza ki a sorokat, és írja be a változókba

Az összes korábbi példában a FETCH utasítást használták az aktuális sor visszaadására. A FETCH utasítás szintaxisa számos kulcsszót is biztosít egy másik sor megadásához. Ha ezeket a kulcsszavakat használja, a FETCH utasítás visszaadja az adott sort, és azt az aktuális sort teszi.

Ezek a kulcsszavak lehetővé teszik egy abszolút pozíció megadását a kurzorkészleten belül. A FIRST és LAST kulcsszavak rendre az első és az utolsó sort adják vissza, míg az ABSZOLÚT n sor n sort határozza meg a kurzor rekordkészletének elejétől (ha n pozitív) vagy végétől (ha n negatív). Az n értéke kifejezhető konstansként (3) vagy változóként (@theRow).

Válassza ki a sorokat abszolút pozíciójuk alapján

Jelölje ki a FetchAbsolute nevű szkriptet, és kattintson a Megnyitás gombra. A Query Analyzer betölti a szkriptet a Query ablakba.

Azon kulcsszavakon kívül, amelyek lehetővé teszik a sorok abszolút pozíciójuk szerinti lekérését, a FETCH utasítás három kulcsszót biztosít, amelyek lehetővé teszik a sorok lekérését az aktuális sorhoz viszonyított pozíciójuk szerint. A FETCH NEXT operátor a következő sort adja vissza, a FETCH PRIOR operátor az előző sort, a FETCH RELATIVE n operátor pedig az n sort adja vissza az aktuális sorból. A FETCH ABSOLUTE n utasításhoz hasonlóan a FETCH RELATIVE n utasítás is megadhat sorokat az aktuális sor előtt, ha n negatív, és az aktuális sor utáni sorokat, ha n pozitív.

Válassza ki a sorokat a relatív helyzetük alapján

Jelölje ki a FetchRelative nevű szkriptet, és kattintson a Megnyitás gombra. A Query Analyzer betölti a szkriptet a Query ablakba.

Ha a kurzor FORWARD_ONLY vagy PAST_FORWARD típusú, akkor csak a NEXT kulcsszó használható a pozíció jelzésére. Valójában, ha a kurzor az egyik ilyen típusú, akkor a NEXT kulcsszóra nincs szükség. Az SQL Server feltételezi, hogy minden FETCH utasítás valójában FETCH NEXT utasítás.

Gyors kurzorhoz használja a FETCH NEXT utasítást

Jelölje ki a FetchFirehose nevű szkriptet, és kattintson a Megnyitás gombra. A Query Analyzer betölti a szkriptet a Query ablakba.

Kattintson a Lekérdezés futtatása gombra a Query Analyzer eszköztáron. A Query Analyzer végrehajtja a lekérdezést.

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

Ha a kurzor módosítható. A kurzorkészlet kezdeti értékeinek megváltoztatása meglehetősen egyszerű. A WHERE záradéknak van egy speciális formája, amely támogatja a kurzorral történő módosítást:

UPDATE table_or_view SET lista_to_modify WHERE CURRENT OF cursor_or_variable

Ezt nevezik pozíciófrissítésnek. A Transact-SQL támogatja a pozíciótörlést is, amely a következő jelöléssel rendelkezik:

DELETE table_or_view WHERE CURRENT OF cursor_or_variable

Helyzetfrissítés végrehajtása

Jelölje ki a PositionedUpdate nevű szkriptet, és kattintson a Megnyitás gombra. A Query Analyzer betölti a szkriptet a Query ablakba.

Kattintson a Lekérdezés végrehajtása gombra a Query Analyzer eszköztáron. A Query Analyzer végrehajtja a lekérdezést. Vegye figyelembe, hogy két rácspanel jelenik meg. Az elsőt a FETCH utasítás hozza létre, és az oszlopok kezdeti tartalmát tartalmazza. A második a SELECT utasítás eredménye, és a Leírás mező értékét tartalmazza módosítás után.

A Transact-SQL kurzorok figyelése

A Transact-SQL két globális változót és egy függvényt biztosít, amelyek segítségével szabályozhatja a kurzor működését és állapotát. A @@CURSOR_ROWS változó a kapcsolaton utoljára megnyitott kurzor sorainak számát adja vissza. A @@CURSOR_ROWS által visszaadott értékek az 1. táblázatban láthatók.

A @@FETCH_STATUS változó az utolsó FETCH parancs végrehajtásáról ad vissza információkat. A 2. táblázat mutatja a @@FETCH_STATUS változó által visszaadott értékeket.

Végül a Transact-SQL biztosítja a CURSOR_STATUS függvényt. Ennek a függvénynek a szintaxisa a következő:

CURSOR_STATUS(típus, kurzor_vagy_változó) A típus lehet "helyi", "globális" vagy "változó", és a cursor_or_variable a lekérendő kurzor vagy kurzorváltozó azonosítója. A CURSOR_STATUS függvény által visszaadott eredmények a 3. táblázatban láthatók.

Használja a kurzorfigyelő funkciókat

Jelölje ki a StatusFunctions parancsfájlt, és kattintson a Megnyitás gombra. A Query Analyzer betölti a szkriptet a Query ablakba.

nyomtatott változat

A kurzor egy olyan objektum, amely lehetővé teszi a SELECT utasítás által visszaadott eredményhalmaz sorainak egyenkénti feldolgozását. A Transact-SQL nyelvben támogatott kurzorokról a következőkben lesz szó. Ezek olyan szerverkurzorok, amelyek objektumként léteznek az adatbázis-kiszolgáló oldalán. Vannak kliensoldali kurzorok is, amelyek kliensoldali adatbázis-alkalmazások létrehozására szolgálnak.

A szakirodalom megjegyzi, hogy egy adathalmaz soronkénti feldolgozása kurzorral az esetek túlnyomó többségében lényegesen lassabb, mint az SQL-eszközök által sorhalmazok feldolgozására végzett hasonló műveletek. Ezért a kurzorok használata csak olyan esetekben javasolt, amikor a szükséges műveletek leírása sorhalmazokkal végzett műveleteken keresztül egyértelműen nem hatékony, vagy akár lehetetlen.

A kurzorral végzett munka általában a következő lépéseket tartalmazza:

kurzor deklaráció;
nyitó kurzor;
attribútumértékek beolvasása változókba az első kurzorbejegyzésből;
a kurzor feletti mozgás (általában hurokban) és a kurzorbejegyzések feldolgozása;
kurzor bezárása;
a kurzornak lefoglalt memória felszabadítása.

A kurzor deklarálása a DECLARE utasítással történik, amelynek formátuma az alábbiakban látható. Megjegyzendő, hogy az SQL Serverben ez az utasítás támogatja az ISO SQL szabvány szintaxisát (a szabvány verziója nincs megadva a dokumentációban), valamint a Transact-SQL nyelvi kiterjesztések CURSOR készletét használó szintaxist.

FOR select_utasítás

Kiterjesztett Transact-SQL szintaxis:

DECLARE cursor_name CURSOR

FOR select_utasítás

]][;]

A GLOBAL kulcsszó megadása azt jelenti, hogy a deklarált kurzor elérhető bármely munkakötegben, triggerben vagy tárolt eljárásban, amely a kiszolgálóhoz való jelenlegi kapcsolaton belül fut le. A kurzor implicit módon csak akkor szabadul fel, ha a kapcsolat megszakad.

Az alapértelmezés szerint létrehozott „helyi” kurzor csak abban a kötegben, tárolt eljárásban vagy triggerben érhető el, amelyben létrehozták. Az ilyen kurzor implicit módon felszabadul, amikor a köteg, a tárolt eljárás vagy az eseményindító befejezi a végrehajtást. Kivétel az, amikor a kurzort egy tárolt eljárás kimeneti paraméterén (OUTPUT) vezetik át. Ezután a kurzor elengedi, amikor az összes rá hivatkozó változót elengedjük, vagy amikor kilépünk a "hatókörből".

A FORWARD_ONLY azt jelenti, hogy csak a kurzor mentén lehet előre "mozgatni" (csak a FETCH NEXT parancs érhető el, lásd lent), pl. a kurzor minden bejegyzése legfeljebb egyszer dolgozható fel. Ha a CSAK ELŐRE van megadva a STATIC, KEYSET vagy DYNAMIC kulcsszavak nélkül, akkor a kurzor DINAMIKUS kurzorként viselkedik (lásd alább). Ha a FORWARD_ONLY vagy a SCROLL opciók egyike sincs megadva, és a STATIC, KEYSET vagy DYNAMIC kulcsszavak egyike sincs megadva, akkor alapértelmezés szerint a FORWARD_ONLY beállítás van megadva.

A SCROLL azt jelenti, hogy a kurzort bármely irányba "mozgathatja" (a FETCH operátorban a FIRST, LAST, PRIOR, NEXT, RELATIVE, ABSOLUTE elérhetők). A SCROLL opció nem adható meg a FAST_FORWARD opcióval. A STATIC, KEYSET és DYNAMIC kurzorok alapértelmezett értéke SCROLL.

STATIC azt jelenti, hogy a kurzor nem frissül. Az ilyen kurzor eredményül kapott adatkészletét a rendszer lekéri az adatbázisból, és az ideiglenes objektumok adatbázisában tárolja a tempdb. A kurzor alapjául szolgáló táblázatok változásai ezután nem jelennek meg a kurzorban.

KEYSET - az ilyen típusú kurzorokhoz a kiválasztott rekordokat azonosító kulcsértékek egy ideiglenes táblában vannak tárolva. A kurzor fölé mozgatásakor a nem kulcsfontosságú attribútumok értékei a megfelelő táblákból kerülnek leolvasásra, így a nem kulcsfontosságú oszlopok változásai láthatóak lesznek a kurzorral végzett munka során. Ha a kurzor sorát már eltávolították a táblából, mire a FETCH utasítás lekéri, a @@ FETCH_STATUS szolgáltatásváltozó a -2 értéket adja vissza. A táblázatokhoz a kurzor megnyitása után hozzáadott sorok nem láthatók a kurzorban. Ha a kurzort létrehozó lekérdezés legalább egy olyan táblát használ, amelynek nincs egyedi indexe, akkor a KEYSET kurzor STATIC-sá alakul.

A DYNAMIC a leginkább erőforrásigényes kurzortípus, amely megjeleníti az eredménykészlet soraiban végrehajtott összes adatmódosítást, beleértve az újonnan beillesztett sorokat is. Az egyes mintákban az adatértékek, a sorrend és a sorok tagsága változhat. A FETCH ABSOLUTE nem használható dinamikus kurzorokkal.

A FAST_FORWARD a leggyorsabb kurzortípus, amely lehetővé teszi, hogy az egyik sorról a másikra csak „előre” lépjen. Ez az alapértelmezett kurzortípus (ha az opcionális kulcsszavak ki vannak hagyva). Ez egyenértékű a FORWARD_ONLY és READ_ONLY opciókkal deklarált kurzorral.

READ_ONLY - "csak olvasható" kurzort definiál: ilyen kurzoron keresztül nem lehet módosítani az adatbázist.

A SCROLL_LOCKS azt jelenti, hogy az SQL Server zárolja a sorokat a kurzorba való beolvasáskor, így biztosítva, hogy az ilyen típusú kurzorral frissíthetők vagy törölhetők legyenek.

Az OPTIMISTIC kulcsszóval deklarált kurzor nem kér sorzárolást, és lehetővé teszi az adatok módosítását. Ha az alapul szolgáló táblában változások következnek be az adatok kurzorba való beolvasása után, az adatoknak a kurzoron keresztüli módosítására tett kísérlet hibát eredményez.

A TYPE_WARNING azt határozza meg, hogy ha egy kurzort implicit módon a kért típusról egy másikra konvertálnak (például a fent leírt KEYSET-sta STATIC kurzorkonverziót egyedi index hiányában a táblázatban), akkor figyelmeztetést küld a kliens.

A Select_statement egy SELECT utasítás, amely a kurzor eredménykészletét hozza létre.

A FOR UPDATE utasítás megadja, hogy a kurzor mely oszlopait frissítse. Ha OF oszlop_neve [, . . . n], akkor csak a felsorolt oszlopok lesznek elérhetők a változtatásokhoz. Ha nincs oszloplista, akkor az összes oszlop frissítése lehetséges, kivéve, ha a kurzor a READ_ONLY paraméterrel van deklarálva.

A kurzor megnyitásához és kitöltéséhez használja a parancsot

OPEN ((kurzor_neve) I @cursor_variable)

Megnyitáskor a kurzor megadható névvel (kurzornév) vagy CURSOR típusú változóval (@cursor_variable). A GLOBAL paraméter határozza meg, hogy a kurzor_neve egy globális kurzor.

A FETCH utasítás a kurzor adatkészletében való mozgásra és az adatok változó értékként való lekérésére szolgál:

FETCH[

(( cursor_name] I @cursor_variable]

A kurzor mentén történő mozgás irányát meghatározó parancsok leírása a táblázatban található. 10.10. Amint azt korábban megjegyeztük, a kurzor típusától függően előfordulhat, hogy egyes parancsok egy adott kurzorhoz nem alkalmazhatók.

Fontos megjegyezni, hogy ha a kurzort most nyitották meg, a FETCH NEXT első végrehajtása a kurzor első bejegyzésére ugrik.

10.10. táblázat

Navigálás a kurzor adatkészletében

A @@FETCH_STATUS globális változó tájékoztatja a FETCH utasítás utolsó végrehajtásának eredményét:

О – a művelet sikeresen befejeződött;

-1 – az utasítás végrehajtása meghiúsult, vagy a karakterlánc az eredményhalmaz határain kívül volt (kurzor véget ért);
-2 – nincs kiválasztható sor, például ha a "változásérzékeny" típusú kurzorral végzett munka során az aktuális rekordot törölték az adatbázisból.

A CLOSE utasítás bezár egy nyitott kurzort, felszabadítva az adatkészlet tárolására használt memóriát. Adatok kijelölése és zárt kurzor feletti mozgatása nem lehetséges - ehhez újra meg kell nyitni.

ZÁRÁS (( kurzor_neve)|@kurzorváltozó)

A DEALLOCATE utasítás eltávolítja a kurzor és a neve vagy változó közötti kapcsolatot. Ha ez a kurzorra utaló vezetéknév vagy változó, akkor maga a kurzor törlődik, és az általa használt erőforrások felszabadulnak:

DEALLOCATE (( kurzor_neve] | @kurzor_változó) Nézzünk egy egyszerű példát a kurzor használatára, ahol a 2000 után megjelent könyvek szerzőit és címeit kiválasztjuk egy táblázatból, és az adatokat a SELECT utasításokon keresztül hurkoljuk, minden alkalommal, amikor egy rekord saját címe. A kód megjegyzései alapján:

/*változók deklarálása*/

DECLARE @auth varchar(50), @title varchar(50)

HOL >= 2000

/*nyissa meg a kurzort és "futtassa" a szerzőt és a címet külön SELECT utasításban*/

KERESÉS KÖVETKEZŐRE A kurzortól AZ @auth, @title BE

WHILESSFETCH_STATUS=0

FETCH NEXT FROM A kurzorból AZ @auth, Címbe

/* zárja be a kurzort és engedje el */

A cursorl FELTÉTELEZÉSE

Ahogy fentebb megjegyeztük, a kurzor neve helyett egy CURSOR típusú változó is használható. Az alábbiakban egy hasonló kód látható ilyen változókat használva:

DECLARE Sauth varchar(50), Stitle varchar(50)

/*kurzor típusú változó deklarálása*/

DECLARE Scurl CURSOR

DECLARE cursorl CURSOR FAST_FORWARD

SELECT Szerző, Cím FROM dbo.Bookl