Markörer i MySQL lagrade procedurer. DECLARE CURSOR kommando allmänna regler Ms sql cursors exempel

Youtube

Markör i SQL, ett område i databasminnet som är dedikerat till att lagra den sista SQL-satsen. Om den aktuella satsen är en databasfråga, lagras också en sträng med frågedata som kallas det aktuella värdet, eller aktuell rad, i minnet. markören. Det angivna området i minnet namnges och är tillgängligt för applikationsprogram.

Enligt SQL-standarden när man arbetar med markörer följande huvudsakliga kan identifieras handlingar:

skapande eller markördeklaration ;
öppnar markören, de där. fylla den med data som är lagrad i flernivåminne;
val från markören Och förändra använder dens datalinjer;
stänger markören, varefter den blir otillgänglig för användarprogram;
frigör markören, dvs. radering markören som ett objekt, eftersom det stängning frigör inte nödvändigtvis minnet som är associerat med det.

SQL Server stöder tre typ av markörer:

markörer SQL används främst inom triggers, lagrade procedurer och skript;
markörer servrar agerar på servern och implementerar applikationsprogrammeringsgränssnittet för ODBC, OLE DB, DB_Library;
markörer klienten implementeras på klienten själv. De hämtar hela resultatuppsättningen med rader från servern och lagrar den lokalt, vilket påskyndar databehandlingen genom att minska tidsspillan på nätverksdrift.

Markörhantering i MS SQL Server-miljö

Markörkontroll implementeras genom att utföra följande kommandon:

DEKLARE - skapande eller markördeklaration ;
ÖPPEN - öppningsmarkören, dvs. fylla den med data;
HÄMTA val från markören Och förändra rader med data med hjälp av en markör;
STÄNGA - stänger markören ;
AVDELA – frigör markören, dvs. radera markören som ett objekt.

Markördeklaration

I SQL-standarden för att skapa markören Följande kommando tillhandahålls:

<создание_курсора>::= DECLARE cursor_name CURSOR FOR SELECT_statement ])]

Användning av nyckelordet INSENSITIVE kommer att skapa statisk markör. Data ändrasär inte tillåtna, dessutom visas inte ändringar, gjord av andra användare. Om nyckelordet INSENSITIVE saknas, a dynamisk markör.

När du anger nyckelordet SCROLL skapas markören kan rullas i valfri riktning, så att du kan använda alla kommandon prover. Om detta argument utelämnas, då markören det visar sig konsekvent, dvs. dess visning kommer endast att vara möjlig i en riktning - från början till slut.

SELECT-satsen anger texten i SELECT-frågan, som bestämmer resultatuppsättningen av rader markören.

Genom att ange argumentet FOR READ_ONLY skapas markören"skrivskyddad" och ingen modifiering av data är tillåten. Det är annorlunda än statisk, även om det senare inte heller tillåter dig att ändra data. Kan deklareras som en skrivskyddad markör dynamisk markör, som låter dig visa ändringar, gjord av en annan användare.

Skapande markören med argumentet FOR UPDATE kan du köra in förändring av markördata antingen i de angivna kolumnerna eller, i avsaknad av argumentet OF kolumnnamn, i alla kolumner.

I MS SQL Server-miljön accepteras följande syntax för skapandekommandot markören:

<создание_курсора>::= DECLARE cursor_name CURSOR FOR SELECT_statement ]]

Genom att använda nyckelordet LOCAL skapas en lokal markören, som endast är synlig inom ramen för paketet, utlösaren, lagrad procedur eller användardefinierad funktion som skapade den. När ett paket, trigger, procedur eller funktion slutförs markörenär implicit förstört. För att överföra innehåll markören utanför konstruktionen som skapade den, måste du tilldela dess parameter ett OUTPUT-argument.

Om nyckelordet GLOBAL anges, en global markören; den existerar tills den aktuella anslutningen stängs.

Om du anger FORWARD_ONLY skapas seriell markör ; prov data kan endast bearbetas i riktning från den första raden till den sista.

Genom att specificera SCROLL skapas rullningsbar markör; Data kan nås i valfri ordning och i vilken riktning som helst.

Ange STATIC skapar statisk markör.

Genom att specificera KEYSET skapas en tangentmarkör.

Ange DYNAMIC skapar dynamisk markör.

Om för markören READ_ONLY ange FAST_FORWARD-argumentet som sedan skapades markören kommer att optimeras för snabb dataåtkomst. Detta argument kan inte användas tillsammans med argumenten FORWARD_ONLY eller OPTIMISTIC.

I markören, skapad med argumentet OPTIMISTIC, är förbjudet förändra Och ta bort rader som ändrades efter öppnar markören.

När argumentet TYPE_WARNING specificeras kommer servern att informera användaren om den implicita typändringen markören om den är inkompatibel med SELECT-frågan.

Öppnar markören

För öppnar markören och fylla den med data från den som specificerades under skapandet markören SELECT-frågan använder följande kommando:

OPEN ((cursor_name) |@cursor_variable_name)

Efter öppnar markören Den associerade SELECT-satsen exekveras, vars utdata lagras i flernivåminne.

Hämtar data från en markör

Direkt efter öppnar markören du kan välja dess innehåll (resultatet av att köra motsvarande fråga) med följande kommando:

HÄMTA [ FROM ]((cursor_name)| @cursor_variable_name) ]

Om du anger FIRST returneras den allra första raden i hela resultatuppsättningen markören, som blir den aktuella raden.

Om du anger LAST returneras den senaste raden markören. Det blir också den nuvarande linjen.

Om du anger NEXT returneras raden omedelbart efter den aktuella i hela resultatuppsättningen. Nu blir det aktuellt. Som standard använder FETCH-kommandot den här metoden. prover rader.

Nyckelordet PRIOR returnerar raden före det nuvarande. Det blir aktuellt.

ABSOLUTE (radnummer | @radnummer_variabel) returnerar raden med dess absoluta indexnummer i hela resultatuppsättningen markören. Radnumret kan anges med en konstant eller som namnet på en variabel i vilken radnumret är lagrat. Variabeln måste vara en heltalsdatatyp. Både positiva och negativa värden anges. När du anger ett positivt värde räknas strängen från början av uppsättningen, medan ett negativt värde räknas från slutet. Den valda raden blir den aktuella raden. Om ett nollvärde anges returneras ingen rad.

