→ Selectarea cursorului în SQL. Victimizarea cursoarelor și buclelor în Transact-SQL

Selectarea cursorului în SQL. Victimizarea cursoarelor și buclelor în Transact-SQL

Rebekah M. Riordan „Cursori în Transact-SQL”

Universitatea de Tehnologii Informaționale pe Internet

http://www.INTUIT.ru

Curs de bază: „Programare în Microsoft SQL Server 2000”

Un cursor este un obiect SQL special, consumator de timp, care este utilizat pentru cursorarea în programele și procedurile care sunt salvate. Cu acest ajutor, puteți parcurge ciclul cu setul de rânduri rezultat, citind direct și modelând rândul pielii. În procedurile care sunt salvate, calculele complexe pot fi adăugate folosind cursoare, ceea ce este important de exprimat folosind sintaxa suplimentară a instrucțiunii SELECT. Excelentul material teoretic din lecție este completat cu aplicații practice foarte bune. Să ne uităm la stagnarea funcției CURSOR_STATUS, o descriere a importantelor @@CURSOR_ROWS și @@FETCH_STATUS și multe altele.

O sa inveti:

  • cursorul mut jos;
  • ascunde cursorul;
  • închideți cursorul;
  • eliberați cursorul;
  • vikoristovvat o comandă FETCH simplă;
  • selectați un rând din modificare;
  • selectați un rând din această poziție absolută;
  • selectați rândul pentru a se potrivi cu poziția de conducere;
  • anularea modificării poziționale;
  • vedere pozițională vykonuvati;
  • utilizați variabila globală @@CURSOR_ROWS pentru a seta numărul de rânduri din mai multe cursoare;
  • utilizați variabila globală @@FETCH_STATUS pentru a evalua rezultatele comenzii FETCH;
  • Utilizați CURSOR_STATUS pentru a seta starea cursorului.

Una dintre puterile caracteristice ale bazelor de date relaționale și cele care stau deasupra impersonalității rândurilor. O mulțime poate fi goală, sau puteți umple doar un rând, dar totuși va fi respectat fără prejudecăți. Aceasta este putere necesară și utilă pentru operațiuni relaționale, dar poate să nu fie foarte utilă pentru adăugiri.

De exemplu, deoarece nu este posibil să indicați un rând pe rând fără persoană, trimiterea rândurilor unul câte unul poate crea dificultăți. Indiferent de acele extensii care extind Transact-SQL la limbajul SQL standard, acestea vă permit să implementați mult mai multe capacități de programare fără a pierde operațiunile care sunt importante, dificile sau imposibil de renunțat la principiile de bază ale lucrului cu multiplicități.

Pentru a face față unor astfel de situații, SQL transferă cursorul. Cursorul este un obiect care indică următorul rând al feței. Pe baza cursorului pe care l-ați creat, puteți muta cursorul în mijlocul grupului și puteți modifica sau șterge datele.

Înțelegerea cursoarelor

Microsoft SQL Server acceptă de fapt două tipuri diferite de cursoare: cursoare Transact-SQL și cursoare API (cursoare de interfață a programului de aplicație). Cursoarele API sunt create în programe precum Microsoft ActiveX Data Objects (ADO), OLE DB, ODBC sau DB-Library. Fiecare dintre aceste API-uri acceptă o serie de capabilități funcționale și utilizează o sintaxă diferită. Nu discutăm despre API-ul cursorului în detaliu aici; Dacă intenționați să le utilizați, accesați documentația completă pentru API și programare, dacă doriți să stagnezi.

Cursoarele Transact-SQL sunt create folosind DECLARE CURSOR suplimentar. Ca obiect cursor și fără rânduri, așa cum este indicat, sunt responsabili pentru server. Astfel de cursoare se numesc cursore server. Dacă accesați un cursor de pe partea serverului dintr-un program conectat la SQL Server printr-un back-end, fiecare operație pe cursor va necesita o comunicare bidirecțională back-to-back. Bibliotecile de cursoare API care acceptă cursoare de pe server acceptă, de asemenea, cursorul client care se află pe sistemul client și memorează în cache rândurile care sunt procesate pe client.

Rândurile goale indicate de cursor sunt indicate de comanda SELECT. Când se deschide un cursor Transact-SQL, comanda SELECT este suprapusă:

comanda SELECT nu poate roti numărul de multiplicatori rezultați;

comanda SELECT nu poate folosi o clauză INTO pentru a crea un tabel nou;

Comanda SELECT nu poate conține clauza COMPUTE sau COMPUTE BY, care sunt utilizate pentru agregarea rezultatelor. (Cu toate acestea, puteți utiliza funcții de agregare, cum ar fi AVG.)

Caracteristicile cursoarelor

Transact-SQL acceptă un număr de tipuri de cursor. Luarea în considerare a diferitelor caracteristici ale tipului de piele al cursorului ar trebui să fie completată cu sarcini obositoare, dar poate fi ușoară luând în considerare, pentru tipul de piele al cursorului, trei caracteristici minore independente: capacitatea de a afișa modificări în datele de ieșire, Este posibil să defilați printre rânduri, precum și să modificați datele. Nu există rânduri.

Variația modificărilor

Capacitatea cursorului de a afișa modificările datelor se numește sensibilitate a cursorului. Să presupunem că ați creat un cursor pentru operator:

SELECT * FROM Oils WHERE Left(OilName, 1) = "B" Baza de date aromoterapie rotiți rândurile așa cum se arată în Fig. 1. Când mutați cursorul, doriți să adăugați o valoare Description pentru elementul Bergamot sau să adăugați un rând pentru elementul Bayberry, care va fi rezultatul tuturor rândurilor pe care le indică cursorul?

Mic 1. Baza de date cu aromaterapie conține mai multe rânduri care încep cu litera B.

Când cursorul este deschis, două tipuri de sensibilitate pot fi identificate în mod independent: modificările din unele rânduri sunt incluse până la multiplicator (appartenarea multiplicității) și sunt afișate modificările în rândurile de ieșire.

Sul

O altă caracteristică a cursorului este capacitatea de a derula atât înainte, cât și înapoi, sau chiar înainte. Aici există un loc pentru programarea dilemei: fluiditate versus mestecat. Cursoarele ulterioare (numai înainte) funcționează mult mai rapid, dar sunt mai puțin flexibile.

Actualizați

Caracteristica rămasă care este utilizată pentru clasificarea cursoarelor este capacitatea de a actualiza rândurile de către cursor. Repet, cursoarele „numai citire” sunt mai productive, dar pot fi mai puțin greoaie.

Tipuri de cursoare

Transact-SQL acceptă diferite tipuri de cursoare: cursore statice, cheie, dinamice, cu acces rapid sau cursore firehose. Cursorul de tip skin salvează date diferite pentru rândurile unde este indicat, în plus, cursorul de tip skin salvează date diferite față de caracteristicile văzute în secțiunea anterioară.

Cursore statice

Un cursor static ia un instantaneu al datelor specificate de instrucțiunea SELECT și o stochează în baza de date tempdb. Nu „simte” modificări în structura sau semnificația datelor, iar orice modificări vor fi afișate doar în copia al cărei cursor este deschis întotdeauna în modul „doar citire”. Cu toate acestea, cursoarele statice pot deveni silențioase sau pot derula.

Cursoare cheie

Cursorul cheie copiază în baza de date tempdb numai coloanele care identifică în mod unic rândul. Pentru a putea citi cursorul cheii, tabelul care este inclus la sfârșitul instrucțiunii SELECT necesită un index unic care specifică setul care este copiat - cheia.

Cursoarele cheie pot fi modificate, deci există un mod „numai citire”. Duhoarea poate fi, de asemenea, defilată sau secvențială.

Calitatea de membru al cursorului cheie este fixată în momentul în care cursorul este pierdut. Dacă, în procesul de deschidere a cursorului, se adaugă un rând care confirmă selecția, acesta nu va fi adăugat în listă. În exemplul nostru anterior, deoarece am selectat LEFT(OilName, 1) = „B”, noul rând cu valorile câmpului OilName „Bayberry” nu va fi adăugat la rândurile care se află în zona de cursorul.

