DECLARE CURSOR istruzione

Invocazione per DECLARE CURSOR

Questa istruzione può essere inserita solo in un programma applicativo. Non è un'istruzione eseguibile. Non deve essere specificato in Java™.

Autorizzazione per DECLARE CURSOR

Per ogni tabella o vista identificata nell'istruzione SELECT del cursore, il set di privilegi deve includere almeno uno dei seguenti elementi:

• Il privilegio SELECT
• La proprietà dell'oggetto
• Autorità DBADM per il database corrispondente (solo tabelle)
• Autorizzazione SYSADM
• Autorità SYSCTRL (solo tabelle catalogo)
• Autorizzazione DATAACCESS

Se l'istruzione select contiene un'istruzione SQL di modifica dei dati, i requisiti di autorizzazione di tale istruzione si applicano anche all'istruzione DECLARE CURSOR.

L'istruzione SELECT del cursore è una delle seguenti:

• L'istruzione select preparata identificata da statement-name
• L'istruzione select specificata

Se viene specificato statement-name:

• Il set di privilegi è determinato dal comportamento DYNAMICRULES in vigore (eseguire, associare, definire o invocare) ed è riassunto nella Tabella 1. (Per ulteriori informazioni su questi comportamenti, compreso un elenco dei valori dell'opzione di binding DYNAMICRULES che li determinano, vedere ID autorizzazione e SQL dinamico )
• Il controllo dell'autorizzazione viene eseguito quando viene preparata l'istruzione SELECT.
• Il cursore non può essere aperto se l'istruzione SELECT non è stata preparata correttamente.

Se è specificata l'istruzione select:

• Il set di privilegi è costituito dai privilegi detenuti dall'ID di autorizzazione del proprietario del piano o del pacchetto.
• Se il piano o il pacchetto viene associato con VALIDATE(BIND), il controllo dell'autorizzazione viene eseguito al momento dell'associazione e l'associazione non va a buon fine se non esiste alcun privilegio richiesto.
• Se il piano o il pacchetto è associato a VALIDATE(RUN), al momento dell'associazione viene eseguito un controllo di autorizzazione, ma non è necessario che tutti i privilegi richiesti esistano in quel momento. Se tutti i privilegi esistono al momento del binding, non viene eseguito alcun controllo dell'autorizzazione quando il cursore viene aperto. Se un privilegio non esiste al momento del binding, viene eseguito un controllo dell'autorizzazione la prima volta che il cursore viene aperto all'interno di un'unità di lavoro. L'OPEN non ha successo se non esiste alcun privilegio richiesto.

descrizione per DECLARE CURSOR

nome-cursore

Denomina il cursore. Il nome non deve identificare un cursore già dichiarato nel programma sorgente. Il nome è solitamente VARCHAR(128); tuttavia, se il cursore è definito CON RITORNO, il nome è limitato a VARCHAR(30).

NO SCROLL o SCROLL

Specifica se il cursore è scorrevole o non scorrevole.

NESSUNO SCORRIMENTO

Specifica che il cursore non è scorrevole. Questa è l'impostazione predefinita.

Scorri

Specifica che il cursore è scorrevole. Per un cursore scorrevole, la sensibilità del cursore agli inserimenti, agli aggiornamenti o alle eliminazioni dipende dall'opzione di sensibilità del cursore in vigore per il cursore. Se non viene specificata un'opzione di sensibilità, ASENSITIVE è l'impostazione predefinita.

SENSIBILE

Specifica che il cursore deve essere il più sensibile possibile. Questa è l'impostazione predefinita.

Un cursore definito come ASENSITIVE sarà dinamico insensibile o sensibile; non sarà statico sensibile. Per informazioni su come la sensibilità effettiva del cursore viene restituita all'applicazione con l'istruzione GET DIAGNOSTICS o nell'SQLCA, vedere l'istruzione OPEN.

La sensibilità di un cursore è un fattore nella scelta del percorso di accesso. Specificare esplicitamente il livello di sensibilità necessario, invece di specificare ASENSITIVE.

INSENSIBILE

Specifica che il cursore non è sensibile agli inserimenti, agli aggiornamenti o alle eliminazioni effettuati nelle righe sottostanti la tabella dei risultati. Di conseguenza, le dimensioni della tabella dei risultati, l'ordine delle righe e i valori di ciascuna riga non cambiano dopo l'apertura del cursore. Inoltre, il cursore è di sola lettura. L'istruzione SELECT o la stringa di attributi dell'istruzione PREPARE non può contenere una clausola FOR UPDATE e il cursore non può essere utilizzato per aggiornamenti o cancellazioni posizionate.

Sensibile

Specifica che il cursore è sensibile alle modifiche apportate al database dopo la materializzazione della tabella dei risultati. Il cursore è sempre sensibile agli aggiornamenti e alle eliminazioni effettuati utilizzando il cursore (ovvero, aggiornamenti e eliminazioni posizionati utilizzando lo stesso cursore). Quando il valore corrente di una riga non soddisfa più l'istruzione select o statement-name, quella riga non è più visibile attraverso il cursore. Quando una riga della tabella dei risultati viene eliminata dalla tabella di base sottostante, la riga non è più visibile attraverso il cursore.

Se Db2 non riesce a rendere visibili le modifiche al cursore, viene generato un errore al momento del binding per OPEN CURSOR. Db2 non può rendere visibili le modifiche al cursore quando il cursore diventa implicitamente di sola lettura. Ad esempio, quando la tabella dei risultati deve essere materializzata, come quando la clausola FROM dell'istruzione SELECT contiene più di una tabella o vista. L'elenco attuale delle condizioni che determinano un cursore di sola lettura implicito è disponibile in Cursori di sola lettura.

L'impostazione predefinita è DYNAMIC.

DYNAMIC

Specifica che la tabella dei risultati del cursore è dinamica, il che significa che la dimensione della tabella dei risultati potrebbe cambiare dopo l'apertura del cursore, poiché le righe vengono inserite o eliminate dalla tabella sottostante, e l'ordine delle righe potrebbe cambiare. Le righe che vengono inserite, cancellate o aggiornate da istruzioni eseguite dallo stesso processo applicativo del cursore sono immediatamente visibili al cursore. Le righe che vengono inserite, cancellate o aggiornate da istruzioni eseguite da altri processi applicativi sono visibili solo dopo che le istruzioni sono state eseguite. Se una colonna per una clausola ORDER BY viene aggiornata tramite un cursore o qualsiasi altro mezzo esterno al processo, la successiva istruzione FETCH si comporta come se la riga aggiornata fosse stata eliminata e reinserita nella tabella dei risultati nella sua posizione corretta. Al momento di un aggiornamento posizionato, il cursore viene posizionato prima della riga successiva della posizione originale e non c'è alcuna riga corrente, facendo sembrare che la riga si sia spostata.

Se non è possibile un cursore DINAMICO SENSIBILE, viene restituito un errore. Ad esempio, se è necessario un tavolo temporaneo, viene restituito un errore. L'istruzione SELECT di un cursore definito come SENSITIVE DYNAMIC non può contenere un'istruzione SQL di modifica dei dati.

La clausola offset e la clausola fetch non devono essere specificate per la fullselect più esterna per un cursore dinamico sensibile.

STATIC

Specifica che le dimensioni della tabella dei risultati e l'ordine delle righe non cambiano dopo l'apertura del cursore. Le righe inserite nella tabella sottostante non vengono aggiunte alla tabella dei risultati, indipendentemente da come vengono inserite. Le righe nella tabella dei risultati non si spostano se le colonne nella clausola ORDER BY vengono aggiornate in righe che sono già state materializzate. Gli aggiornamenti e le cancellazioni posizionate sono consentiti se la tabella dei risultati è aggiornabile. L'istruzione SELECT di un cursore definito come SENSITIVE STATIC non può contenere un'istruzione SQL di modifica dei dati.

Un cursore STATICO ha visibilità delle modifiche apportate da questo cursore utilizzando aggiornamenti o eliminazioni posizionate. Le modifiche apportate al di fuori di questo cursore sono visibili con l'opzione SENSITIVE dell'istruzione FETCH. Un FETCH SENSITIVE può provocare un buco nella tabella dei risultati (ovvero una differenza tra la tabella dei risultati e la tabella di base sottostante). Se una riga aggiornata nella tabella base di un cursore non soddisfa più il predicato della sua istruzione SELECT, si verifica un buco di aggiornamento nella tabella dei risultati. Se una riga di un cursore è stata eliminata nella tabella base, si verifica un buco di eliminazione nella tabella dei risultati. Quando un FETCH SENSITIVE rileva un aggiornamento, non vengono restituiti dati (viene emesso un avviso) e il cursore viene lasciato posizionato sull'aggiornamento. Quando un FETCH SENSITIVE rileva un foro di cancellazione, non vengono restituiti dati (viene emesso un avviso) e il cursore viene posizionato a sinistra sul foro di cancellazione.

Gli aggiornamenti tramite cursore comportano un nuovo recupero automatico della riga. Questo re-fetch significa che gli aggiornamenti possono creare essi stessi un buco. La riga recuperata riflette anche le modifiche derivanti dall'aggiornamento della stessa riga da parte di trigger. È importante riflettere questi cambiamenti per mantenere la coerenza dei dati nella riga.

L'utilizzo di una funzione non deterministica (integrata o definita dall'utente) nella clausola WHERE dell'istruzione select o statement-name di un cursore SENSITIVE STATIC può causare risultati fuorvianti. Questa situazione si verifica perché l' Db2 e costruisce una tabella dei risultati temporanea e recupera le righe da questa tabella per le istruzioni FETCH INSENSITIVE. Quando un Db2 e elabora un'istruzione FETCH SENSITIVE, le righe vengono recuperate dalla tabella sottostante e i predicati vengono rivalutati. L'utilizzo di una funzione non deterministica può produrre un risultato diverso su ogni FETCH SENSITIVE della stessa riga, il che potrebbe anche far sì che la riga non venga più considerata una corrispondenza.