Argumentet RELATIVE (antal rader | @variabel antal rader) returnerar raden som är det angivna antalet rader efter den aktuella. Om du anger ett negativt antal rader kommer raden som är det angivna antalet rader före den nuvarande att returneras. Om du anger ett nollvärde returneras den aktuella raden. Den returnerade raden blir den aktuella raden.

Till öppna global markör, måste du ange nyckelordet GLOBAL före dess namn. namn markören kan också specificeras med en variabel.

Konstruktionen INTO @variable_name [,...n] specificerar en lista med variabler där motsvarande kolumnvärden för den returnerade strängen kommer att lagras. Variablernas ordning måste matcha ordningen på kolumnerna i markören, och variabelns datatyp är datatypen i kolumnen markören. Om INTO-konstruktionen inte är specificerad kommer beteendet för FETCH-kommandot att likna beteendet för SELECT-kommandot - data visas på skärmen.

1) Konceptet med en markör
Interaktiv SQL gör ingen skillnad mellan enrads- och flerradsfrågor. Inbäddad SQL exekverar dessa frågor på olika sätt. Enradsfrågor returnerar en rad och vi har redan täckt dem. När resultatet av en fråga är mer än en rad måste inbäddad SQL tillåta applikationen att hämta frågeresultaten rad för rad. Markörer används för detta. En markör är en variabel som är kopplad till en fråga. Dess värde är varje rad som matchar frågan. Liksom variabler måste markörer deklareras innan de kan användas. Till skillnad från vyer är markörer designade för rad-för-rad-behandling.

2) Markördeklaration

DEKLARERA [{}] [[NEJ] SKROLLA] MARKÖR [{UTAN|UTAN} HÅLL] FÖR [FÖR {LÄS ENDAST|UPPDATERA [AV ]}]

3) Nyckelord
. KÄNSLIG|INSENSITIV|ASENSITIV– ändringar i resultatuppsättningen är synliga | förbjuden (fixad med en kopia av datamängden)|DBMS själv bestämmer om en kopia ska göras (fungerar som standard).
. UTAN|UTAN HOLD– lämnar öppna | stänger markören om en COMMIT-sats påträffas.
. SKROLLA– [förhindrar] att extrahera resultatrader i slumpmässig ordning.
. ENDAST FÖR LÄS– definierar en skrivskyddad markör.
. FÖR UPPDATERING AV– blockerar endast de angivna kolumnerna från att uppdateras.

4) Deklarera en markör i SQL Server

DEKLARERA MARKÖR [LOKAL|GLOBAL] [FORWARD_ONLY|SCROLL] [STATISK|KEYSET|DYNAMISK|FAST_FORWARD] [READ_ONLY|SCROLL_LOCKS|OPTIMISTISK] FÖR [FÖR UPPDATERING [AV ]]

. STATISK– Definierar en markör som skapar en tillfällig kopia av data för användning av markören. Alla frågor mot en markör får åtkomst till den angivna temporära tabellen i tempdb-databasen, så ändringar i bastabellerna påverkar inte data som returneras av sampel för den markören, och markören i sig tillåter inte att ändringar görs.
. KEYSET– Indikerar att medlemskapet eller ordningen på rader i markören inte ändras efter att den har öppnats. En uppsättning nycklar som unikt identifierar rader är inbyggd i en tabell i tempdb-databasen som kallas keyset.
. DYNAMISK– Definierar en markör som visar alla dataändringar som gjorts på raderna i resultatuppsättningen när den här markören visas. Datavärdena, ordningen och medlemskapet för rader i varje urval kan variera. Alternativet ABSOLUT stöds inte av dynamiska markörer.
. SNABBSPOLA– Indikerar en FORWARD_ONLY, READ_ONLY markör för vilken prestandaoptimering är aktiverad. Alternativet FAST_FORWARD kan inte specificeras med alternativen SCROLL eller FOR_UPDATE.
. SCROLL_LOCKS– Indikerar att positionerade uppdateringar eller raderingar som görs via markören garanterat kommer att lyckas. SQL Server låser rader när de läses in i markören för att säkerställa att de är tillgängliga för efterföljande ändringar. Alternativet SCROLL_LOCKS kan inte specificeras med alternativet FAST_FORWARD eller STATIC.
. OPTIMISTISK– Indikerar att positionerade uppdateringar eller raderingar som görs via markören kommer att misslyckas om raden har uppdaterats sedan den lästes in i markören. SQL Server låser inte rader när de läses in i markören. Istället görs en jämförelse av värdena för tidsstämpelkolumnen (eller kontrollsummor om tabellen inte har en tidsstämpelkolumn) för att avgöra om raden har ändrats sedan den lästes in i markören. Om en rad har ändrats är dess positionerade ändring eller radering inte möjlig. Alternativet OPTIMISTISK kan inte specificeras med alternativet FAST_FORWARD.

5) Öppna markören

6) Hämta rader från markören

HÄMTA [{NÄSTA|FÖR|FÖRSTA|SIST|{ABSOLUT|RELATIV }}]
FRÅN IN I

7) Alternativ för markörpositionering
. NÄSTA|FÖR|FÖRSTA|SIST– till nästa|föregående|första|sista raden i resultatuppsättningen.
. RELATIV ±N– till en linje med en positiv eller negativ offset i förhållande till den aktuella linjen.
. ABSOLUT ±N– till en rad med ett uttryckligen angivet absolut positionsnummer från början eller slutet av markören.

Notera: SQL Server tillåter heltalsvariabeln @N istället för N.

8) Stänger markören

9) Anteckningar om markörer
. Om markören innehåller mer än en rad är det nödvändigt att organisera en slinga för att hämta data från den, och regelbundet kontrollera för att nå den sista raden.
. Till skillnad från tabeller och vyer ordnas markörrader antingen explicit med hjälp av en sektion SORTERA EFTER, eller i enlighet med de konventioner som antagits i ett visst DBMS.
. Markörer används också för att välja grupper av rader från tabeller, som kan uppdateras eller raderas en i taget.
. För att en markör ska kunna uppdateras måste den uppfylla samma kriterier som vyn, det vill säga inte innehålla avsnitt UNION, ORDER BY, GROUP BY, DISTINCT.

10) Exempel för att radera data från en markör

exec sql deklarera markör Cur1 för välj * från Kund
där Betyg
// print (@f1+’ ‘+convert(Varchar(5),@f2))
exec sql radera från kunden
där ström av Cur1; ) – Ta data att radera från markören
ej gjort:
exec sql stäng markör Cur1; — Stäng markören
utgång();

11) Exempel på höjning av provisioner