În mod similar, dacă se face o modificare la o serie care nu este mulțumită de apartenența la plural, de exemplu, înlocuind „Basil” cu „Kumquat”, seria va pierde totuși un membru al pluralului. Odată ce rândul este eliminat, termenul multiplicator este eliminat și SQL Server returnează NULL pentru toate valorile coloanei.

Dacă doriți ca apartenența la mai multe cursoare să fie nefixată după deschiderea cursorului, modificați valoarea datelor care sunt introduse în tabelele de ieșire pentru a vedea modificarea. De exemplu, modificarea valorii câmpului Descriere pentru rândul Bergamot va fi rotită de cursor. Dacă modificați valoarea tastelor anonime, acestea sunt afișate în cursoare imediat ce apar în mijlocul cursorului. Prin tragerea fundului din față, valoarea câmpului OilName a fost schimbată de la „Basil” la „Kumquat” în mijlocul cursorului, cursorul este rotit la „Kumquat”. Dacă modificarea a fost făcută de un alt utilizator, cursorul, ca și înainte, se rotește spre „Basil”.

Porada. După cum trebuie să știm în secțiunea următoare, crearea unui cursor și deschiderea cursorului cu diverse operații. Pentru a actualiza cursorul cheie, îl puteți închide și redeschide.

Cursore dinamice

Cursorul dinamic este mutat în așa fel încât instrucțiunea SELECT să fie repetată într-un rând. (De fapt, totul funcționează puțin diferit, dar un astfel de fenomen ne permite să judecăm mai bine activitatea cursoarelor dinamice.) Cursoarele dinamice afișează modificări legate atât de datele de membru, cât și de valorile de ieșire, indiferent dacă sunt împărțite sau modificate în mijlocul cursorului sau contribuit de un alt corespondent.

Pentru cursoarele dinamice, se aplică aceeași regulă: instrucțiunea SELECT care este utilizată pentru a defini cursorul poate insera doar o clauză ORDER BY în contextul unui index care include clauzele care sunt potrivite de clauza ORDER BY. Când specificați un cursor cheie într-o clauză ORDER BY care nu operează pe un index, SQL Server convertește cursorul într-un cursor cheie.

Cursore cu acces rapid

SQL Server acceptă o formă de cursor special optimizată, care nu derulează și este doar pentru citire. Acest tip de cursor folosește cuvântul cheie FAST_FORWARD și este cel mai adesea numit un cursor firehose.

Cursoarele „arzând” sunt și mai eficiente, dar atunci când sunt folosite, există două schimburi importante. În primul rând, dacă în instrucțiunea SELECT a cursorului ați selectat coloane cu tipul de date text, ntext sau imagine, precum și fraza TOP, SQL Server convertește cursorul într-unul cheie.

În caz contrar, dacă instrucțiunea SELECT pe care ați folosit-o pentru a atribui un cursor tabelelor care au declanșatori și tabelelor care nu au declanșatori, cursorul este convertit în static. Declanșatorii sunt scripturi Transact-SQL care sunt compilate automat de server atunci când este deschis un tabel operator DML (Data Manipulation Language). În raportul nostru ne vom uita la declanșatorii din Lecția 29, în același timp suntem extrem de respectuoși în momentul actual: dacă adăugați un declanșator la un tabel care este cursorat de cursor, suplimentul dvs. poate fi folosit pentru a edita cursorul, fragmentele din SQL Server vor transforma cursorul swidden într-unul mai mic Vizibil.

Cursor wiki

Cursoarele Victory sunt similare cu variabilele locale vikoristing - le votați, setați valorile și apoi vikorist. Cu toate acestea, pe lângă modificările locale, care sunt detectate automat atunci când depășiți limitele zonei de acțiune, trebuie să creați în mod clar rânduri care sunt cursate de cursor și apoi să eliminați cursorul.

Crearea de cursoare

Primul croque de la cursorul vikoristan este crearea acestuia. Cursoarele Transact-SQL sunt create folosind instrucțiunea DECLARE CURSOR.

Respect! SQL Server acceptă două metode diferite pentru crearea cursoarelor: sintaxa SQL-92 și sintaxa Transact-SQL. Sintaxa SQL-92 urmează standardul ANSI, dar are mai puține funcționalități decât sintaxa Transact-SQL, care este discutată aici.

Instrucțiunea DECLARE CURSOR are următoarea sintaxă:

DECLARE cursor_name CURSOR

[vizibilitate]

[sul]

[blocare]

PENTRU operator_selecție

Vă rugăm să vedeți toți parametrii care definesc caracteristicile cursorului - vizibilitate, tip etc. – є nu neapărat lingvistic. Valorile acestor parametri sunt flexibile și pot indica sau nu metode de interacțiune cu înregistrările sau manifestările de ieșire, precum și opțiunile de lucru cu baza de date. Pentru a face operatorul mai ușor de înțeles, cel mai bine este să setați în mod explicit toți parametrii de care aveți nevoie. În acest caz, știi exact ce iei.

Aspectul cursorului este determinat de utilizarea cuvintelor cheie LOCAL sau GLOBAL, care au același efect ca și cuvintele cheie @local_table sau @@global_table când orarul este dezactivat.

Porada. SQL Server închide și eliberează cursorul local când depășește limitele zonei sale de activitate (vizibilitate), sau mai degrabă, va funcționa din nou în mod explicit.

Parametrul de defilare vă permite să utilizați cuvintele cheie FORWARD_ONLY și SCROLL, care stabilesc, aparent, capacitatea de a vă deplasa doar de la început până la sfârșit, sau altfel direct.

Parametrul tip indică tipul de cursor care este deschis. Cuvintele cheie valide aici sunt STATIC, KEYSET, DYNAMIC și FAST_FORWARD. Tipul de parametru FAST_FORWARD și parametrul de defilare FORWARD_ONLY sunt dezactivate reciproc.

Parametrul de blocare înseamnă că rândurile pot fi modificate de cursor, iar dacă da, pot fi modificate de alți utilizatori. Dacă este utilizat cuvântul cheie READ_ONLY, cursorul nu poate face nicio modificare asupra datelor de ieșire. Cu toate acestea, alți utilizatori pot modifica datele sau puteți utiliza singur operatorul UPDATE. Deoarece SCROLL_LOCKS este setat în parametrul de blocare, actualizările pot fi făcute numai de cursor. Toate celelalte instrucțiuni UPDATE, ca în mijlocul aceluiași pachet, și alte componente care sperăm să nu fie terminate.

Opțiunea de blocare rămasă, OPTIMISTIC, vă permite să actualizați rândurile atât în ​​mijlocul cursorului, cât și în spatele acestuia. Aceasta este cea mai bună opțiune, dar în viitor există certitudinea că o modificare introdusă de cursor se va termina cu eșec, dacă se efectuează o serie de modificări după citirea de către cursor.

Parametrul TYPE_WARNING indică SQL Server să trimită o avertizare timpurie către client atunci când tipul de cursor este convertit de la tipul specificat la un alt tip. Acest lucru este posibil dacă afișați un cursor care nu acceptă instrucțiunea SELECT.

Parametrul select_operator care apare în fraza FOR este obligatoriu. Aceasta specifică rândurile care vor fi incluse în cursor.

Expresia PENTRU UPDATE nu este necesară. După procesare, cursoarele sunt modificate deoarece parametrul READ_ONLY nu este specificat, totuși, în acest caz este mai bine să selectați această frază astfel încât să fie inclusă în rezultatul extras. Puteți selecta secțiunea OPRIRE pentru a indica rândurile de melodii pentru care permiteți modificarea. Dacă omiteți clauzele OF, modificarea poate fi aplicată tuturor clauzelor specificate în instrucțiunea SELECT.