Un FETCH INSENSITIVE su un cursore STATICO SCORREVOLE SENSITIVE non è sensibile alle modifiche apportate al di fuori del cursore, a meno che un precedente FETCH SENSITIVE non abbia già aggiornato quella riga; tuttavia, gli aggiornamenti posizionati e le modifiche di eliminazione con il cursore sono visibili.

I cursori STATICI non sono sensibili agli inserimenti.

SENZA o CON HOLD

Specifica se si deve impedire la chiusura del cursore in seguito a un'operazione di conferma.

SENZA SOSTEGNO

Non impedisce la chiusura del cursore in seguito a un'operazione di conferma. Questa è l'impostazione predefinita.

CON RITENZIONE

Impedisce la chiusura del cursore in seguito a un'operazione di conferma. Un cursore dichiarato con WITH HOLD viene chiuso al momento del commit se si verifica una delle seguenti condizioni:

• La connessione associata al cursore è in stato di rilascio in attesa.
• L'opzione di binding DISCONNECT(AUTOMATIC) è attiva.
• L'ambiente è uno in cui l'opzione CON RITARDO viene ignorata.

Quando viene specificato WITH HOLD, un'operazione di commit esegue il commit di tutte le modifiche nell'unità di lavoro corrente. Ad esempio, con un cursore non scorrevole, è necessaria un'istruzione FETCH iniziale dopo un'istruzione COMMIT per posizionare il cursore sulla riga che segue quella su cui era posizionato prima dell'operazione di commit.