exec sql deklarera markören CurCust för välj * från Säljare
där SNum in (välj SNum från Kund där Rating=300); — Definiera markören
exec sql öppna markören CurCust; - Kör markören
while (sqlca.sqlcode==0) ( — Skapa en loop för att uppdatera data i tabellen
exec sql hämta CurCust till:Id_num, :SalesPerson, :Loc, :Comm;
exec sql update SalesPeople set Comm=Comm+.01 där aktuell
av CurCust; ) – Ta data för uppdatering från markören
exec sql stäng markör CurCust; — Stäng markören
SELECT S.Name, MAX(S.City) AS City, SUM(O.Amt) AS Amt FROM Säljare S INNER JOIN Beställningar O PÅ S.SNum=O.SNum GRUPP EFTER S.Namn BESTÄLL EFTER 2

DEKLARERA Cur1 SCROLL CURSOR FÖR SELECT S.Name, MAX(S.City) AS City, SUM(O.Amt) AS Amt FROM SalesPeople S INNER JOIN Orders O ON S.SNum=O.SNum GROUP BY S.Name BESTÄLL BY 2
ÖPPEN Cur1
HÄMTA NÄSTA FRÅN Cur1
WHILE @@FETCH_STATUS=0
BÖRJA
HÄMTA NÄSTA FRÅN Cur1
SLUTET
STÄNG Cur1
AVDELA Cur1

Det kan mycket väl hända att svaret på en enkel klientförfrågan kommer att vara ett urval av hundratusentals rader, vilket är svårsmält för de flesta klienter. I det här fallet är lösningen på problemet med interaktion med klienter att använda markörer som en universell mekanism för att utbyta data mellan servern och klienten. Markörer arbetar med resultatuppsättningen data (resultatet av en fråga), vilket ger användarna ytterligare databehandlingsmöjligheter:

Markörer låter dig arbeta med tabellrader genom att ange deras serienummer i datamängden;

Markörer låter dig implementera komplexa datamodifieringsoperationer, till exempel när du ändrar värdet på en kolumn kräver att du upprepade gånger kommer åt värdena i andra kolumner.

Markörens livscykel:

Skapa en markör: DEKLARERA<имя курсора>[ INSENSITIVE ] [ SCROLL ] MARKÖR FÖR< SELECT -оператор>FÖR (LÄS ENDAST | UPPDATERING)

Här betyder nyckelordet INSENSITIVE att markören kommer att vara statisk (en ögonblicksbild av data), medan markören som standard skapas dynamiskt (ett val görs varje gång raden öppnas). Nyckelordet SCROLL innebär att markören kan rullas i vilken riktning som helst, annars skapas markören som en "sekventiell" markör.

Öppningsmarkör:ÖPPNA [GLOBAL]<имя курсора>. En markör som anges som GLOBAL raderas inte automatiskt när proceduren eller paketet som den anropades från slutar.

Läsningdata : HÄMTA [[ NÄSTA | FÖREGÅENDE | FÖRSTA | SISTA | ABSOLUT n | RELATIVE n ] FRÅN ] [ GLOBAL ]<имя курсора>[INTO@variabel_namn,...]. SQL Server 2000 låter dig läsa bara en rad från en markör. Det FÖRSTA nyckelordet är att returnera markörens första rad; LAST – sista raden på markören; NÄSTA – nästa rad efter den nuvarande, den returnerade raden blir den nuvarande; PRIOR – föregående före nuvarande; ABSOLUTE n – returnerar en rad med dess absoluta sekvensnummer i markören; RELATIVE – n rader efter den aktuella. Kolumndata kommer att lagras i var och en av de specificerade variablerna i den ordning de listas.

Ändra data: exekverar ett UPDATE-kommando med syntax designad för att arbeta med markörer.

Ta bort data: kör ett DELETE-kommando med syntax utformad för att fungera med markörer.

Stänger markören: STÄNG [GLOBAL]<имя курсора>

Släpp markören: AVALLOKERA [GLOBALT]<имя курсора>

Ett exempel på hur du använder en markör:

DECLARE fo_curs CURSOR STATIC FOR

VÄLJ namn_rus från för BESTÄLLNING AV namn_rus

DECLARE @name varchar(50)

HÄMTA FÖRST FRÅN fo_curs INTO @namn

WHILE @@FETCH_STATUS=0

HÄMTA NÄSTA FRÅN fo_curs INTO @namn

DEALLOCATE fo_curs

2.7. Säkerställande av datasäkerhet och integritet i Microsoft SQL Server. Databashantering. Roller. Tilldela rättigheter till användare (GIVNA, NEKA, ÅTERVÄNDA). Metoder och teknologier för dataskydd i SQL Server.

SQL Server säkerhet och administration. .

Huvuduppgiften för ett DBMS är att säkerställa integriteten och konsistensen av data inom det valda ämnesområdet. En av faktorerna som hindrar systemet från att lösa detta problem är handlingar från användare som av misstag eller avsiktligt försöker förstöra datastrukturen eller ändra själva data. Följaktligen måste DBMS skyddas inte bara från fysiska fel utan också från användare som är otillräckliga för de uppgifter som implementeras. För att göra detta är det nödvändigt att designa och ansluta ett säkerhetssystem till databasen som förhindrar användare från att utföra åtgärder utanför deras behörighet.

Databashantering

För att skapa en databas med TSQL, använd kommandot CREATE DATABASE, men vanligtvis används funktionerna i SQL Server Management Studio för detta ändamål. Det finns en hel del databasoperationer definierade i SQL Server: öka (minska) filstorlekar, ändra konfiguration (ALTER-kommando), bifoga och ta bort, överföra ägande, byta namn, visa egenskaper och slutligen ta bort (DROP DATABASE).

Som de flesta databasservrar har SQL Server en användare med fullständiga administrativa rättigheter - det här är Systemadministratör eller "sa". Efter den första serverinstallationen är sa-lösenordet tomt. Användaren som skapar en ny databas blir automatiskt dess ägare ('dbo' - Databasägare) Vid den tidpunkt då databasen skapas definieras även användarens "gäst" Om användarkontot inte är explicit mappat till en användare en specifik databas, får användaren implicit åtkomst med Att använda gästnamnet gäst är vanligtvis förbjudet.

Användaren som skapar ett objekt i databasen blir automatiskt dess ägare, och ingen, inklusive dbo och sa, kan använda det objektet förrän ägaren tilldelar dem rättigheter till det. Men för att en användare ska kunna skapa ett objekt måste databasägaren först ge honom lämpliga rättigheter.