Cursorul se modifică

Transact-SQL permite modificări ale tipului CURSOR. Și aici sintaxa standard DECLARE nu creează un cursor; Trebuie să setați în mod explicit cursorul în spatele cuvântului cheie SET.

DECLARE myCursor CURSOR

PENTRU SELECTARE OilName DIN Uleiuri

DECLARE @myCursorVariable CURSOR

SET @myCursorVariable = myCursor

Această sintaxă este scurtă deoarece trebuie să faceți modificări care pot fi aplicate la diferite cursoare. Acest lucru poate fi necesar dacă creați o procedură oficială pentru lucrul cu diferiți factori de rezultat.

Puteți anunța schimbarea cursorului și apoi selectați-l pentru a închide imediat cursorul.

DECLARE @myCursorVariable CURSOR SET @myCursorVariable = CURSOR LOCAL FAST_FORWARD FOR SELECT OilName FROM Oils

Dacă alegeți această sintaxă, cursorul nu afișează identificatorul și mesajul trimis către unul nou se poate face doar printr-o modificare.

Vizibil pentru cursor

Dezactivarea cursorului distruge obiectul cursorului, dar nu creează un set de înregistrări care sunt manipulate de cursor (fără cursor). Cursorul silențios nu va fi creat decât dacă deschideți cursorul. După ce a finalizat sintaxa complexă a operatorului DECLARE CURSOR, sintaxa operatorului pare complet clară:

DESCHIDERE cursor_or_change

Cuvântul cheie GLOBAL ajută la rezolvarea conflictelor: ca și cursorul, apelurile din cuvântul cheie LOCAL, cursorul, apelurile din cuvântul cheie GLOBAL, vor crea un nou identificator, trimis la cursor va fi transferat pe cursorul local. De ce nu ați vikorizat cuvântul cheie GLOBAL? Ca și în alte situații similare, este mai bine să indicați în mod explicit cuvântul cheie atunci când deschideți cursorul global.

Închideți cursorul

După ce ați terminat de navigat prin cursor, îl puteți închide. Instrucțiunea CLOSE eliberează resursele care sunt utilizate pentru a menține poziția cursorului și, de asemenea, eliberează toate blocările care au fost aplicate rândurilor care au fost utilizate pentru parametrul SCROLLLOCKS în instrucțiunea DECLARE. Sintaxa comenzii CLOSE este aproape identică cu sintaxa instrucțiunii OPEN - doar cuvântul cheie este schimbat:

CLOSE cursor_or_change

Setarea cursorului

Operatorul rămas în secvența de acțiuni asociate cu cursorul creat este operatorul DEALLOCATE. Sintaxa lui Yogo este, de asemenea, simplă:

DEALLOCATE cursor_or_change

Totuși, există o subtilitate aici: operatorul DEALLOCATE șterge identificatorul sau cursorul care se schimbă, dar nu șterge neapărat cursorul în sine. Cursorul în sine nu va fi vizibil până când toți identificatorii care se bazează pe el vor fi fie eliberați, fie nu vor mai funcționa (când trec dincolo de limitele zonelor de acțiune). Să aruncăm o privire la aceste exemple:

Crearea unui cursor DECLARE myCursor CURSOR KEYSET READ_ONLY FOR SELECT * FROM Oils -- Crearea unei variabile de cursor DECLARE @cursorVariable CURSOR -- Crearea înregistrărilor anonime pentru un cursor OPEN myCursor -- Atribuirea unei variabile cursor SET @cursorVariable = myCursor

Odată ce un cursor este atribuit, identificatorul myCursor nu mai este asociat cu non-cursorul, cu excepția cazului în care variabila @cursorVariable este încă aplicată non-cursorului, cursorul și non-cursorul nu sunt asociate. Dacă nu activați în mod explicit schimbarea cursorului, cursorul și non-cursorul vor fi dezactivate până când modificarea este irosită.

Manipularea rândurilor folosind un cursor suplimentar

Cursorele cu forțe puternice nu ar fi de mare interes dacă ai putea lucra cu un cântec suplimentar. Transact-SQL acceptă trei comenzi diferite pentru lucrul cu cursoare: FETCH, UPDATE și DELETE.

Comanda FETCH trage valori dintr-un rând de mai multe rânduri în cursor. În forma sa cea mai simplă, comanda FETCH are următoarea sintaxă:

FETCH cursor_or_change

Pentru acest format de înregistrare, rândul de la poziția cursorului este rotit (rând de flux).

Vikorist comanda simplă FETCH

  1. Accesați folderul SQL 2000 Step by Step din directorul rădăcină, vizualizați scriptul folosind SimpleCursor și faceți clic pe butonul Deschidere.
  2. Query Analyzer introduce scriptul în fereastra Interogare.

Porada. Poate că acordați atenție faptului că acest scenariu se termină cu instrucțiunea SELECT inferioară. În partea dreaptă, crearea și deschiderea cursorului va necesita timp suplimentar. Nu modificați niciodată cursorul, deoarece instrucțiunea SELECT este suficientă pentru vizualizare.

Comanda FETCH nu numai că poate roti un rând fără mijloc, dar vă permite și să salvați valorile din rândul rotit în cele modificate. Pentru a salva rezultatele comenzii FETCH de la modificare, utilizați următoarea sintaxă:

FETCH cursor_or_change INTO change_list

List_of_changeables conține o listă de nume care sunt separate prin grupuri de nume notabile. Înainte ca echipa FETCH să voteze, puteți vota pentru modificări. Lista modificărilor este responsabilă pentru înlocuirea modificării pentru clauza skin care apare în instrucțiunea SELECT indicată de cursor. Tipul de modificare este responsabil fie pentru evitarea, fie pentru a fi compatibil cu tipul de date.

Selectați rândurile din intrarea de mai jos

Pe toate stocurile din față, operatorul FETCH a fost folosit pentru a roti rândul de producție. Sintaxa instrucțiunii FETCH transmite, de asemenea, un număr de cuvinte cheie pentru a insera un alt rând. Dacă aceste cuvinte cheie sunt diferite, operatorul FETCH va roti sarcinile rândului și profitabilitatea acestuia, să-l facem mai precis.

Aceste cuvinte cheie fac posibilă specificarea unei poziții absolute în multe cursoare. Cuvintele cheie FIRST și LAST rotesc primul și ultimul rând, în timp ce ABSOLUT n specifică un rând care are n rânduri de la începutul (care este n pozitiv) sau de la sfârșitul (care este n negativ) al mai multor intrări de cursor. Valorile lui n pot fi exprimate ca constante (3) și apar variabile (@theRow).

Selectați rândurile din poziția lor absolută

  1. Accesați scriptul numit FetchAbsolute și faceți clic pe butonul Deschidere. Query Analyzer introduce scriptul în fereastra Interogare.

Pe lângă cuvintele cheie care permit trasarea rândurilor după poziția lor absolută, operatorul FETCH transmite trei cuvinte cheie care permit trasarea rândurilor după poziția lor față de rândul de flux. Operatorul FETCH NEXT rotește rândul din față, operatorul FETCH PRIOR rotește rândul din față, iar operatorul FETCH RELATIVE n rotește rândul la o distanță de n rânduri de cel curent. Similar cu operatorul FETCH ABSOLUTE n, operatorul FETCH RELATIVE n poate specifica rânduri care să-l urmeze pe cel curent, deoarece n este negativ, iar rândurile care să-l urmeze pe cel curent, care este n este pozitiv.

Selectați rândurile în funcție de poziția lor principală

  1. Vizualizați scriptul folosind numele FetchRelative și faceți clic pe butonul Deschidere. Query Analyzer introduce scriptul în fereastra Interogare.

Deoarece cursorul este de tip FORWARD_ONLY sau PAST_FORWARD, pentru a insera o poziție puteți folosi cuvântul cheie NEXT. De fapt, dacă cursorul este mutat la unul dintre aceste tipuri, cuvântul cheie NEXT nu este necesar. SQL Server transmite aceeași instrucțiune FETCH ca o instrucțiune FETCH NEXT.