WITH HOLD non ha alcun effetto su un'istruzione SQL di modifica dei dati all'interno di un'istruzione SELECT. Quando viene emesso un COMMIT, le modifiche causate dall'istruzione SQL data change vengono confermate, indipendentemente dal fatto che il cursore sia dichiarato WITH HOLD o meno.

Tutti i cursori vengono implicitamente chiusi da un'operazione di connessione (tipo 1) o di rollback. Un cursore viene implicitamente chiuso anche da un'operazione di commit se WITH HOLD viene ignorato o non specificato.

I cursori dichiarati con WITH HOLD in programmi non guidati da messaggi ( CICS® ) o in programmi non guidati da messaggi ( IMS ) non verranno chiusi da un'operazione di rollback se il cursore è stato aperto in un'unità di lavoro precedente e non sono state apportate modifiche al database nell'unità di lavoro corrente. Il cursore non può essere chiuso perché CICS e IMS non trasmettono la richiesta di rollback a Db2 per un'unità di lavoro nulla.

Se un cursore viene chiuso prima dell'operazione di conferma, l'effetto è lo stesso che se il cursore fosse stato dichiarato senza l'opzione WITH HOLD.

WITH HOLD viene ignorato nei programmi basati su messaggi ( IMS, IFP e BMP basati su messaggi). WITH HOLD mantiene la posizione del cursore in un programma pseudo-conversazionale ( CICS ) fino alla fine dell'attività (EOT).