Roll låter dig kombinera användare som utför samma funktioner för att förenkla administrationen. Roller kan vara inbyggda eller anpassade. Inbyggda roller implementeras på servernivå och på databasnivå. Nedan finns en tabell över inbyggda databasroller:

db_ägare. Har alla rättigheter i databasen

db_accessadmin. Kan lägga till eller ta bort användare

Db_securityadmin. Hanterar alla behörigheter, objekt, roller och användare

Db_ddladmin. Kan köra alla DDL-kommandon utom GRANT, DENY, REVOKE

Db_backupoperator. Arkivarien kan utföra kommandon. data

db_datareader. Kanske tittar. alla data i någon tabell

db_datawriter. Kanske en modifikation. alla data i någon tabell

Db_denydatareader. Förbjuden se kärlek data i någon tabeller

Db_denydatawriter. Förbjud modifiering av data i några tabeller

Tilldela rättigheter till användare. Grunden för SQL Server-säkerhet är (1) konton; (2) användare; (3) roller; (4) grupper.

När en användare ansluter till SQL Server bestäms de åtgärder han kan utföra av de rättigheter som tilldelats honom som användare och medlem av en roll. Rättigheter beviljas av DBMS-administratören, databasägaren eller ägaren till ett specifikt databasobjekt. Rättigheter i databasen kan delas in i tre kategorier: (1) rättigheter att få åtkomst till databasobjekt; (2) rättigheter att utföra TSQL-kommandon; (3) implicita rättigheter. Servern låter dig överföra äganderätten från en användare till en annan.

Följande kommandon används för att hantera användarbehörigheter för att komma åt databasobjekt:

BEVILJA(ALLA |< вид действия >,…}

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

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

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

TILL ( OFFENTLIGT |<имя объекта системы безопасности>,…}

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

– tilldela rättigheter till användare, Var

ALLA – användaren ges alla möjliga behörigheter, specificera annars

<вид действия>– rättigheter till åtgärder som är tillgängliga för användaren, nämligen:

VÄLJ – för vy, för tabellkolumn och för tabell (vy)

INSERT – för att lägga till, för tabellen (vyn) som helhet

UPPDATERING – för förändring, för en tabellkolumn och för en tabell (vy)

DELETE – för att ta bort, för tabellen (vyn) som helhet

EXECUTE – för att utföra lagrade procedurer

REFERENSER – möjligheten att referera till ett specificerat objekt (inkludera det som en del av en främmande nyckel).

<имя объекта системы безопасности>– SQL Server-konton, Windows-domänanvändare; PUBLIC – för alla användare.

MED BILJANDEALTERNATIV - tillåter användaren som för närvarande beviljas rättigheter att tilldela åtkomsträttigheter till objektet till andra användare.

SOM<имя группы> | <имя роли>– deltagande av en användare i en roll som ges möjlighet att ge rättigheter till andra användare.

GE VAL PÅ författare TILL allmänheten

BILJA INFOGA, UPPDATERA, DELETE PÅ författare TILL Mary, John, Tom

BIDRAG VAL PÅ Plan_Data TILL redovisning MED BIDRAG

BETYD VAL PÅ Plan_Data TILL Jack AS Accounting

Jack är inte medlem i redovisningsrollen, men någon i den rollen kan ge tillstånd

FÖRNEKA(ALLA |< вид действия >,…}

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

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

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

TILL ( OFFENTLIGT |<имя объекта системы безопасности>,…}

– nekad åtkomst användare till databasobjekt. CASCADE återkallar rättigheter inte bara från denna användare, utan också från alla som han har gett rättigheter till.

Exempel (på kommandoförbud TSQL):

NEJ SKAPA BORD TILL Jack CASCADE

Team ÅTERKALLA används för att implicit neka åtkomst till databasobjekt. Syntaxen är densamma som kommandot DENY. Implicit nekande liknar att neka åtkomst, förutom att det bara gäller på den nivå som det är definierat på. Exempel: Användaren Jack, som är medlem i rollen GoodUsers, ges åtkomsträttigheter till XFiles-tabellen. Om REVOKE nekas för rollen GoodUsers att få åtkomst till denna tabell, kan Jack fortfarande komma åt den här tabellen eftersom rättigheterna för honom är explicit definierade. Om du använder REVOKE personligen åt honom kommer han att förlora rätten att få åtkomst till XFiles.

Behörigheter som ges till roller ärvs av deras medlemmar. Om en användare beviljas åtkomst till ett objekt genom medlemskap i en roll men nekad i en annan, så löses alltid åtkomstkonflikten till förmån för nekande.

Dataskyddsteknik i MS SQL Server

1. Mekanism kontrollpunkter– kontrollpunkter som genereras efter ~60 s för att skriva uppdaterade sidor till disken (en kontrollpunkt kan tvingas fram av kommandot CHECKPOINT).

2. Inbyggda och externa mekanismer för att kontrollera databasens integritet (startas automatiskt eller, som DBCC-verktyget - Database Consistency Checker - manuellt).

3. Fysisk duplicering (om tillåtet) av databasfiler med operativsystemet (inklusive mekanismen för speglade hårddiskar).

4. Säkerhetskopiera databaser och transaktionsloggar - genom att skriva en databasdump till en backupenhet (magnetband eller hårddisk).

5. Replikering – möjligheten att duplicera information genom att regelbundet (i vissa fall synkront) överföra den från en SQL-server till en annan.

6. Kryptering av trafik mellan klient och server, samt kryptering av koder som används för att arbeta med databasobjekt (lagrade procedurer, triggers, etc.)

En explicit markör är ett SELECT-kommando som uttryckligen definieras i deklarationsdelen av ett program. När du deklarerar en explicit markör får den ett namn. Explicita markörer kan inte definieras för kommandona INSERT, UPDATE, MERGE och DELETE.

Genom att definiera SELECT-kommandot som en explicit markör har programmeraren kontroll över de viktigaste stegen för att hämta information från Oracle-databasen. Den bestämmer när markören ska öppnas (OPEN), när rader ska väljas från den (FETCH), hur många rader som ska väljas och när markören ska stängas med CLOSE-kommandot. Information om markörens aktuella tillstånd är tillgänglig via dess attribut. Det är denna höga granularitet av kontroll som gör explicita markörer till ett ovärderligt verktyg för programmeraren.

Låt oss titta på ett exempel:

1 FUNCTION jealousy_level (2 NAME_IN IN friends.NAME%TYPE) RETUR NUMMER 3 SOM 4 CURSOR jealousy_cur 5 ÄR 6 VÄLJ plats FRÅN vänner 7 DÄR NAMN = ÖVRE (NAME_IN); 8 8 jealousy_rec jealousy_cur%ROWTYPE; 9 återgång NUMMER; 10 BÖRJA 11 ÖPPNA jealousy_cur; 13 12 HÄMTA jealousy_cur INTO jealousy_rec; 15 13 OM jealousy_cur%FOUND 14 DÅ 15 OM jealousy_rec.location = "PUERTO RICO" 16 DÅ retval:= 10; 17 ELSIF jealousy_rec.location = "CHICAGO" 18 DÅ retval:= 1; 19 SLUT OM; 20 SLUT OM; 24 21 STÄNG svartsjuka_cur; 26 22 RETUR återgång; 23 UNDANTAG 24 NÄR ANDRA DÅ 25 OM jealousy_cur%ISOPEN SÅ 26 STÄNG jealousy_cur; 27 SLUT OM; 28 SLUT;

De följande avsnitten diskuterar var och en av dessa operationer i detalj. Termen "markör" i dem syftar på explicita markörer, om inte texten uttryckligen anger något annat.

Deklarera en explicit markör

För att kunna använda en explicit markör måste den deklareras i deklarationsdelen av PL/SQL-blocket eller -paketet:

CURSOR cursor_name [ ([ parameter [, parameter...]) ] [ RETURN spec_reEirn ] IS SELECT_command ];

Här är markörnamnet namnet på den deklarerade markören; spiifiction_te?it - valfri RETURN-sektion; KOMaHdaSELECT - valfritt giltigt SQL SELECT-kommando. Parametrar kan också skickas till markören (se avsnittet "Markörparametrar" nedan). Slutligen, efter kommandot SELECT...FOR UPDATE, kan du ange en lista över kolumner som ska uppdateras (se även nedan). Efter deklarationen öppnas markören med OPEN-kommandot och rader hämtas från den med FETCH-kommandot.

Några exempel på explicita markördeklarationer.

Markör utan parametrar. Den resulterande uppsättningen rader från den här markören är uppsättningen företags-ID:n valda från alla rader i tabellen:

CURSOR company_cur IS SELECT company_id FRÅN företag;

Markör med parametrar. Den resulterande raduppsättningen av den här markören innehåller en enda rad med företagsnamnet som motsvarar värdet på den angivna parametern:

CURSOR name_cur (company_id_in I NUMBER) IS SELECT name FRÅN company WHERE company_id = company_id_in;

Markör med RETURN-sats. Den resulterande raduppsättningen av denna markör innehåller all data i personaltabellen för avdelnings-ID 10:

CURSOR emp_cur RETUR anställda%ROWTYPE ÄR VALD * FRÅN anställda WHERE department_id = 10;

Markörens namn

Ett explicit markörnamn måste vara upp till 30 tecken långt och följa samma regler som andra PL/SQL-identifierare. Markörnamnet är inte en variabel - det är identifieraren för pekaren till begäran. Markörnamnet tilldelas inget värde och kan inte användas i uttryck. Markören används endast i kommandona OPEN, CLOSE och FETCH, och för att kvalificera markörattributet.

Deklarera en markör i ett paket

Explicita markörer deklareras i deklarationsdelen av ett PL/SQL-block. En markör kan deklareras på paketnivå, men inte inom en specifik paketprocedur eller funktion. Ett exempel på att deklarera två markörer i ett paket:

PACKAGE book_info IS CURSOR titles_cur IS VÄLJ titel FRÅN böcker; CURSOR books_cur (title_filter_in IN books.title%TYPE) RETURNERA böcker%ROWTYPE ÄR SELECT * FRÅN böcker DÄR titel LIKE title_filter_in; SLUTET;

Den första titles_cursor-markören returnerar endast boktitlar. Den andra, books_cur , returnerar alla rader i boktabellen där boknamnen matchar mönstret som anges som markörparameter (till exempel "Alla böcker som innehåller strängen 'PL/SQL'"). Observera att den andra markören använder en RETURN-sektion, som deklarerar datastrukturen som returneras av FETCH-kommandot.

Sektionen RETURN kan innehålla någon av följande datastrukturer:

En post definierad från en datatabellrad med attributet %ROWTYPE.
En post definierad från en annan, tidigare deklarerad markör, som också använder attributet %rowtype.
En programmerardefinierad post.

Antalet uttryck i markörvalslistan måste matcha antalet kolumner i posten tabellnamn%ROWTYPE, Kypcop%ROWTYPE eller posttyp. Datatyperna för elementen måste också vara kompatibla. Till exempel, om det andra elementet i urvalslistan är av typen NUMBER, kan den andra kolumnen i posten i RETURN-sektionen inte vara av typen VARCHAR2 eller BOOLEAN.

Innan vi går vidare till en detaljerad undersökning av RETURN-sektionen och dess fördelar, låt oss först förstå varför det kan vara nödvändigt att deklarera markörer i ett paket? Varför inte deklarera en explicit markör i programmet där den används - i en procedur, funktion eller anonymt block?

Svaret är enkelt och övertygande. Genom att definiera en markör i ett paket kan du återanvända frågan som definieras i det utan att upprepa samma kod på olika platser i applikationen. Genom att implementera frågan på ett ställe förenklar dess modifiering och kodunderhåll. Vissa tidsbesparingar uppnås genom att minska antalet bearbetade förfrågningar.

Det är också värt att överväga att skapa en funktion som returnerar en markörvariabel baserad på REF CURSOR . Det anropande programmet hämtar rader genom en markörvariabel. För mer information, se avsnittet "Markörvariabler och REF CURSOR".

När du deklarerar markörer i återanvändbara paket finns det en viktig sak att tänka på. Alla datastrukturer, inklusive markörer, deklarerade på "paketnivå" (inte i en specifik funktion eller procedur), behåller sina värden under hela sessionen. Detta innebär att batchmarkören förblir öppen tills du uttryckligen stänger den, eller tills sessionen avslutas. Markörer som deklareras i lokala block stängs automatiskt när dessa block är klara.

Låt oss nu titta på RETURN-sektionen. En intressant sak med att deklarera en markör i ett paket är att markörens rubrik kan separeras från dess kropp. Denna rubrik, som mer påminner om ett funktionshuvud, innehåller information som programmeraren behöver för att fungera: namnet på markören, dess parametrar och vilken typ av data som returneras. Markörens kropp är kommandot SELECT. Denna teknik demonstreras i den nya versionen av books_cursor-deklarationen i book_info-paketet:

PACKAGE book_info IS CURSOR books_cur (title_filter_in IN books.title%TYPE) RETURNERA böcker%ROWTYPE; SLUTET; PACKAGE BODY book_info IS CURSOR books_cur (title_filter_in IN books.title%TYPE) RETURNERA böcker%RAWTYPE ÄR SELECT * FRÅN böcker DÄR titel LIKE title_filter_in; SLUTET;

Alla tecken före IS-nyckelordet bildar en specifikation, och efter IS kommer markörkroppen. Att dela upp markördeklarationen kan tjäna två syften.

Döljer information. Markören i paketet är en "svart låda". Detta är bekvämt för programmerare eftersom de inte behöver skriva eller ens se kommandot SELECT. Det räcker att veta vilka poster den här markören returnerar, i vilken ordning och vilka kolumner de innehåller. En programmerare som arbetar med paketet använder markören som alla andra färdiga element.
Minsta omkompilering. Genom att dölja frågedefinitionen i paketets brödtext kan ändringar av kommandot SELECT göras utan att ändra markörhuvudet i paketspecifikationen. Detta gör att kod kan förbättras, korrigeras och kompileras om utan att kompilera om paketspecifikationen, så att program som är beroende av det paketet inte kommer att markeras som ogiltiga och inte behöver kompileras om.

Öppna en explicit markör

Att använda en markör börjar med att definiera den i deklarationssektionen. Därefter måste den deklarerade markören öppnas. Syntaxen för OPEN-satsen är mycket enkel:

OPEN cursor_name [ (argument [, argument...]) ];

Här är cursorname namnet på den tidigare deklarerade markören, och argument är värdet som skickas till markören om den deklareras med en lista med parametrar.

Oracle stöder också FOR-syntax när du öppnar en markör, som används för både markörvariabler (se avsnittet "Markörvariabler och REF CURSOR") och inbäddad dynamisk SQL.

När PL/SQL öppnar en markör, kör den frågan den innehåller. Dessutom identifierar den den aktiva datamängden - raderna i alla tabeller som deltar i frågan som matchar WHERE-kriteriet och kopplingsvillkoret. OPEN-kommandot hämtar inte data - det är uppgiften för FETCH-kommandot.

Oavsett när den första datahämtningen sker, säkerställer Oracles dataintegritetsmodell att alla hämtningsoperationer returnerar data i det tillstånd där markören öppnades. Med andra ord, från öppning till stängning av markören, när data hämtas från den, ignoreras infogning, uppdatering och radering som utförs under denna tid helt.

Dessutom, om kommandot SELECT innehåller en FÖR UPPDATERING-sektion, låses alla rader som identifieras av markören när markören öppnas.

Om du försöker öppna en markör som redan är öppen kommer PL/SQL att skicka följande felmeddelande:

ORA-06511: PL/SQL: markören är redan öppen

Därför, innan du öppnar markören, bör du kontrollera dess tillstånd med hjälp av attributvärdet %är öppen:

OM INTE company_cur%ISOPEN SÅ ÖPPNA company_cur; ENDIF;

Attributen för explicita markörer beskrivs nedan i avsnittet dedikerat till dem. sektion.

Om ett program kör en FOR-slinga med hjälp av en markör, behöver markören inte öppnas (hämtas, stängs) explicit. PL/SQL-motorn gör detta automatiskt.

Hämtar data från en explicit markör

SELECT-kommandot skapar en virtuell tabell - en uppsättning rader definierade av en WHERE-sats med kolumner definierade av en lista med SELECT-kolumner. Således representerar markören denna tabell i PL/SQL-programmet. Det primära syftet med en markör i PL/SQL-program är att välja rader för bearbetning. Hämta markörrader görs med kommandot FETCH:

FETCH cursor_name INTO record_or_variable_list;

Här är markörnamnet namnet på markören från vilken posten väljs, och posten eller variabellistan är PL/SQL-datastrukturerna till vilka nästa rad i den aktiva postuppsättningen kopieras. Data kan placeras i en PL/SQL-post (deklareras med %ROWTYPE-attributet eller TYPE-deklarationen) eller i variabler (PL/SQL-variabler eller bindningsvariabler - som i Oracle Forms-element).

Exempel på explicita markörer

Följande exempel visar olika sätt att ta prov på data.

Hämta data från en markör till en PL/SQL-post:

DECLARE CURSOR company_cur är SELECT ...; company_rec company_cur%ROWTYPE; BÖRJA ÖPPNA company_cur; FETCH company_cur INTO company_rec;

Hämta data från en markör till en variabel:

HÄMTA new_balance_cur INTO new_balance_dollars;

Hämta data från en markör till en PL/SQL-tabellrad, variabel och Oracle Forms bindningsvariabel:

HÄMTA emp_name_cur INTO emp_name (1), anställningsdatum, :dept.min_salary;

Data som hämtas från en markör ska alltid placeras i en post som deklareras under samma markör med attributet %ROWTYPE; Undvik att välja listor med variabler. Att hämta till en post gör koden mer kompakt och flexibel, vilket gör att du kan ändra hämtningslistan utan att ändra kommandot FETCH.

Provtagning efter bearbetning av sista raden

När du öppnar markören väljer du rader från den en efter en tills alla är slut. Du kan dock fortfarande utfärda kommandot FETCH efter detta.

Konstigt nog ger PL/SQL inget undantag i det här fallet. Han gör bara ingenting. Eftersom det inte finns något annat att välja, ändras inte värdena för variablerna i INTO-delen av FETCH-kommandot. Med andra ord, kommandot FETCH ställer inte in dessa variabler till NULL.

Explicita markörkolumnalias

SELECT-satsen i markördeklarationen anger listan med kolumner som den returnerar. Tillsammans med tabellkolumnnamn kan den här listan innehålla uttryck som kallas beräknade eller virtuella kolumner.

Ett kolumnalias är ett alternativt namn som anges i SELECT-kommandot för en kolumn eller ett uttryck. Genom att definiera lämpliga alias i SQL*Plus kan du visa resultaten av en godtycklig fråga i läsbar form. I dessa situationer är alias inte nödvändiga. Å andra sidan, när du använder explicita markörer, behövs beräknade kolumnalias i följande fall:

när data hämtas från en markör till en post som deklareras med %ROWTYPE-attributet baserat på samma markör;
när ett program innehåller en referens till en beräknad kolumn.