Vikorizați instrucțiunea FETCH NEXT pentru un cursor suedez

  1. Accesați scriptul numit FetchFirehose și faceți clic pe butonul Deschidere. Query Analyzer introduce scriptul în fereastra Interogare.

Faceți clic pe butonul Run Query din bara de instrumente Query Analyzer. Analizatorul de interogări este introdus.

Modificarea și selectarea rândurilor prin cursoare

Cursorul dumneavoastră este în curs de modificare. Modificarea valorilor de ieșire în multe cursoare este ușoară. O formă specială a clauzei WHERE a fost transmisă pentru a sprijini modificarea prin intermediul cursorului:

UPDATE table_or_data SET list_of_modifications WHERE CURRENT OF cursor_or_changed

Aceasta se numește actualizări de poziție. Transact-SQL acceptă, de asemenea, afișarea pozițională, care ia forma unei înregistrări ca aceasta:

DELETE table_or_data WHERE CURRENT OF cursor_or_change

Vedeți actualizările de poziție

  1. Accesați scriptul numit PositionedUpdate și faceți clic pe butonul Deschidere. Query Analyzer introduce scriptul în fereastra Interogare.

Faceți clic pe butonul Execute Query din bara de instrumente Query Analyzer. Analizatorul de interogări este introdus. Vă rugăm să rețineți că apar două panouri grilă. Primul este creat de operatorul FETCH și plasează cob în loc de stovpts. Celălalt este rezultatul executării instrucțiunii SELECT și înlocuirii valorilor câmpului Description după modificare.

Monitorizarea cursoarelor Transact-SQL

Transact-SQL oferă două funcții globale care vă ajută să controlați modul în care se comportă cursorul. Modificarea @@CURSOR_ROWS rotește un număr de rânduri ale cursorului rămas care este deschis în conexiune. Valorile pe care @@CURSOR_ROWS le rotesc sunt prezentate în Tabelul 1.

Meniul @@FETCH_STATUS returnează informații despre configurația comenzilor FETCH rămase. Tabelul 2 are valori care pot fi rotite folosind @@FETCH_STATUS.

Transact-SQL definește funcția CURSOR_STATUS. Această funcție are următoarea sintaxă:

CURSOR_STATUS(type, cursor_or_change) Tipul poate fi „local”, „global” sau „variabil”, iar cursor_or_change este identificatorul pentru cursorul sau schimbarea cursorului, informații despre care trebuie să fie preluată. Rezultatele obținute folosind funcția CURSOR_STATUS sunt prezentate în Tabelul 3.

Explorați funcțiile de monitorizare a cursorului

  1. Accesați scriptul StatusFunctions și faceți clic pe butonul Deschidere. Query Analyzer introduce scriptul în fereastra Interogare.

Versiune pentru prieteni

Comanda DECLARE CURSOR vă permite să glisați și să plasați înregistrările de tabel pentru manipulare. Acest lucru vă permite să efectuați procesarea rândurilor în loc de procesarea tradițională cu seturi de date precum SQL.

Prima dată când lucrați cu cursorul, veți putea vedea astfel de comenzi rapide.

Cursorul este creat folosind comanda DECLARE. Cursorul este deschis cu comanda OPEN.

Operațiile cu cursorul sunt efectuate folosind comanda FETCH. Cursorul este închis cu comanda CLOSE.

Comanda DECLARE CURSOR specifică o instrucțiune SELECT. Rândul de piele care este rotit cu instrucțiunea SELECT poate fi selectat și editat individual. În aplicația actuală pentru Oracle, cursorul devine tăcut în bloc în același timp cu multe alte modificări. După aceea, în următorul bloc BEGIN ... END, cursorul se deschide, se face o selecție, iar cursorul se închide.

CURSOR title_price_cursor IS SELECT title, price FROM titluri

UNDE prețul NU ESTE NUL; title_price_val title_price_cursor ROWTYPE; preţ_nou NUMĂR(10,2);

OPEN title_price_Cursor;

FETCH title_price_cur-sor INTO title_price_val;

new_price:= "title_price_val.price" * 1.25 INSERT INTO new_title_price VALUES

(title_price_val.title, new_price) CLOSE title_price_cursor; SFÂRŞIT;

Părți ale acestei aplicații se bazează pe PL/SQL, majoritatea codului nu este explicat în această carte. Cu toate acestea, blocul DECLARE arată clar că cursorul înnebunește. Pentru un bloc PL/SQL care este în curs de finalizare, cursorul este inițializat cu comanda OPEN, valorile sunt preluate cu comanda FETCH și, în final, cursorul este închis cu comanda CLOSE.

Instrucțiunea SELECT este baza cursorului, așa că este o practică bună să o testați cu atenție înainte de a rula instrucțiunea DECLARE CURSOR. Instrucțiunea SELECT poate fi aplicată unui tabel de bază sau altor metode. Prin urmare, cursoarele „numai citire” pot fi actualizate cu actualizări. Instrucțiunea SELECT poate conține clauze precum ORDER BY, GROUP BY și HAVING, deoarece aceste clauze nu actualizează tabelul de ieșire. Dacă cursorul este desemnat ca FOR UPDATE, este recomandat să ștergeți astfel de instrucțiuni folosind instrucțiunea SELECT.

Cursoarele locale sunt adesea folosite ca parametri de ieșire ai procedurilor care sunt salvate. Puteți să localizați și să salvați cursorul în procedura care este salvată și să-l transmiteți jobului batch care l-a numit sau procedurii care este salvată.

În aplicația simplă actuală pentru DB2, avem un cursor care se uită la numerele departamentelor, numele departamentelor și numerele managerului din grupul_admin "ХО1".

DECLARE dept_cursor CURSOR

FOR SELECT dept_nbr, dept_name, mgr_nbr

WHERE admin_group="X01"

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

În aplicația curentă Microsoft SQL Server, este afișat cursorul pentru tabelul editorilor. Cursorul selectează prima înregistrare din tabelul editorilor care se potrivește cu instrucțiunea SELECT și o inserează într-un alt tabel. Apoi mergeți la intrarea curentă, apoi la cea curentă - până când toate intrările sunt procesate. Când este găsit, cursorul se închide și memoria este eliberată (comanda DEALLOCATE nu este acceptată de Microsoft SQL Server).

DECLARE @publisher_name VARCHAR(20)

DECLARE pub_cursor CURSOR FOR SELECT pub_name FROM publishers WHERE țara „SUA”

FETCH NEXT FROM pub_cursor ÎN publisher_name

WHILE @s>FETCH_STATUS=0