Per i dettagli sulle restrizioni che si applicano alla dichiarazione dei cursori con WITH HOLD, vedere Cursori trattenuti e non trattenuti.

WITHOUT RETURN oppure WITH RETURN

Specifica se la tabella dei risultati del cursore è destinata a essere utilizzata come un insieme di risultati che verrà restituito da una procedura. Se viene specificato statement-name, il valore predefinito è l'attributo prepare corrispondente dell'istruzione. Altrimenti, l'impostazione predefinita è WITHOUT RETURN.

WITHOUT RETURN

Specifica che la tabella dei risultati del cursore non è destinata ad essere utilizzata come un insieme di risultati che verrà restituito da una procedura.

WITH RETURN

Specifica che la tabella dei risultati del cursore è destinata ad essere utilizzata come un insieme di risultati che verrà restituito da una procedura. CON RITORNO è rilevante solo se l'istruzione DECLARE CURSOR è contenuta nel codice sorgente di una procedura. In altri casi, il precompilatore potrebbe accettare la clausola, ma non ha effetto.

Quando un cursore dichiarato utilizzando la clausola WITH RETURN TO CALLER rimane aperto alla fine di un programma o di una routine, tale cursore definisce un insieme di risultati dal programma o dalla routine. Utilizzare l'istruzione CLOSE per chiudere un cursore che non è destinato a essere un insieme di risultati dal programma o dalla routine. Sebbene Db2 chiuda automaticamente tutti i cursori che non sono dichiarati utilizzando una clausola WITH RETURN, si consiglia l'uso dell'istruzione CLOSE per aumentare la portabilità delle applicazioni.

Per i cursori non scorrevoli, il risultato è costituito da tutte le righe dalla posizione corrente del cursore alla fine della tabella dei risultati. Per i cursori scorrevoli, il set di risultati è costituito da tutte le righe della tabella dei risultati.

TO CALLER

Specifica che il cursore può restituire un risultato impostato al chiamante della procedura. Il chiamante è il programma o la routine che ha eseguito l'istruzione SQL CALL che richiama la procedura che contiene l'istruzione DECLARE CURSOR. Ad esempio, se il chiamante è una procedura, il risultato impostato viene restituito alla procedura. Se il chiamante è un'applicazione client, il risultato viene restituito all'applicazione client.

Se l'istruzione è contenuta nel codice sorgente di una procedura, WITH RETURN TO CALLER specifica che il cursore può essere utilizzato come cursore del set di risultati. Un cursore impostato sul risultato viene utilizzato quando la tabella dei risultati di un cursore deve essere restituita da una procedura. Specificare TO CALLER è facoltativo.

In altri casi, la clausola viene ignorata e il cursore non può essere utilizzato come cursore di risultato.

TO CLIENT

Specifica che il cursore può restituire un risultato impostato all'applicazione client. Questo cursore è invisibile a qualsiasi procedura nidificata intermedia. Se una funzione o un trigger richiama la procedura (direttamente o indirettamente), il risultato non può essere restituito al client e il cursore verrà chiuso al termine della procedura.

posizionamento del set di file

Specifica se è possibile accedere a più righe di dati come un insieme di righe in un'unica istruzione FETCH per il cursore. L'impostazione predefinita è SENZA POSIZIONAMENTO DELLA FILA.

SENZA POSIZIONAMENTO DELLA CATENA DI TRASMISSIONE

Specifica che il cursore può essere utilizzato solo con istruzioni FETCH posizionate in riga. Il cursore deve restituire una singola riga per ogni istruzione FETCH e la clausola FOR n ROWS non può essere specificata su un'istruzione FETCH per questo cursore. SENZA POSIZIONAMENTO RIGA o accesso a riga singola si riferisce a come i dati vengono recuperati dal motore del database. Per l'accesso remoto, i dati potrebbero essere bloccati e restituiti al cliente in blocchi.

CON POSIZIONAMENTO DELLA FILA