Överväg följande fråga. Kommandot SELECT väljer namnen på alla företag som beställde varor under 2001, såväl som det totala antalet beställningar (förutsatt att standardformateringsmasken för den aktuella databasinstansen är DD-MON-YYYY):

VÄLJ företagsnamn, SUMMA (inv_amt) FRÅN företag c, faktura i WHERE c.company_id = i.company_id AND i.invoice_date MELLAN "01-JAN-2001" OCH "31-DEC-2001";

Om du kör det här kommandot i SQL*Plus får du följande utdata:

FÖRETAGSNAMN	SUM(INV_AMT)
ACME TURBO INC.	1000
WASHINGTON HAIR CO.	25.20

Som du kan se är kolumnrubriken SUM (INV_AMT) inte väl lämpad för en rapport, men den är bra för att bara visa data. Låt oss nu köra samma fråga i ett PL/SQL-program med en explicit markör och lägga till ett kolumnalias:

DECLARE CURSOR comp_cur IS SELECT c.name, SUM (inv_amt) total_sales FROM company C, invoice I WHERE C.company_id = I.company_id AND I.invoice_date MELLAN "01-JAN-2001" AND "31-DEC-2001"; comp_rec comp_cur%ROWTYPE; BÖRJA ÖPPNA comp_cur; FETCH comp_cur INTO comp_rec; SLUTET;

Utan aliaset kommer jag inte att kunna referera till kolumnen i comp_rec-poststrukturen. Om du har ett alias kan du arbeta med en beräknad kolumn precis som med vilken annan frågekolumn som helst:

OM comp_rec.total_sales > 5000 DÅ DBMS_OUTPUT.PUT_LINE ("Du har överskridit din kreditgräns på $5000 med " || TO_CHAR (comp_rec.total_sales - 5000, "$9999")); ENDIF;

När du väljer en rad i en post som deklareras med %ROWTYPE-attributet, kan den beräknade kolumnen endast nås med namn - eftersom strukturen på posten bestäms av själva markörens struktur.

Stänger en explicit markör

En gång i barndomen fick vi lära oss att städa efter oss själva, och denna vana fanns kvar hos oss (även om inte alla) resten av våra liv. Det visar sig att denna regel spelar en extremt viktig roll i programmering, och speciellt när det gäller att hantera markörer. Glöm aldrig att stänga markören när du inte längre behöver den!

CLOSE kommandosyntax:

STÄNG cursor_name;

Nedan finns några viktiga tips och överväganden relaterade till att stänga explicita markörer.

Om en markör deklareras och öppnas i en procedur, se till att stänga den när du är klar med den; annars kommer din kod att läcka minne. I teorin bör en markör (som vilken datastruktur som helst) automatiskt stängas och förstöras när den går utanför räckvidden. Vanligtvis, när du avslutar en procedur, funktion eller anonymt block, stänger PL/SQL faktiskt alla öppna markörer i den. Men denna process är resurskrävande, så av effektivitetsskäl försenar PL/SQL ibland identifiering och stängning av öppna markörer. Markörer av typen REF CURSOR kan per definition inte stängas implicit. Det enda du kan vara säker på är att när det "yttersta" PL/SQL-blocket slutförs och kontrollen återförs till SQL eller ett annat anropande program, kommer PL/SQL implicit att stänga alla markörer som öppnas av det blocket eller kapslade block utom REF CURSOR . Artikeln "Cursor reuse in PL/SQL static SQL" från Oracle Technology Network ger en detaljerad analys av hur och när PL/SQL stänger markörer. Kapslade anonyma block är ett exempel på en situation där PL/SQL inte implicit stänger markörer. För lite intressant information om detta ämne, se Jonathan Gennicks artikel "Stänger PL/SQL implicit markörer?"
Om en markör deklareras i ett paket på paketnivå och är öppen i något block eller program, kommer den att förbli öppen tills du uttryckligen stänger den eller tills sessionen avslutas. Därför, efter att ha avslutat arbetet med en satsnivåmarkör, bör du omedelbart stänga den med kommandot CLOSE (och förresten, detsamma bör göras i undantagsavsnittet):

BÖRJA ÖPPNA my_package.my_cursor; ... Arbeta med markören STÄNG my_package.my_cursor; UNDANTAG NÄR ANDRA DÅ OM mypackage.my_cursor%ISOPEN SÅ STÄNG my_package.my_cursor; ENDIF; SLUTET;

Markören kan bara stängas om den tidigare varit öppen; annars kommer ett INVALID_CURS0R-undantag att kastas. Markörens tillstånd kontrolleras med attributet %ISOPEN:

OM company_cur%ISOPEN SÅ STÄNG company_cur; ENDIF;

Om det finns för många öppna markörer kvar i programmet, kan antalet markörer överstiga värdet för databasparametern OPEN_CURSORS. Om du får ett felmeddelande, se först till att markörerna som deklareras i paketen är stängda när de inte längre behövs.

Explicita markörattribut

Oracle stöder fyra attribut (%FOUND, %NOTFOUND, %ISOPEN, %ROWCOUNTM) för att få information om tillståndet för en explicit markör. En attributreferens har följande syntax: cursor%attribute

Här är markören namnet på den deklarerade markören.

Värdena som returneras av explicita markörattribut visas i tabell. 1.

Bord 1. Explicita markörattribut

Värdena för markörattribut före och efter att ha utfört olika operationer med dem visas i tabell. 2.

Tänk på följande när du arbetar med explicita markörattribut:

Om du försöker komma åt attributen %FOUND, %NOTFOUND eller %ROWCOUNT innan markören öppnas eller efter att den stängs, kastar Oracle ett INVALID CURSOR-undantag (ORA-01001).
Om första gången FETCH-kommandot körs, den resulterande raduppsättningen är tom, returnerar markörattributen följande värden: %FOUND = FALSE , %NOTFOUND = TRUE och %ROWCOUNT = 0 .
När du använder BULK COLLECT returnerar attributet %ROWCOUNT antalet rader som hämtats till de givna samlingarna.

Tabell 2. Markörattributvärden

Drift	%HITTADES	%HITTADES INTE	%ÄR ÖPPEN	%ROWCOUNT
Innan ÖPPEN	Undantag ORA-01001	Undantag ORA-01001	FALSK	Undantag ORA-01001
Efter OPEN	NULL	NULL	SANN	0
Före det första FETCH-provet	NULL	NULL	SANN	0
Efter det första provet HÄMTA	SANN	FALSK	SANN	1
Innan efterföljande HÄMTA	SANN	FALSK	SANN	1
Efter efterföljande FETCH	SANN	FALSK	SANN	Beror på data
Före det sista FETCH-provet	SANN	FALSK	SANN	Beror på data
Efter det sista FETCH-provet	SANN	FALSK	SANN	Beror på data
Innan STÄNG	FALSK	SANN	SANN	Beror på data
Efter STÄNG	Undantag	Undantag	FALSK	Undantag

Användningen av alla dessa attribut visas i följande exempel:

Tidigare bloggar har upprepade gånger gett exempel på användning av parametrar rutiner och funktioner. Parametrar är ett sätt att skicka information till och från en programmodul. När de används på rätt sätt gör de modulerna mer användbara och flexibla.

PL/SQL låter dig skicka parametrar till markörer. De utför samma funktioner som parametrarna för programvarumodulerna, såväl som flera ytterligare.

Utökar funktionerna för återanvändning av markören. Istället för att hårdkoda värdena som definierar datavalsvillkoren i WHERE-satsen, kan du använda parametrar för att skicka nya värden till WHERE-satsen varje gång markören öppnas.
Felsökning av problem med marköromfång. Om frågan använder parametrar istället för hårdkodade värden, är den resulterande uppsättningen markörrader inte kopplad till ett specifikt program eller blockvariabel. Om ditt program har kapslade block kan du definiera en markör på översta nivån och använda den i kapslade block med variabler deklarerade i dem.

Antalet markörparametrar är obegränsat. När OPEN anropas måste alla parametrar (förutom de som har standardvärden) anges för markören.

När kräver en markör parametrar? Den allmänna regeln här är densamma som för procedurer och funktioner: om markören förväntas användas på olika platser och med olika värden i WHERE-sektionen, bör en parameter definieras för den. Låt oss jämföra markörer med och utan parametern. Exempel på en markör utan parametrar:

CURSOR joke_cur IS SELECT namn, kategori, last_used_date FROM Jokes;

Markörens resultatuppsättning inkluderar alla poster i skämttabellen. Om vi bara behöver en viss delmängd av rader ingår WHERE-avsnittet i frågan:

CURSOR joke_cur ÄR SELECT namn, kategori, senast_använd_datum FRÅN skämt WHERE kategori = "MAN";

För att utföra denna uppgift använde vi inte parametrar, och de behövs inte. I det här fallet returnerar markören alla rader som tillhör en specifik kategori. Men vad händer om kategorin ändras varje gång du använder den här markören?

Markörer med parametrar

Naturligtvis skulle vi inte definiera en separat markör för varje kategori – det skulle vara helt oförenligt med hur datadriven applikationsutveckling fungerar. Vi behöver bara en markör, men en som vi kan ändra kategori för - och den skulle fortfarande returnera den information som krävs. Och den bästa (men inte den enda) lösningen på detta problem är att definiera en parametriserad markör:

PROCEDUR explain_joke (main_category_in IN joke_category.category_id%TYPE) IS /* || Markör med en lista med parametrar som består av || från en enda strängparameter. */ CURSOR joke_cur (category_in IN VARCHAR2) IS SELECT name, category, last_used_date FROM Joke WHERE category = UPPER (category_in); joke_rec joke_cur%ROWTYPE; BEGIN /* Nu, när du öppnar en markör, skickas ett argument till den */ OPEN joke_cur (main_category_in); HÄMTA joke_cur INTO joke_rec;

Mellan markörnamnet och IS-nyckelordet finns nu en lista med parametrar. Det hårdkodade HUSBAND-värdet i WHERE-satsen har ersatts med en referens till UPPER-parametern (category_in). När du öppnar markören kan du ställa in värdet på HUSBAND , husband eller MANN - markören kommer fortfarande att fungera. Namnet på kategorin för vilken markören ska returnera skämttabellrader anges i OPEN-satsen (inom parentes) som en bokstavlig, konstant eller ett uttryck. När markören öppnas analyseras kommandot SELECT och parametern associeras med värdet. Den resulterande uppsättningen rader bestäms sedan och markören är redo för hämtning.

Öppna en markör med alternativ

En ny markör kan öppnas som anger vilken kategori som helst:

OPEN joke_cur(Jokes_pkg.category); OPEN joke_cur("man"); OPEN joke_cur("politiker"); OPEN joke_cur (Jokes_pkg.relation || "-IN-LAW");

Markörparametrar används oftast i WHERE-satsen, men de kan refereras till någon annanstans i SELECT-satsen:

DECLARE CURSOR joke_cur (category_in IN ARCHAR2) IS SELECT name, category_in, last_used_date FROM joke WHERE category = UPPER (category_in);

Istället för att läsa kategorin från tabellen, ersätter vi helt enkelt parametern category_in i urvalslistan. Resultatet förblir detsamma eftersom WHERE-satsen begränsar provkategorin till parametervärdet.

Markörens parameteromfång

Omfattningen av en markörparameter är begränsad till den markören. En markörparameter kan inte refereras utanför SELECT-kommandot som är associerat med markören. Följande PL/SQL-kodavsnitt kompileras inte eftersom programnamn inte är en lokal variabel i blocket. Detta är en formell markörparameter som endast definieras inuti markören:

DECLARE CURSOR scariness_cur (program_name VARCHAR2) IS SELECT SUM (scary_level) total_cary_level FRÅN tales_from_the_crypt WHERE prog_name = program_name; BEGIN program_name:= "DEN ANDANDE MUMIEN"; /* Ogiltig länk */ OPEN scariness_cur (program_name); .... STÄNG scariness_cur; SLUTET;

Markörparameterlägen

Syntaxen för markörparametrar är mycket lik den för procedurer och funktioner - förutom att markörparametrar bara kan vara IN-parametrar. Markörparametrar kan inte ställas in på lägena OUT eller IN OUT. Dessa lägen tillåter att värden skickas och returneras från procedurer, vilket inte är meningsfullt för en markör. Det finns bara ett sätt att få information från markören: hämta en post och kopiera värdena från listan över kolumner i INTO-sektionen

Standardparametervärden

Markörparametrar kan tilldelas standardvärden. Ett exempel på en markör med ett standardparametervärde:

CURSOR emp_cur (emp_id_in NUMBER:= 0) ÄR SELECT anställd_id, emp_name FROM anställd WHERE anställd_id = emp_id_in;

Eftersom parametern emp_id_in har ett standardvärde kan den utelämnas i FETCH-kommandot. I detta fall kommer markören att returnera information om medarbetaren med kod 0.