INSERT INTO foreign_publishers VALUES("j>nume_publisher)

CLOSE pub_cursor DEALLOCATE pub_cursor

În această aplicație, puteți obține ajutor cu privire la modul în care cursorul se deplasează peste un set de înregistrări. (Acest exemplu de clic nu demonstrează această idee, dar ceea ce arată cu adevărat cel mai bun mod de a face acest lucru este instrucțiunea INSERT, SELECT în sine.)

Codul meu T-SQL I, în orice caz, a setat operațiuni bazate. Sunt vinovat de aceste tipuri de operațiuni, deoarece SQL Server este proiectat să proceseze și ar trebui să fie mai rapid decât procesarea în serie. Știu că există cursoare, dar nu sunt sigur cum să le folosesc. Puteți oferi câteva exemple de cursor? Puteți oferi vreo îndrumare cu privire la când să utilizați cursoarele? Presupun că Microsoft include SQL Server pentru a se asigura că sunt de vină într-un loc în care pot fi corectate într-un mod eficient.

Soluţie

În unele cazuri, cursoarele pot să nu fie vikorizate, în alte locuri apar în zona rămasă, iar în alte grupuri sunt vikorizate în mod regulat. Are loc în circumstanțe speciale și nu în altele. a început să facem următoarele:

  • Uită-te la un exemplu de cursor
  • Descompune componentele cursorului
  • Furnizați exemple suplimentare de cursor
  • Analizați avantajele și dezavantajele utilizării cursorului

Cum se creează un cursor SQL Server

Crearea unui cursor SQL Server este un proces secvenţial, astfel încât veţi şti că le puteţi duplica cu diferiţi parametri logici în decurs de o oră. Să parcurgem pașii:

  1. În primul rând, veți găsi parametrii pe care îi veți solicita în logică.
  2. În cealaltă jumătate de oră vei găsi butoane cu nume specifice, pe care le vei naviga prin cel logic. Acest lucru nu este întotdeauna cazul cu cursorul.
  3. Treizeci, veți scrie de la cursor până la începutul procesului de procesare.
  4. În al patrulea rând, este procesul de date care este unic pentru toate seturile de logică. Aceasta poate fi inserarea, actualizarea, ștergerea etc. pentru rândul de date, cum ar fi Vikonanii. Acesta este un set important de logică pentru procesul în curs care operează la nivelul pielii.
  5. În al cincilea rând, obțineți următoarea înregistrare de pe cursor așa cum ați făcut la pasul 3 și apoi pasul 4 este repetat din nou prin procesarea datelor selectate.
  6. În al șaselea rând, odată ce toate datele au fost procesate, închideți cursorul.
  7. Ca o notă finală și importantă, sunteți responsabil pentru dezvoltarea unui cursor pentru localizarea tuturor resurselor naționale deținute de SQL Server.

În plus, mergeți în partea de jos a paginii pentru a afla cum să utilizați cursoarele SQL Server și cum să le creați.

Exemplu de cursor SQL Server

Aici este partea de jos a butonului din vârful Raportului despre cele pentru a captura toate bazele de date SQL Server, unde backup-urile sunt emise în serie:

DECLARE @name VARCHAR(50) -- numele bazei de date DECLARE @path VARCHAR(256) -- calea pentru fișierele de rezervă DECLARE @fileName VARCHAR(256) -- numele fișierului pentru backup DECLARE @fileDate VARCHAR(20) -- wikilist pentru numele fișierului SET @path = "C:\Backup\" SELECT @fileDate = CONVERT(VARCHAR(20),GETDATE(),112) DECLARE db_cursor CURSOR FOR SELECT name FROM MASTER.dbo.sysdatabases WHERE name NOT IN ("master","model ","msdb","tempdb") OPEN db_cursor FETCH NEXT FROM db_cursor INTO @name WHILE @@FETCH_STATUS = 0 BEGIN SET @fileName = @path + @name + "_" + @fileDate + ".BAK" BACKUP DATABASE @ name TO DISK = @fileName FETCH NEXT FROM db_cursor INTO @name END CLOSE db_cursor DEALLOCATE db_cursor

Componentele cursorului SQL Server

Pe baza celor descrise, cursoarele includ următoarele componente:

  • Instrucțiuni DECLARE - Variabilele Declare sunt evidențiate în blocul de cod
  • Instrucțiuni SET\SELECT - Inițializați variabilele la o anumită valoare
  • Instrucțiunea DECLARE CURSOR - Completați cursorul cu valori care vor fi evaluate
    • NOTĂ - Există un rând de parametri în instrucțiunea DECLARE CURSOR FOR așa cum există în instrucțiunea SELECT. Aceasta poate fi fie 1, fie o mulțime de variabile și coloane.
  • Instrucțiune OPEN - Deschideți cursorul pentru a începe procesarea datelor
  • Instrucțiuni FETCH NEXT - Atribuiți valorile specifice de pe cursor variabilelor
    • NOTĂ - Această logică este revizuită pentru populația cob înainte de instrucțiunea WHILE și apoi din nou în timpul fiecărei bucle din proces, ca parte a instrucțiunii WHILE
  • Declarație WHILE - Condiție pentru începerea și continuarea procesării datelor
  • Instrucțiune BEGIN...END - Începutul și sfârșitul blocului de cod
    • NOTĂ - Pe baza unui proces de flux pot fi utilizate instrucțiunile BEGIN...END
  • Procesarea datelor - În acest cont, această copie logică a unei baze de date în anumite fișiere și nume de fișiere, iar aceasta poate fi o întindere a unui DML sau logic administrativ
  • Instrucțiune CLOSE - Eliberează datele curente și blocările asociate, dar permite redeschiderea cursorului
  • Instrucțiunea DEALLOCATE - Distruge cursorul

Lectură recomandată

Aflați mai multe despre cursorii și alternativele SQL Server:

Exemple suplimentare de cursor SQL Server

În aplicația de backup, puteți utiliza cursorul pentru a introduce alte tipuri folosind logica bazată pe cursor:

  • Script pentru a crea comenzi pentru a dezactiva, activa, elimina și recrea constrângerile cheii externe în SQL Server

Analiza cursorului SQL Server

Analiza de mai jos este menită să servească drept perspectivă în diferite scenarii, în care logica bazată pe cursor poate fi sau nu benefică:

  • Procesarea tranzacțiilor online (OLTP) - în majoritatea mediilor OLTP, SET se bazează pe aspecte logice, cel mai mult pentru tranzacții scurte. Echipa noastră a finalizat a treia parte a procesului, care creează cursori vikory pentru toate procesele care pot face clic pe ele, dar nu vor fi un rezultat al cântecului. De obicei, logica bazată pe SET este mai mult decât fezabilă, iar cursoarele sunt rareori necesare.
  • Raportare - Pe baza designului rapoartelor și a designului de bază, cursoarele nu sunt de obicei necesare. Cu toate acestea, echipa noastră analizează cerințele de raportare, care nu sunt specifice în ceea ce privește claritatea și nu sunt necesare pentru utilizarea cursorului pentru a evalua corect valorile de raportare. Este clar că va trebui să introduceți date pentru procesele inițiale, iar instrumentul bazat pe cursor va fi gata pentru dezvoltare și editare într-un manager convenabil înainte de utilizare.
  • Procesare serializată - Deoarece sunteți responsabil pentru accelerarea proceselor într-o manieră serializată, cursoarele sunt o opțiune viabilă.
  • Sarcini administrative - Majoritatea sarcinilor administrative trebuie să fie implementate într-o manieră serială care se potrivește bine în logica bazată pe cursor, iar alte obiecte bazate pe sistem pot fi dezvoltate pentru a îndeplini nevoia. În multe circumstanțe, cursoarele și wiki-urile sunt disponibile pentru întregul proces.
  • Seturi de date grozave - Puteți parcurge seturi de date grozave oricând sau mai mult de acum:
    • Cursorul se bazează pe o abordare logică care nu poate fi utilizată pentru a procesa cererea.
    • Cu un set mare de operațiuni de bază pe servere cu o utilizare minimă a memoriei, datele pot fi furate sau monopolizate de SQL Server, care, în presiunea timpului, poate adăuga memorie. Astfel, o abordare bazată pe cursor poate fi apreciată.
    • Unele instrumente vă înregistrează manual datele într-un fișier sub anteturi, astfel încât procesarea datelor din memorie poate duce sau nu la accidente.
    • În timp ce datele pot fi ștampilate în SQL Server, datele de intrare sunt eliberate numai pentru productivitatea naturii odată ce rezultatele sunt complete. Toate resursele de pe serverele de script pot fi folosite pentru procesele ETL, astfel încât datele să poată fi importate.
    • SSIS acceptă loturi de seturi de date care rezolvă nevoia generală de a împărți un set mare de date în dimensiuni mai ușor de gestionat și de a performa mai bine decât abordarea rând cu rând cu un cursor.
    • Mai mult decât atât, deoarece cursorul sau SSIS este codificat logic, este posibil să fie reexecutat în același timp pe baza
    • Repetați un lot cu comanda GO
    Pasii urmatori
    • Pe măsură ce vă veți urmări procesul de înregistrare, veți folosi utilizarea cursorului SQL Server. Mirosurile pot fi prezente sau nu în procesele dumneavoastră ocupate sau operaționale. Există o mulțime de moduri de a face totul, astfel încât să puteți utiliza cursorul ca alternativă rezonabilă sau nu. Tu fii judecătorul.
    • Dacă studiați alte tehnici de codare și aveți nevoie de cercetări care necesită timp, un cursor vikory poate fi o alternativă viabilă. Poate fi mult timp pentru a verifica aceste date și termenii de recuperare mitthevo. Dacă faceți doar unul sau două procese, sau dacă procesați temeinic, nu puteți face trucul.
    • Deoarece cursorii sunt ocoliți în mijlocul nostru, va fi evident să alegem o altă alternativă viabilă. Doar asigurați-vă că procesul nu va cauza alte probleme. Ca un cap, atunci când cursorul este cursor și milioane de rânduri care vor fi confirmate, potențial pulsează toate aceste date din cache și provoacă dispute suplimentare? Sau datele dvs. sunt selectate din date grozave, astfel încât să fie paginate pe disc sau scrise în directorul temporar?
    • După cum apreciați că cursorul se bazează pe alte opțiuni, pentru a dezvolta o gamă completă de tehnologii în ceea ce privește timpul, conținutul și resursele sunt necesare. Sperăm că această fabrică vă va conduce la tehnica proprietății.

stagnează până când: SQL Server (începând din 2008) Baza de date SQL Azure SQL Azure Data WarehouseParallel Data Warehouse

Acestea sunt atributele cursorului de pe server în limbajul Transact-SQL, care este folosit pentru a analiza comanda care este utilizată pentru a genera setul de rezultate pe care operează cursorul. Declarația DECLARE CURSOR acceptă atât sintaxa standard ISO, cât și sintaxa utilizată de extensia limbajului Transact-SQL.

Sintaxa ISO DECLARE cursor_name [ INSENSITIVE ] [ SCROLL ] CURSOR FOR select_statement [ FOR ( READ ONLY | UPDATE [ OF column_name [ ,...n ] ] ) ] ] [ ;] Sintaxă extinsă Transact-SQL DECLARE cursor_name CURSOR [LOCAL | GLOBAL] [NUMAI_ÎNAINTARE | SCROLL] [STATIC | KEYSET | DINAMIC | FAST_FORWARD ] [ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ] [ TYPE_WARNING ] FOR select_statement [ FOR UPDATE [ OF column_name [ ,...n ] ] ] [;]