Specifica che il cursore può essere utilizzato con istruzioni FETCH posizionate su riga o su insieme di righe. Questo cursore può essere utilizzato per restituire una singola riga o più righe, come un insieme di righe, con una singola istruzione FETCH. Il POSIZIONAMENTO DELLE RIGHE si riferisce a come i dati vengono recuperati dal motore del database. Per l'accesso remoto, se una riga è idonea, almeno 1 riga viene restituita come set di righe. La dimensione del set di righe dipende dal numero di righe specificato nell'istruzione FETCH e dal numero di righe che soddisfano i criteri. I dati potrebbero essere bloccati e restituiti al cliente in blocchi.

Db2 Le applicazioni REXX non supportano i cursori dichiarati CON ROWSET POSITIONING. Per consentire l'uso di un cursore per un'istruzione SELECT in un'applicazione REXX di Oracle ( Db2 ) con istruzioni FETCH posizionate su riga o su insieme di righe, specificare WITH ROWSET POSITIONING nella stringa di attributi dell'istruzione PREPARE per l'istruzione SELECT.

istruzione select

Specifica la tabella dei risultati del cursore. Vedere l'istruzione select per una spiegazione dell 'istruzione select.

L'istruzione select non deve includere marcatori di parametro (tranne che per REXX), ma può includere riferimenti a variabili host. Nelle lingue host, diverse da REXX, le dichiarazioni delle variabili host devono precedere l'istruzione DECLARE CURSOR nel programma sorgente. In REXX, i marcatori di parametro devono essere utilizzati al posto delle variabili host e l'istruzione deve essere preparata.

La clausola USING dell'istruzione OPEN può essere utilizzata per specificare variabili host che sostituiranno i valori delle variabili host o dei marcatori di parametri specificati come parte dell'istruzione nell'istruzione DECLARE CURSOR.

L'istruzione select non deve contenere un'istruzione SQL di modifica dei dati se il cursore è definito come SENSITIVE DYNAMIC o SENSITIVE STATIC.

L'istruzione select non deve contenere un select completo che sia una clausola VALUES.

L'elenco di selezione esterno dell'istruzione select di un cursore scorrevole non deve essere un valore array.

dichiarazione-nome

Identifica l'istruzione select preparata che specifica la tabella dei risultati del cursore ogni volta che il cursore viene aperto. Il nome dell'istruzione non deve essere identico al nome di un'istruzione specificata in un'altra istruzione DECLARE CURSOR del programma sorgente. Per una spiegazione delle istruzioni SELECT preparate, vedere l'istruzione PREPARE.

L'istruzione select preparata non deve contenere un'istruzione SQL di modifica dei dati se il cursore è definito come SENSITIVE DYNAMIC o SENSITIVE STATIC.

Note per DECLARE CURSOR

Un cursore in stato aperto indica una tabella dei risultati e una posizione relativa alle righe di tale tabella. La tabella è la tabella dei risultati specificata dall'istruzione SELECT del cursore.

Cursori di sola lettura:

Se la tabella dei risultati è di sola lettura, anche il cursore è di sola lettura. Il cursore che fa riferimento a una vista con invece di trigger è di sola lettura poiché non è consentito utilizzare tali cursori con istruzioni UPDATE e DELETE posizionate. La tabella dei risultati è di sola lettura se una o più delle seguenti istruzioni sono vere riguardo all'istruzione di selezione del cursore:

• La prima clausola FROM identifica o contiene uno dei seguenti elementi:
  • Più di una tabella o vista
  • Una tabella di catalogo senza colonne aggiornabili
  • Una vista di sola lettura
  • Un'espressione tabella nidificata
  • Una funzione tabella
  • Una tabella di query materializzata mantenuta dal sistema
  • Viene utilizzato un singolo tavolo che è un tavolo temporale di periodo di sistema e una specifica di periodo per SYSTEM_TIME
  • Viene utilizzata una singola vista che fa riferimento, direttamente o indirettamente, a una tabella temporale del periodo di sistema nella clausola FROM della fullselect esterna della definizione della vista e una specifica del periodo per SYSTEM_TIME
• La prima clausola SELECT specifica la parola chiave DISTINCT, contiene una funzione di aggregazione o utilizza entrambe
• Contiene un'istruzione SQL per la modifica dei dati
• La sottoquery esterna contiene una clausola GROUP BY, una clausola HAVING o entrambe le clausole
• Contiene una sottoquery in modo tale che l'oggetto base della sottoquery esterna e della sottoquery sia la stessa tabella
• Sono specificati uno qualsiasi dei seguenti operatori o clausole:
  • Un operatore di set
  • Una clausola ORDER BY (tranne quando il cursore è dichiarato come scorrevole SENSITIVE STATIC)
  • Una clausola SOLO LETTURA