cursor_name
cursor_name

INSENSIBIL
tempdb; Astfel, modificările aduse tabelelor de bază nu sunt afișate în datele rotite de selecțiile acestui cursor, iar acest cursor nu permite modificări. Dacă se modifică sintaxa ISO, dacă nu este specificat parametrul INSENSITIVE, actualizările și intrările din tabelele de bază sunt fixate și afișate în selecțiile următoare.

SUL
Indică faptul că toți parametrii de selecție (PRIMUL, ULTIMUL, ANTERIOR, URMĂTOR, RELATIV, ABSOLUT) sunt disponibili. Deoarece instrucțiunea ISO DECLARE CURSOR nu include parametrul SCROLL, este acceptat parametrul de selecție NEXT. Parametrul SCROLL nu poate fi specificat simultan cu parametrul FAST_FORWARD.

select_statement
Instrucțiunea SELECT standard returnează intrarea rezultată la cursor. Cuvintele cheie FOR BROWSE și INTO nu sunt permise select_statement Uimit de cursor.

select_statement conflict cu cursorul de tip alimentat.

DOAR CITIȚI

Actualizat]
nume_coloană [, .. .n] este indicat, cu excepția cazului în care articolele sunt listate, se pot face modificări. Deoarece instrucțiunea UPDATE este procesată fără o listă de clauze, pot fi posibile actualizări pentru toate clauzele.

cursor_name
Am un cursor de server Transact-SQL. cursor_name Trebuie să respectați regulile pentru identificatori.

LOCAL
Indică faptul că cursorul este local în raport cu pachetul, procedura care este salvată sau declanșatorul în care tip de creare. Poziția cursorului este permisă doar în mijlocul acestei zone. Cursorul poate fi încărcat cu pachete de modificări locale, proceduri salvate, declanșatoare sau parametrul de ieșire al procedurii salvate. Parametrul OUTPUT este folosit pentru a trece cursorul local pachetului care este salvat, procedura sau declanșatorul, care poate apoi atribui parametrul de modificare cursorului cu metoda de analiză ulterioară a cursorului după finalizarea procedurii salvate. Cursorul este generat implicit după finalizarea pachetului, procedura care este salvată sau declanșarea, care apare atunci când cursorul este trecut la parametrul OUTPUT. Dacă cursorul este trimis la parametrul OUTPUT, cursorul este afișat atunci când sunt selectate toate modificările care sunt trimise la cel nou, sau la părăsirea zonei de vizibilitate.

GLOBAL
Aceasta indică faptul că cursorul este global în raport cu conexiunea. Numele cursorului poate fi analizat fie prin orice procedură care este salvată, fie printr-un pachet care este adăugat la conexiune. Cursorul apare implicit de îndată ce conexiunea este deschisă.

FORWARD_ONLY
Aceasta indică faptul că cursorul se poate deplasa doar de la primul rând pe cel rămas. Este acceptat și parametrul de selecție FETCH NEXT. Dacă parametrul FORWARD_ONLY este specificat fără cuvintele cheie STATIC, KEYSET sau DYNAMIC, cursorul funcționează ca un cursor DYNAMIC. Deoarece nu sunt specificate nici argumentul FORWARD_ONLY, nici argumentul SCROLL, argumentul FORWARD_ONLY este înlocuit deoarece lipsesc cuvintele cheie STATIC, KEYSET sau DYNAMIC. Cursorele STATIC, KEYSET și DYNAMIC sunt alocate setărilor SCROLL. Pentru API-urile bazei de date precum ODBC și ADO, modul FORWARD_ONLY este acceptat de următoarele cursoare Transact-SQL: STATIC, KEYSET și DYNAMIC.

STATIC
Aceasta înseamnă un cursor care creează o copie sensibilă la timp a datelor pentru cursor. Toate înregistrările până la cursor sunt convertite în tabelul de timp alocat tempdb; Astfel, modificările aduse tabelelor de bază nu sunt afișate în datele rotite de selecțiile acestui cursor, iar acest cursor nu permite modificări.

KEYSET
Indică faptul că apartenența și ordinea rândurilor cursorului sunt neschimbate în momentul deschiderii acestuia. Un set de chei care desemnează în mod unic rândurile introduse într-un tabel în tempdb numit chei.

Modificările la valorile non-cheie din tabelele de bază, adăugate de cursorul Vlasnik sau înregistrate de alți utilizatori, sunt afișate imediat ce cursorul este privit de Vlasnik. Modificările create de alți utilizatori nu sunt afișate (modificările nu pot fi create folosind un cursor Transact-SQL suplimentar pe partea serverului). Dacă rândul este vizibil, testul de selecție a rândului se rotește @@FETCH_STATUS -2. Valoarea actualizată a tastei din spatele cursorului este similară cu vizualizarea rândului vechi cu inserarea ulterioară a unui rând nou. Rândul cu valori noi nu este vizibil și încercați să rotiți selecția rândului cu valori vechi @@FETCH_STATUS -2. Actualizarea este vizibilă imediat, deoarece mirosurile sunt împărțite prin cursorul din spatele clauzei suplimentare WHERE CURRENT OF.

DINAMIC
Aceasta înseamnă un cursor care afișează toate modificările datelor, grupate pe rândurile setului de rezultate, pe măsură ce cursorul îl privește. Semnificația acestor date, ordinea și apartenența rândurilor din fiecare eșantion individual se pot schimba. Parametrul de selecție ABSOLUT nu este acceptat de cursoarele dinamice.

REPEDE INAINTE
Indică cursorul FORWARD_ONLY, READ_ONLY, pentru care optimizarea productivității este activată. Parametrul FAST_FORWARD nu poate fi specificat simultan cu parametrii SCROLL sau FOR_UPDATE.

READ_DOAR
Împiedică modificările efectuate prin intermediul acestui cursor. Clauza WHERE CURRENT OF nu poate fi trimisă la cursor într-o instrucțiune UPDATE sau DELETE. Acest parametru are prioritate față de capacitatea implicită de a actualiza cursorul.

SCROLL_LOCKS
Indică faptul că actualizările poziționate sau acțiunile care operează în spatele ajutorului cursorului sunt garantate a fi finalizate cu succes. SQL Server blochează rândurile din lumea în care sunt citite de cursor pentru a se asigura că acele rânduri sunt disponibile pentru modificări ulterioare. Parametrul SCROLL_LOCKS nu poate fi specificat simultan cu parametrul FAST_FORWARD sau STATIC.

OPTIMIST
Indică faptul că actualizările poziționate sau elementele care apar în spatele cursorului suplimentar nu vor fi adăugate dacă rândul a fost actualizat din momentul în care rândul a fost citit în cursor. SQL Server nu blochează rândurile din lumea citirii curente în cursor. Natomistul vikoristovuyutsya povnyannya timestamp-ul sume valorice sau de control, deoarece tabelul nu are timestamp-ul Pași pentru a indica dacă rândul este schimbat după citirea în cursor. Dacă rândul a fost modificat, încercările de actualizare a poziției nu vor avea succes. Parametrul OPTIMISTIC nu poate fi specificat simultan cu parametrul FAST_FORWARD.

TYPE_WARNING
Indică faptul că clientul va fi trimis în avans, deoarece cursorul va fi implicit convertit dintr-un tip care este interogat în altul.

select_statement
Instrucțiunea SELECT standard returnează intrarea rezultată la cursor. Cuvintele cheie COMPUTE, COMPUTE BY, FOR BROWSE și INTO nu sunt permise select_statement Uimit de cursor.

SQL Server convertește implicit cursorul într-un tip diferit din cauza propozițiilor din select_statement conflict cu cursorul de tip alimentat. Pentru a elimina fișele de date suplimentare. „Recrearea implicită a cursorului”.

pentru actualizare]
Aceasta înseamnă elementele care sunt actualizate în cursor. Dacă OF nume_coloană [, ... n] Este posibil să faceți modificări după listarea articolelor. Dacă instrucțiunea UPDATE este actualizată fără o listă de clauze, atunci actualizarea este posibilă pentru toate clauzele, cu excepția cazului în care parametrul READ_ONLY este specificat pentru paralelism.

Instrucțiunea DECLARE CURSOR specifică atributele cursorului Transact-SQL din partea serverului, astfel încât să poată privi ceea ce este procesat pentru a produce setul de rezultate pe care rulează cursorul. Instrucțiunea OPEN stochează setul de rezultate, iar instrucțiunea FETCH rotește rândul. Instrucțiunea CLOSE șterge tastarea curentă asociată cursorului. Instrucțiunea DEALLOCATE alocă resursele care sunt utilizate de cursor.

Prima formă a instrucțiunii DECLARE CURSOR utilizează sintaxa ISO pentru setarea parametrilor cursorului. O altă formă a instrucțiunii DECLARE CURSOR este o extensie de cursor a Transact-SQL care vă permite să definiți cursoare folosind tipuri similare cu cele găsite în funcțiile cursorului API-urilor bazei de date, cum ar fi ODBC și ADO.

Nu este posibilă amestecarea celor două forme. Dacă specificați SCROLL sau fără cuvinte cheie APPLICATION înainte de cuvântul cheie CURSOR, nu puteți selecta cuvinte cheie între cursor și, de asemenea, pentru select_statement Cuvinte cheie. La introducerea cuvintelor cheie între CURSOR, precum și pentru select_statement Cuvintele cheie nu pot fi specificate ca SCROLL sau INSENSITIVE înaintea cuvântului cheie CURSOR.

Dacă sintaxa implicită Transact-SQL pentru instrucțiunea DECLARE CURSOR nu specifică parametrii READ_ONLY, OPTIMISTIC sau SCROLL_LOCKS, atunci valorile implicite sunt preluate.

    Dacă instrucțiunea SELECT nu acceptă actualizarea (fie există permisiunea insuficientă, fie când se accesează tabele la distanță care nu acceptă actualizarea), atunci cursorul primește parametrul READ_ONLY.

    Cursoarele STATIC și FAST_FORWARD sunt setate la READ_ONLY.

    Cursoarele DYNAMIC și KEYSET sunt setate la OPTIMISTIC.

Mesajele de pe cursoare pot fi modificate prin alte instrucțiuni ale limbajului Transact-SQL. Funcțiile API-ului bazei de date nu pot fi executate pe cursoare. De exemplu, după ce cursorul este gol, funcțiile și metodele OLE DB, ODBC sau ADO nu pot fi invocate pe numele său. Rândurile de cursor nu pot fi selectate folosind funcții suplimentare și metode API; Pentru a face acest lucru, trebuie să înțelegeți instrucțiunile FETCH ale limbajului Transact-SQL.

Mai jos sunt procedurile care sunt salvate și pot fi folosite pentru a atribui puteri cursorului după defecțiunea acestuia.

Zminni poate fi vikorystuvatsya ca parte select_statement, Oricine are un cursor gol. Valorile cursoarelor modificate nu se vor schimba după acest anunț.

Permisiunea DECLARE CURSOR este acordată tuturor utilizatorilor care pot efectua o funcție SELECT separată pentru afișaje, tabele și tabele organizate de cursor.

Nu puteți vikoriza cursoarele sau declanșatoarele de pe un tabel cu un index de depozit de coloane grupat. Acest schimb nu se limitează la indici non-cluster; Puteți clasa cursoarele și declanșatoarele pe un tabel cu un index de depozit de coloane necluster.

A. Wikipedia pentru un cursor și sintaxă simple

Setul rezultat, creat atunci când acest cursor este deschis, include toate rândurile și coloanele tabelului. Acest cursor poate fi actualizat, toate actualizările și informațiile sunt prezentate în selecția pentru acest cursor. FETCH``NEXT este disponibil doar atâta timp cât parametrul SCROLL nu este specificat.

DECLARE vend_cursor CURSOR FOR SELECT * FROM Purchasing.Vendor OPEN vend_cursor FETCH NEXT FROM vend_cursor;

B. Utilizarea cursoarelor încorporate pentru afișarea informațiilor

La inserția cap la cap, cursoarele sunt afișate pe partea pliabilă. Furnizorul de îngrijire a pielii va folosi cursorul intern.

SETARE NOCOUNT ON; DECLARE @vendor_id int, @vendor_name nvarchar(50), @message varchar(80), @product nvarchar(50); IMPRIMARE" -------- Raport produse furnizor --------"; DECLARE vendor_cursor CURSOR FOR SELECT VendorID, Name FROM Purchasing.Vendor WHERE PreferredVendorStatus = 1 ORDER BY VendorID; OPEN vendor_cursor FETCH NEXT FROM vendor_cursor INTO @vendor_id, @vendor_name WHILE @@FETCH_STATUS = 0 BEGIN PRINT " " SELECTAȚI @message = "----- Produse de la furnizor: "+ @nume_furnizor PRINT @mesaj -- Declarați un cursor interior bazat -- pe vendor_id din cursorul exterior. DECLARE product_cursor CURSOR FOR SELECT v.Name FROM Purchasing.ProductVendor pv, Production.Product v WHERE pv.ProductID = v.ProductID AND pv.VendorID = @vendor_id -- Valoare variabilă de la cursorul exterior OPEN product_cursor FETCH NEXT FROM product_cursor INTO @product IF @@FETCH_STATUS<>0 PRINT "<>" WHILE @@FETCH_STATUS = 0 BEGIN SELECT @message = " " + @product PRINT @message FETCH NEXT FROM product_cursor INTO @product END CLOSE product_cursor DEALLOCATE product_cursor -- Obțineți următorul furnizor. END CLOSE vendor_cursor; DEALLOCATE vendor_cursor;