• Viene eseguito con livello di isolamento UR e non è specificata una clausola FOR UPDATE.
• È una clausola VALUES.

Se la tabella dei risultati non è di sola lettura, il cursore può essere utilizzato per aggiornare o cancellare le righe sottostanti della tabella dei risultati.

Colonne di riferimento che verranno aggiornate:

Se un cursore utilizza istruzioni FETCH per recuperare colonne che verranno aggiornate in seguito, specificare FOR UPDATE OF quando si selezionano le colonne. Quindi specificare WHERE CURRENT OF nelle successive istruzioni UPDATE o DELETE. Queste clausole impediscono a Db2 di selezionare l'accesso attraverso un indice sulle colonne che vengono aggiornate, il che potrebbe altrimenti causare a Db2 di leggere la stessa riga più di una volta.

Per ulteriori informazioni, vedere Aggiornamento dei dati recuperati in precedenza.

Tabelle per le quali sono applicati controlli di accesso a righe o colonne:

L'istruzione select del cursore può fare riferimento a una tabella per la quale sono applicati controlli di accesso a righe o colonne. I controlli di accesso a riga o colonna non influiscono sulla determinazione del fatto che il cursore sia di sola lettura e non influiscono sulla sensibilità del cursore.

Requisiti del database dei file di lavoro per i cursori statici scorrevoli:

Per utilizzare un cursore a scorrimento statico, è necessario innanzitutto creare un database di file di lavoro e almeno uno spazio tabella con una dimensione di pagina di 32KB in questo database, poiché un cursore a scorrimento statico richiede una tabella temporanea per la sua tabella dei risultati mentre il cursore è aperto. Db2 sceglie uno spazio della tabella da utilizzare per la tabella dei risultati temporanea. I cursori a scorrimento dinamico non richiedono una tabella temporanea dichiarata.

Per le dichiarazioni di cursori scorrevoli statici che contengono stringhe vuote, l' Db2 e assegna un byte nello spazio della tabella temporanea per ogni stringa vuota. L'esempio seguente mostra una dichiarazione di cursore scorrevole con una stringa vuota:

EXEC SQL DECLARE CSROWSTAT SENSITIVE STATIC SCROLL CURSOR
  WITH ROWSET POSITIONING WITH HOLD FOR
  SELECT ID1,'' 
  FROM TB;  

Cursori nei programmi COBOL e Fortran :

Nei programmi sorgente COBOL e Fortran, l'istruzione DECLARE CURSOR deve precedere tutte le istruzioni che fanno riferimento esplicito al cursore per nome. Questa regola non si applica necessariamente alle altre lingue host perché il precompilatore fornisce un'opzione a due passaggi per queste lingue. Questa regola si applica alle altre lingue host se non si utilizza l'opzione a due passaggi.

Cursori in REXX:

Se le variabili host sono utilizzate in un'istruzione DECLARE CURSOR all'interno di una procedura REXX, l'istruzione DECLARE CURSOR deve essere oggetto di un PREPARE e di un EXECUTE.

Portata di un cursore:

L'ambito di cursor-name è il programma sorgente in cui è definito, ovvero il programma applicativo inviato al precompilatore. Pertanto, è possibile fare riferimento a un cursore solo tramite istruzioni precompilate con la dichiarazione del cursore. Ad esempio, un programma COBOL chiamato da un altro programma non può utilizzare un cursore aperto dal programma chiamante. Inoltre, un cursore definito in un sottoprogramma dell' Fortran e può essere richiamato solo in quel sottoprogramma. I cursori che specificano WITH RETURN in una procedura e vengono lasciati aperti vengono restituiti come set di risultati.

Sebbene l'ambito di un cursore sia il programma in cui è dichiarato, ogni pacchetto (o DBRM di un piano) creato dal programma include un'istanza separata del cursore, e più di un'istanza del cursore può essere utilizzata nella stessa esecuzione del programma. Ad esempio, supponiamo che un programma sia precompilato con l'opzione CONNECT(2) e che il suo DBRM sia utilizzato per creare un pacchetto nella posizione X e un pacchetto nella posizione Y. Il programma contiene le seguenti istruzioni SQL:

  DECLARE C CURSOR FOR ...
  CONNECT TO X
  OPEN C
  FETCH C INTO ...
  CONNECT TO Y
  OPEN C
  FETCH C INTO ...

La seconda istruzione OPEN C non causa un errore perché si riferisce a un'istanza diversa del cursore C. Lo stesso vale per una singola località se i colli sono in collezioni diverse.

Un'istruzione SELECT viene valutata nel momento in cui viene aperto il cursore. Se lo stesso cursore viene aperto, chiuso e poi riaperto, i risultati possono essere diversi. Se l'istruzione SELECT del cursore contiene CURRENT DATE, CURRENT TIME o CURRENT TIMESTAMP, tutti i riferimenti a questi registri speciali producono lo stesso rispettivo valore data-ora in ogni operazione FETCH. Il valore viene determinato quando il cursore viene aperto. È possibile aprire contemporaneamente più cursori utilizzando la stessa istruzione SELECT. Sono considerate attività indipendenti.

Blocco dei dati:

Per elaborare i dati in modo più efficiente, l' Db2 e potrebbe bloccare i dati per i cursori di sola lettura. Se non si intende utilizzare un cursore in un'istruzione UPDATE o DELETE posizionata, definire il cursore come SOLO LETTURA.

Posizionato cancella e livello di isolamento UR:

Specificare FOR UPDATE se si desidera utilizzare il cursore per un DELETE posizionato e il livello di isolamento è UR a causa di un'opzione BIND. In questo caso, il livello di isolamento è CS.

Restituzione di un risultato impostato da una procedura memorizzata:

Un cursore dichiarato in una stored procedure restituisce un risultato quando tutte le seguenti condizioni sono vere:

• Il cursore viene dichiarato con l'opzione WITH RETURN. In un ambiente distribuito, i blocchi di ogni risultato dei dati del cursore vengono restituiti con la risposta dell'istruzione CALL.
• Il cursore rimane aperto dopo l'uscita dalla procedura memorizzata. Un cursore dichiarato con l'opzione SCROLL deve essere lasciato posizionato prima della prima riga prima di uscire dalla procedura memorizzata.
• Il cursore viene dichiarato con l'opzione WITH HOLD se la procedura memorizzata è definita per eseguire il commit al ritorno.

Il risultato è l'insieme di tutte le righe dopo la posizione corrente del cursore dopo l'uscita dalla procedura memorizzata. Si presume che il set di risultati sia di sola lettura. Se la stessa procedura viene richiamata di nuovo, i cursori di set di risultati aperti per una procedura memorizzata in un determinato sito vengono chiusi automaticamente dal sistema di gestione del database.

Cursori scorrevoli specificati con funzioni definite dall'utente:

Una riga può essere recuperata più di una volta con un cursore scorrevole. Pertanto, se un cursore scorrevole è definito con una funzione che non è deterministica nella lista di selezione del cursore, una riga può essere recuperata più volte con risultati diversi per ogni recupero. (Tuttavia, il valore di una funzione che non è deterministica nella clausola WHERE di un cursore scorrevole viene acquisito quando il cursore viene aperto e rimane invariato fino a quando il cursore viene chiuso) Allo stesso modo, se un cursore scorrevole è definito con una funzione definita dall'utente con azione esterna, l'azione viene eseguita ad ogni richiamo.

Casi multipli di un cursore definito con RETURN TO CLIENT:

Se il cursore è dichiarato in una procedura SQL nativa, un cursore dichiarato come WITH RETURN TO CLIENT può essere aperto anche quando un cursore con lo stesso nome è già nello stato aperto. In questo caso, il cursore già aperto diventa un cursore di risultato e non è più accessibile utilizzando il suo nome. Viene aperto un nuovo cursore, accessibile tramite il nome del cursore. Quando viene emessa un'istruzione CLOSE, l'ultima istanza del cursore verrà chiusa. La chiusura del nuovo cursore non rende nuovamente accessibile il cursore precedentemente accessibile con quel nome. I cursori che diventano in questo modo cursori di set di risultati non sono accessibili sul server e possono essere elaborati solo sul client.