Astăzi vedem o mulțime de lucruri de făcut, de exemplu, cum să rulăm o procedură deja creată care acceptă parametrii, în vrac, atunci. nu numai cu parametri statici, ci cu parametrii care sunt modificați, de exemplu, pe baza unui tabel, ca funcție inițială, și în care putem fi ajutați în mod specific cursoare și bucle, iar modul de implementare a totul este imediat surprinzător.

Odată ce ați înțeles, ne vom uita la cursor și vom merge direct la o anumită sarcină. Și vom recunoaște imediat adevărul.

Procedura principală este de a defini toate acțiunile pe care o funcție SQL primară nu le poate, de exemplu, să le dispună și să le insereze pe baza acestor aspecte. І Alergați, de exemplu:

EXEC test_PROCEDURE par1, par2

Dacă îl rulați numai cu aceiași parametri ca cei specificați, cu excepția cazului în care trebuie să rulați această procedură, să spunem de 100, 200 sau chiar de mai multe ori, atunci așteptați un minut. pentru o lungă perioadă de timp Ar fi fost mult mai simplu dacă am fi rulat procedura ca funcție primară a instrucțiunii select, de exemplu:

SELECTAȚI my_fun(id) DIN test_table

Această funcție se execută pe aceeași înregistrare a tabelului test_table, altfel, după cum știți procedura, nu este posibilă corectarea acesteia. Dar există o modalitate care ne va ajuta să ne atingem planul, sau mai degrabă, două metode - prima cu un cursor într-o buclă și cealaltă doar cu o buclă, sau fără un cursor. Există două opțiuni de luat în considerare că trebuie să finalizăm procedura suplimentară odată ce am lansat-o.

Notă! Toate aplicațiile sunt scrise în SGBD MSSql 2008 folosind Management Studio. De asemenea, toate acțiunile următoare extrag cunoștințele necesare din SQL și, mai precis, din programarea în Transact-SQL. Aș dori să vă ofer câteva informații despre materialul actual:

Ei bine, asta este și înainte de a scrie procedura, să aruncăm o privire la datele de ieșire ale exemplului nostru.

Acceptabil, є tabel test_table

CREATE TABLE .( (18, 0) NULL, (50) NULL, (50) NULL) ON GO

Înainte de aceasta, este necesar să introduceți date, pe baza oricăror diviziuni care urmează procedura my_proc_test, în acest caz, pur și simplu introduceți date, dar în practică puteți utiliza propria procedură, deoarece puteți scăpa de o mulțime de probleme, dar în cazul nostru procedura în sine nu este importantă, este mai importantă pentru fund. Ei bine, hai să-l creăm:

CREAȚI PROCEDURA. (@number numeric, @pole1 varchar(50), @pole2 varchar(50)) AS BEGIN INSERT INTO dbo.test_table (număr, pole1, pole2) VALUES (@number, @pole1, @pole2) END GO

Pur și simplu ia trei parametri și îi inserează în tabel.

Dacă acceptăm această procedură, trebuie să rulăm de câte ori mai multe rânduri în orice tabel sau date (VIEWS) pentru a o rula în bloc pentru rândul skin al dzherel-ului.

Și, de exemplu, putem face același dzherelo, vom avea un tabel simplu test_table_time, și îl puteți avea, așa cum am spus deja dzherelo-ul meu, de exemplu, un tabel orar sau o prezentare:

CREATE TABLE .( (18, 0) NULL, (50) NULL, (50) NULL) ON GO

Amintiți-vă aceste date de testare:

Și acum procedura noastră trebuie începută pe rândul pielii, atunci. trei cu parametri diferiți. Pe măsură ce înțelegeți semnificația acestor câmpuri și parametrii noștri, dacă am rulat procedura manual, axa arăta astfel:

exec my_proc_test 1, 'pole1_str1', 'pole2_str1'

Și încă trei, cu parametri similari.

Dacă nu ne place, atunci vom scrie o altă procedură suplimentară care va rula procedura noastră principală de câte ori avem nevoie.

Prima varianta.

Cursorul lui Vikorist și ciclul în procedură

Să mergem direct la dreapta și să scriem procedura ( my_proc_test_all), am comentat mai devreme codul:

CREAȚI PROCEDURA. AS --vocalizați modificările DECLARE @number bigint DECLARE @pole1 varchar(50) DECLARE @pole2 varchar(50) --vocalizați cursorul DECLARE my_cur CURSOR FOR SELECT number, pole1, pole2 FROM test_table_vrem --curbați cursorul de rând în modificările noastre FETCH NE XT FROM my_cur INTO @number, @pole1, @pole2 --dacă există date în cursor, atunci mergem în buclă --și rotim acolo până când rândurile din cursor se termină WHILE @@FETCH_STATUS = 0 BEGIN - bucla este pornită pentru fiecare iterație procedura noastră principală cu parametrii necesari exec dbo.my_proc_test @number, @pole1, @pole2 - citiți următorul rând al cursorului FETCH NEXT FROM my_cur CLOSE my_cur DEALLOCATE my_cur GO

Și acum nu mai putem da clic și verifica rezultatul:

Înainte de sfârșitul procedurii SELECT * FROM test_table --faceți clic pe procedura EXEC dbo.my_proc_test_all --după sfârșitul procedurii SELECT * FROM test_table

După cum puteți vedea, totul a funcționat pentru noi ca o urmă, astfel încât procedura my_proc_test a rulat de trei ori și am rulat procedura suplimentară o singură dată.

Altă opțiune.

Vikorist are un ciclu mai puțin pentru procedură

Vă spun imediat că este nevoie de numerotarea rândurilor din tabel, atunci. Fiecare rând poate fi numerotat, de exemplu 1, 2, 3. În tabelul nostru de timp, un astfel de câmp este număr.

Scrierea unei proceduri my_proc_test_all_v2

CREAȚI PROCEDURA. AS --voted change DECLARE @number bigint DECLARE @pole1 varchar(50) DECLARE @pole2 varchar(50) DECLARE @cnt int DECLARE @i int --știi câte rânduri are tabelul orar SELECT @cnt=count(*) FROM test_table_vrem - setați valoarea inițială a identificatorului SET @i=1 WHILE @cnt >= @i BEGIN -- setați valoarea parametrilor noștri SELECT @number=number, @pole1= pole1, @pole2=pole2 FROM test_table_vrem WHERE number = @I --per iterație Ciclul lansează procedura noastră principală cu parametrii necesari EXEC dbo.my_proc_test @number, @pole1, @pole2 --more croc set @i= @i+1 END GO

Să verificăm rezultatul și mai întâi ne vom șterge tabelul, deoarece am completat deja cu atenție procedura suplimentară my_proc_test_all:

Să ștergem tabelul DELETE test_table --înainte de sfârșitul procedurii SELECT * FROM test_table --clic al procedurii EXEC dbo.my_proc_test_all_v2 --după sfârșitul procedurii SELECT * FROM test_table

După cum sa dovedit, rezultatul este același, chiar și fără cursoare. Care este cea mai bună opțiune pentru dvs., prima opțiune este bună, deoarece numerotarea nu este necesară în principiu și, după cum știți, cursoarele tind să dureze mult timp, deoarece cursorul va avea o mulțime de rânduri, iar cealaltă opțiune este bine pentru că va funcționa tsyuє, așa cum mi se pare suedez , din nou, deoarece vor fi multe rânduri, dacă este necesară numerotarea, opțiunea cu un cursor este în special mai puțin adecvată și apoi puteți veni cu ceva mai bun, Voi arăta doar elementele de bază ale modului de implementare a unei sarcini care au fost stabilite. Noroc!

 

 
Tse tsikavo: