Riferimento Lingua del Tivoli Service Desk 6.0 Developer's Toolkit Script

Manipolazione SQL

Ritorna alla pagina principale


SQLBeginWork

Descrizione

Avvia una transazione.

Sintassi

FUNCTION SQLBeginWork: INTEGER;

Note

Il TSD Script generalmente esegue il commit di ogni istruzione SQL dopo il completamento avvenuto con esito positivo. Tuttavia si può desiderare che una serie di istruzioni SQL vengano sottoposte, insieme, a commit o a rollback. SQLBeginWork sospende il commit automatico di ogni istruzione SQL fino a quando non si effettua una chiamata a SQLCommit o a SQLRollBack.

Dopo un commit o un rollback, la transazione termina e il TSD Script riprende il commit automatico. SQLBeginWork deve essere nuovamente richiamato per avviare un'altra transazione.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
ok : BOOLEAN;
ACTIONS
(* start the transaction (transaction) ==> this disables the
 normal
 automatic committing after every SQL operation *)
  SQLBeginWork;
(* do your work here ok := .... *)
IF ok THEN
 SQLCommit; (* save changes since SQLBeginWork *)
      ELSE
 SQLRollBack; (* reverse changes since SQLBeginWork *)
          END;
(* After a commit or rollback the transaction will be
 terminated. *)
(* Call SQLBeginWork again to start the next transaction if
 you don't *)
(* want the automatic committing *)
END; --Test--

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLCloseAll

Descrizione

Chiude i cursori aperti e le istruzioni preparate e scollega le connessioni DBMS aperte.

Sintassi

FUNCTION SQLCloseAll: INTEGER;

Note

Sebbene non sia richiesto, è possibile richiamare questa routine prima di uscire dal file .kb principale. Questo esegue il commit delle transazioni in corso.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
ACTIONS
(* perform some SQL operations... *)
SQLCloseAll;
          END;

Codici di ritorno

Codici di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLCloseCursor

Descrizione

Chiude un cursore precedentemente aperto attraverso una chiamata a SQLSelect.

Sintassi

FUNCTION SQLCloseCursor(cursor: SQLCURSOR): INTEGER;

Attenzione: Un'operazione di rollback chiude tutti i cursori (consultare SQLRollBack).

La maggior parte dei driver non consentono di specificare i cursori che possono espandere le unità di lavoro (ad esempio, dichiararle con WITH HOLD). Un'eccezione consiste nel driver CLI DB2. Dopo un'operazione di commit tutti i cursori vengono chiusi. Tuttavia, se si eseguono le operazioni SQL (come ad esempio gli aggiornamenti) in un loop fetch, è necessario disabilitare il commit automatico dopo ogni istruzione SQL.

Nota: E' necessario chiudere tutti i cursori prima di eseguire un'operazione di commit o di rollback.

Note argomento

Nome dell'argomento Descrizione
cursore Questo è il parametro di tipo SQLCursor impostato da una precedente chiamata a SQLSelect.

Note

Dopo il completamento, SQLCloseCursor imposta il cursore su $Unknown. Una chiamata a SQLCloseCursor con un cursore chiuso in precedenza termina con un errore. Nessun messaggio di errore visualizzato.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
   retCd : INTEGER;
ACTIONS
(* select all employees *)
retCd := SQLSelect(cursor,'* from emp');
IF (retCd < 0) THEN
      EXIT retCd;
          END;
 retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* perform some operations based on this row...
 .
 .
 .
 *)
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
(* now close the cursor *)
  SQLCloseCursor(cursor);
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Il cursore è stato chiuso con esito positivo
(altro) Consultare il manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Scripte

Consultare anche


SQLCloseStatement

Descrizione

Chiude un'istruzione precedentemente aperta (preparata) tramite SQLPrepare.

Sintassi

FUNCTION SQLCloseStatement(statement: SQLSTATEMENT): INTEGER;

Avvertenze

Un'operazione rollback chiude tutte le istruzioni preparate. Un'operazione di commit chiude tutte le istruzioni preparate che non fanno riferimento ad un cursore aperto.

Nota: E' necessario chiudere manualmente tutte le istruzioni coinvolte con SQLCloseStatement prima di eseguire un commit o un rollback.

Note argomento

Nome dell'argomento Descrizione
statement Il parametro dell'istruzione viene inizializzato da una chiamata a SQLPrepare

Note

SQLCloseStatement viene supportata da tutti i driver. Dopo il completamento, SQLCloseStatement imposta l'istruzione su $Unknown.

Una chiamata a SQLCloseStatement con un'istruzione chiusa precedentemente termina con un errore. Nessun messaggio di errore visualizzato.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER IS
VARIABLES
  stmt: SQLStatement;
   retCd : INTEGER;
ACTIONS
SQLBeginWork
   (* insert the user names passed in *)
 retCd := SQLPrepare(stmt,'INSERT INTO USERS VALUES (?)');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate the transaction *)
      EXIT retCd;
          END;
   FOR users DO
    retCd := SQLExecute(stmt,users[$current]);
   IF retCd < 0 THEN
  SQLCloseStatement(stmt);
 SQLRollBack; (* reverse changes and release locks *)
      EXIT retCd;
          END;
   END; (* for *)
 (* close the prepared statement *)
  SQLCloseStatement(stmt);
 SQLCommit; (* save changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLCommand

Descrizione

Emette comandi non SQL, dipendenti dall'implementazione all'interprete SQL.

Sintassi

FUNCTION SQLCommand(sub_command: STRING): INTEGER;

Note argomento

Nome dell'argomento Descrizione
sub_command La stringa comandi è composta da due parti: la prima parte è il sottocomando del gestore del database; la seconda parte contiene i parametri per questo comando. Il comando è sensibile al maiuscolo e minuscolo. Tutti i parametri sono separati da spazi vuoti. Consultare la seguente sezione per i sottocomandi disponibili.

Note

Sottocomandi SQLCommand

Come mostrato nella tabella, esistono diversi sottocomandi per l'istruzione SQLCommand.

Diversi sottocomandi richiedono connection_handle_string. Per specificare il database origine al momento selezionato, è possibile inoltrare $Current. Alternativamente, se non si specifica nulla, viene utilizzato il database origine al momento selezionato.

Per richiamare una stringa dell'handle di connessione, richiamare SQLCommand con il sottocomando GET CURRENT CONNECTION. Il valore di ritorno intero può essere assegnato ad una stringa. Questa stringa è connection_handle_string.

Esistono inoltre diversi sottocomandi che specificano un source_name. (I parametri del nome origine sono sempre facoltativi.) Per specificare l'origine alla quale si è al momento collegati, è possibile inoltrare $Current. Per specificare l'origine dati di default, è possibile inoltrare $Default. Se non viene specificato alcun nome origine, si utilizza $Current.

La seguente tabella mostra i sottocomandi per SQLCommand ('<sub_command>'), i parametri e le descrizioni. I valori nella colonna Parametri vengono forniti dall'utente.

Sottocomando Parametro Descrizione
CONNECT connect_string Apre una connessione con il DBMS. Questo comando deve essere richiamato prima di ogni operazione SQL. Generalmente è una delle prime istruzioni richiamate dall'applicazione dell'utente. Se non si fornisce connect_string, viene stabilito un collegamento con l'origine dati di default. Dopo un collegamento riuscito, questo diviene il collegamento al momento selezionato.
DISCONNECT connection_handle_string Scollega dal collegamento al quale connection_handle_string fa riferimento. L'handle della connessione è un intero che è possibile ottenere richiamando SQLCommand (GET CURRENT CONNECTION) immediatamente dopo la connessione.
GET CASE CONVERSION source_name Restituisce la modalità di conversione del caso per i nomi degli oggetti (non per i dati):
0 = none
1 = upper
2 = lower
Un codice di ritorno negativo indica un errore.
GET CASE SENSITIVITY source_name Indica al Tivoli Service Desk Developer's Toolkit se il DBMS dispone di nomi oggetti sensibili al maiuscolo e minuscolo (come ad esempio i nomi colonna, i nomi tabelle e così via). Questo non si applica ai dati (sebbene con alcuni DBMS, come ad esempio SQLServer, i nomi degli oggetti e i dati sensibili al maiuscolo e minuscolo coesistono).
I valori di ritorno possibili sono:
0 = non sensibili al maiuscolo e minuscolo
1 = sensibili al maiuscolo e minuscolo
GET CATALOG CASE CONVERSION source_name Restituisce la modalità di conversione del caso (maiuscolo o minuscolo) per i dati contenuti nelle tabelle del catalogo di sistema:
0 = none
1 = upper
2 = lower
Un valore di ritorno negativo indica un errore.
GET CHECK DRIVER source_name Restituisce TRUE se (quando ci si collega) viene eseguito un controllo per determinare se il driver (ad esempio, CDSS06.DLL) è uno dei driver non supportati; in caso contrario restituisce FALSE.
GET CURRENT CONNECTION source_name Restituisce un handle di connessione intero per la connessione al momento selezionata. Se si riceve un codice di errore inferiore a zero, consultare la pagina Definizione codici di errore SQL per ulteriori informazioni.
GET CURRENT ODBC HENV Restituisce l'handle dell'ambiente ODBC attuale utilizzato dal Tivoli Service Desk Developer's Toolkit. Questo si applica solo quando si utilizzano i driver ODBC. Un valore di ritorno negativo indica un errore.
GET CURRENT ODBC HDBC Restituisce l'handle di connessione ODBC corrente per la connessione principale attuale del Tivoli Service Desk Developer's Toolkit. Questo si applica solo quando si utilizzano i driver ODBC. Un valore di ritorno negativo indica un errore.
GET DATE FORMAT source_name Restituisce il formato della data corrente per il DBMS.
GET DBMS source_name Restituisce il codice intero per il DBMS dell'origine denominata source_name. I possibili valori di ritorno sono: 0 o 2 (DB2/); 1 (Oracle); 3, 23, o 24 (SQLServer); 4 o 12 (SYBASE); e 16 o 17 (INFORMIX).
GET IN TRANSACTION connection_handle Restituisce 1 se una transazione è in corso (in altre parole, SQLBeginWork è stato richiamato e SQLCommit o SQLRollback non sono stati ancora richiamati). Un codice di ritorno 0 indica che nessuna transazione è in corso. Un codice di ritorno negativo indica un errore.
GET MODULE Restituisce un codice intero per la libreria SQL che si sta utilizzando. Questo fornisce solo la compatibilità backward. I valori possibili dei codici di modulo sono: 2 = (Più piattaforme - X/OPEN e ODBC).
GET MODULE TYPE Restituisce il tipo di modulo corrente. Questo fornisce solo la compatibilità backward. I valori possibili sono: 5 = X/OPEN
Nota: Questo è simile al sottocomando GET MODULE, tranne che per il fatto che GET MODULE definisce l'ODBC per il Q+E versione 2 per la compatibilità backward.
GET MULTI CONNECT source_name Restituisce 1 se l'origine denominata source_name supporta più connessioni contemporaneamente.
GET SHOW WARNINGS source Restituisce TRUE se le caselle dei messaggi per le avvertenze sono abilitate; in caso contrario restituisce FALSE.
GET TIME FORMAT source_name Restituisce il formato dell'ora corrente per il DBMS.
GET UPDATE LOCK STYLE source_name Restituisce lo stile del bloccaggio corrente:
0 = none
1 = selezione per aggiornamento
2 = update
Un codice di ritorno negativo indica un errore.
GET UPDATE MODE source_name Restituisce la modalità di aggiornamento della simultaneità passiva. I valori possibili sono:
0 = none
1 = select
2 = DBMS optimistic
Un codice di ritorno negativo indica un errore.
RESTORE CURRENT QUALIFIER Sottopone a fetch il valore del qualificativo salvato per ultimo nell'insieme interno e lo trasforma nel qualificativo corrente per la connessione attuale.
RESTORE CURRENT SYSQUALIFIER Sottopone a fetch il valore del qualificativo della tabella del sistema salvato per ultimo nell'insieme interno e lo trasforma nel qualificativo del sistema corrente per la connessione attuale.
SAVE CURRENT QUALIFIER Memorizza il valore del qualificativo della tabella corrente per la connessione attuale nell'insieme interno.
SAVE CURRENT SYSQUALIFIER Memorizza il valore del qualificativo della tabella del sistema corrente per la connessione attuale in un insieme interno. Imposta la modalità di conversione del caso (maiuscolo o minuscolo) per in nomi degli oggetti (non per i dati). I valori validi per conversion sono: NONE, UPPER e LOWER.
SET CASE CONVERSION conversion
SET CASE SENSITIVITY true | false Indica al Tivoli Service Desk Developer's Toolkit se il DBMS corrente dispone di nomi oggetti sensibili al maiuscolo o minuscolo (come ad esempio i nomi delle tabelle, i nomi delle colonne e così via). Questo non si applica ai dati (sebbene con alcuni DBMS, come ad esempio SQLServer, i nomi degli oggetti e i dati sensibili al maiuscolo e minuscolo coesistono).
SET CATALOG CASE CONVERSION conversion Imposta la modalità di conversione del caso (maiuscolo o minuscolo) corrente nelle tabelle del catalogo di sistema. I valori validi per conversion sono UPPER, LOWER e NONE.
SET CHECK DRIVER true | false Imposta lo stato corrente per eseguire il controllo della convalida del driver.
SET CONNECTION connection_handle_string Imposta la connessione correntemente selezionata sull'handle a cui connection_handle_string fa riferimento.
SET CURRENT QUALIFIER qualifier Imposta il qualificativo della tabella sul qualificativo per la connessione correntemente selezionata.
SET CURRENT SYSQUALIFIER qualifier Imposta il qualificativo della tabella di sistema sul qualificativo per la connessione correntemente selezionata.
SET DBMS dbms Consente di sovrapporre il DBMS correntemente riconosciuto. (Consultare GET DBMS per un elenco di valori DBMS.)
SET SHOW WARNINGS true | false Imposta lo stato corrente per visualizzare le caselle dei messaggi di avvertenza.
SET UPDATE LOCK STYLE style Consente di impostare lo stile di blocco corrente in modo locale. I valori validi per style sono: NONE, SELECT FOR UPDATE e UPDATE.
SET UPDATE MODE none | select | dbms_optimistic Indica al Tivoli Service Desk Developer's Toolkit come eseguire la concorrenza passiva:
NONE - il record originale non viene paragonato al database. SELECT -esegue un SQL select del record e lo confronta con il record originale utilizzato nei meccanismi di concorrenza passiva per rilevare se la versione DBMS del record è stata modificata.
DBMS_OPTIMISTIC - tenta di utilizzare i meccanismi di concorrenza passiva specifici del DBMS per rilevare se la versione del DBMS del record è stata modificata.
START USING DATABASE database_name Questo comando alterna il database correntemente attivo su database_name.
TRACE ALERT DESTINATION file name Imposta il file di destinazione per ogni messaggio di notifica generato da un timer di traccia.
Se utilizzato, le informazioni vengono accodate al file specificato. Per default, questo file viene denominato sql_trc.alr.
Nota: Le informazioni vengono accodate al file esistente. Questo è diverso dal comando TRACE FILE, che tronca le informazioni sul file specificato.
TRACE AUTO FLUSH true | false Se TRACE AUTO FLUSH viene impostato su TRUE, l'emissione sul file di traccia viene scaricato (scritto su disco) ogni volta che viene scritto. Normalmente, l'emissione sulla registrazione viene scritta su disco solo quando la traccia è completata o quando il sistema operativo decide di scaricare un buffer.
Un malfunzionamento del sistema operativo può causare la perdita di alcune o di tutte le informazioni. Il comando TRACE AUTO FLUSH forza le informazioni sul file, assicurando che il malfunzionamento del sistema operativo non provochi una perdita delle emissioni. Il valore di default è TRUE.
Nota: Le prestazioni possono risentire della frequenza con la quale si accede al file.
TRACE ENABLED true | false Determina se la traccia è abilitata o disabilitata. Se TRACE ENABLED non è presente, il valore di default è FALSE.
TRACE FILE file name Posizione l'emissione del file di traccia nel file specificato. Questo file viene troncato ogni volta che si avvia la traccia a meno che l'accodamento non sia stato specificato (consultare TRACE APPEND). Se il parametro TRACE_FILE è mancante, il file di traccia di default, sql_trc.log, viene creato nella directory corrente.
TRACE FILE APPEND true | false Quando si inoltra TRUE, ogni file di traccia esistente viene accodato; se si inoltra FALSE, ogni file esistente viene sovrascritto. In entrambi i casi, il file di traccia viene creato se non esiste già. Il valore di default è FALSE.
TRACE INDENT INCR integer Controlla il numero degli spazi utilizzati per far rientrare i blocchi nidificati. Il valore di default è di quattro spazi.
TRACE MAX LINE LENGTH integer Imposta la lunghezza massima della riga nel file di traccia di emissione prima che si verifichi l'avvolgimento. Il valore di default è 2000000000, che disabilita l'avvolgimento.
TRACE MAX NUM FETCHES integer Imposta il numero di righe della serie dei risultati che viene registrato nel file di log. Questo è anche il numero degli eseguibili che sono memorizzati quando si utilizza la combinazione SQLPrepare/SQLExecute. Il valore di default è 3.
TRACE MAX PARAMETER SIZE integer | ALL | NONE Imposta la quantità di dati, in byte per colonna, che viene emessa al file di log per i risultati restituiti dai comandi SQL. Se si specifica ALL, l'istruzione intera viene sempre scritta. Se si specifica NONE, la traccia dei dati colonna viene disabilitata e nessun dato dei risultati viene registrato. Se si specifica 0, i nomi delle colonne appaiono nella registrazione, ma nessun dato viene registrato.
Il valore di default per TRACE MAX PARAMETER SIZE è di 256 byte.
TRACE MAX STATEMENT SIZE integer | ALL Imposta il limite sulla dimensione dell'emissione registrata nel file di log. Se si specifica ALL, l'intera istruzione viene registrata senza essere troncata. Il valore di default è di 1024 byte.
TRACE MSG Message Text Posiziona il testo del messaggio nel file di log di traccia.
TRACE SEPARATOR string Consente ad una stringa specificata dall'utente di essere utilizzata al posto del valore "==>" di default. Utilizzare questa per inserire velocemente un blocco nell'emissione di traccia.
TRACE START TIMER timer name [/i=indent_spaces] [/a=milliseconds] [/q] Avvia un timer con l'unico identificativo fornito. Questo viene visualizzato nel file di log per fornire un punto di riferimento. Il parametro /i controlla il livello di Rientranza (numero di spazi) per collegare gli eventi durante l'intervallo di tempo. Il valore di default per /i è 0.
Il parametro /a (facoltativo) consente un limite massimo sull'intervallo di tempo prima di inviare un messaggio di notifica.
Il parametro /q (facoltativo) viene utilizzato per l'emissione della modalità silenziosa senza alcuna emissione del file di log. Quando /q non è presente, l'emissione viene normalmente registrata su un file.
Nota: Viene richiamato un TRACE_START_TIMER implicito con l'inizializzazione SQL.
TRACE STATEMENTS Questo è un elenco di tipi di istruzioni da registrare, ognuno separato da un segno più (+). Per disabilitare la registrazione, impostare l'indicatore su NONE. Il valore di default è ALL.
TRACE STOP TIMER nome timer Termina la sessione di tempificazione iniziata con la chiamata corrispondente a TRACE_START_TIMER. (Il nome del timer univoco viene corrisposto senza la caratteristica che stabilisce la sensibilità al maiuscolo e minuscolo.)
Quando la sessione di tempificazione termina, il livello di rientranza viene reimpostato e i risultati di tempificazione vengono registrati a meno che /q (silenzioso) non è stato utilizzato (in TRACE START TIMER) per eliminare l'emissione sul file di log.
Nota: Un TRACE STOP TIMER implicito viene richiamato con un deinizializzazione SQL (SQLCloseAll o terminazione di programma).
WRITE LAST ERROR MSG file_name Scrive l'ultimo messaggio di errore DBMS su file_name. Questo non scrive i messaggi di errore generati dal Tivoli Service Desk Developer's Toolkit (ad esempio, INVALID CURSOR HANDLE).

Parametri di traccia SQL configurabili per l'ambiente

E' possibile impostare una sottoserie delle opzioni di traccia con le variabili di ambiente SAISQLTRCFILE e SAISQLTRCENABLED.

SAISQLTRCFILE imposta il nome del file di traccia. Ad esempio, per impostare questa variabile di ambiente dalla riga comandi, è necessario immettere:

SET SAISQLTRCFILE=c:\trc\trc.log.

SAISQLTRCENABLED abilita o disabilita la traccia SQL. Ad esempio, per impostare questa variabile di ambiente dalla riga comandi, è necessario immettere:

SET SAISQLTRCENABLED=TRUE.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
connectionHandle, retCd, dbms, module, caseSensitive,
 caseConvert: INTEGER;
ACTIONS
(*connect to the data source*)
retCd := SQLCommand('CONNECT SOURCE=ADV_ORACLE;QUAL=
 EXAV;UID=TIM;');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the current connection handle*)
connectionHandle := SQLCommand ('GET CURRENT CONNECTION');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* set the current connection*)
ret := SQLCommand ('SET CONNECTION' & connectionHandle);
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(*disconnect from the current connection*)
retCd := SQLCommand ('DISCONNECT');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(*disconnect from a specified connection*)
retCd := SQLCommand ('DISCONNECT' & connectionHandle);
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the current DBMS type*)
dbms := SQLCommand ('GET DBMS');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the DBMS type for a specific data source *)
dbms := SQLCommand ('GET DBMS TEST');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get SAI_SQL.DLL module type *)
module := SQLCommand ('GET MODULE');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get whether or not the DBMS is case-sensitive *)
caseSensitive := SQLCommand ('GET CASE SENSITIVITY');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the current case conversion mode *)
caseConvert := SQLCommand ('GET CASE CONVERSION');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* set the current case conversion mode for the current connection *)
ret := SQLCommand ('SET CASE CONVERSION upper');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* save the current qualifier for the current connection *)
ret := SQLCommand ('SAVE CURRENT QUALIFIER');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the date format for the named ADVISOR *)
ret := SQLCommand('GET DATE FORMAT ADVISOR');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* get the time format for the source to which I am currently connected *)
ret := SQLCommand('GET TIME FORMAT');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* set the current qualifier for the current connection *)
ret := SQLCommand('SET CURRENT QUALIFIER Fred');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* restore the current qualifier for the current connection *)
ret := SQLCommand('RESTORE CURRENT QUALIFIER');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
(* switch databases *)
ret := SQLCommand('START USING DATABASE advisor');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
END; --Test--

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche

Consultare il manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script per ulteriori informazioni:


SQLCommit

Descrizione

Emette un comando SQL Commit Work all'interprete SQL, accettando dunque tutte le modifiche apportate durante questa transazione.

Sintassi

FUNCTION SQLCommit: INTEGER;

Avvertenze

Se un'istruzione preparata non fa riferimento ad un cursore aperto, un commit provoca la chiusura di quell'istruzione. E' necessario chiudere manualmente ogni istruzione preparata prima di eseguire un commit.

La maggior parte dei driver non consentono di specificare i cursori che possono espandere le unità di lavoro (ad esempio, dichiararle con WITH HOLD). Un'eccezione consiste nel driver CLI DB2. Dopo un'operazione di commit, tutti i cursori vengono chiusi. Tuttavia, se si eseguono le operazioni SQL (come ad esempio gli aggiornamenti) in un loop fetch, è necessario disabilitare il commit automatico dopo ogni istruzione SQL.

Nota: E' necessario chiudere tutti i cursori prima di eseguire un'operazione di commit o di rollback.

Note

Il TSD Script generalmente esegue il commit di ogni istruzione SQL dopo il completamento. Quando si esegue un gruppo di istruzioni SQL all'interno di una transazione, tuttavia, è necessario eseguire il commit o il rollback manuale della transazione con SQLCommit o SQLRollBack.

Dopo una chiamata effettuata a SQLCommit (o SQLRollBack), la transazione corrente viene terminata e il commit automatico viene ripreso. E' necessario effettuare un'altra chiamata a SQLBeginWork per avviare un'altra transazione.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
(* misc *)
   retCd : INTEGER;
ACTIONS
 (* begin a transaction *)
  SQLBeginWork;
 (* delete all employees whose age is > age passed in *)
 retCd := SQLDelete('emp','age > ' & age);
   IF retCd < 0 THEN
 SQLRollBack; (* terminate this transaction *)
      EXIT retCd;
          END;
(* commit changes and release locks *)
    SQLCommit;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLCreateSearchString

Descrizione

Dato un record i cui campi contengono criteri di inquiry, SQLCreateSearchString crea una clausola WHERE SQL valida (senza il WHERE).

Sintassi

FUNCTION SQLCreateSearchString(VAL tableName: STRING,
                               REF searchString: STRING,
                               VAL searchRec: any record or
                               list of any record): INTEGER;

Avvertenze

Quando si esegue una inquiry che non è sensibile al maiuscolo e minuscolo, il TSD Script chiama automaticamente la funzione Upper appropriata. Nella maggior parte dei casi, la inquiry non utilizza un indice. Per utilizzare gli indici nelle ricerche, è necessario specificare un operatore sensibile al maiuscolo e minuscolo.

Note argomento

Nome dell'argomento Descrizione
tableName La tabella o la vista che si inquiry
searchString Questo contiene la stringa di inquiry che viene creata da SQLCreateSearchString
searchRec Questo parametro è un record singolo o un elenco di record che contiene i criteri di inquiry

Note

SQLCreateSearchString viene utilizzato per creare una clausola WHERE in base al contenuto del record, o all'elenco di record, inoltrati. Se un elenco di record viene inoltrato, le clausole risultanti da ogni elemento dell'elenco vengono combinate con l'operatore logico OR. All'interno di un record, le clausole risultanti da ogni campo sono combinate con l'operatore logico AND.

Notare quanto segue per quel che riguarda SQLCreateSearchString:


Valori validi per i campi operatore

Valore Descrizione
(none) Se non viene specificato un operatore nello schermo Verifica, viene eseguita una inquiry sensibile al maiuscolo e minuscolo. Questo consente l'utilizzo degli indici.
= Uguale sensibile al maiuscolo e minuscolo (utilizzato se il campo operatore non esiste o è $Unknown:database:querying).
> Maggiore di non sensibile al maiuscolo e minuscolo.
< Minore di non sensibile al maiuscolo e minuscolo.
>= Uguale a o maggiore di non sensibili al maiuscolo e minuscolo.
<= Minore di o uguale a non sensibili al maiuscolo e minuscolo.
<> Non uguale a non sensibile al maiuscolo e minuscolo.
== Uguale a sensibile al maiuscolo e minuscolo.
>> Maggiore di sensibile al maiuscolo e minuscolo.
<< Minore di sensibile al maiuscolo e minuscolo.
>= Maggiore di o uguale a sensibile al maiuscolo e minuscolo.
<= Minore di o uguale a sensibili al maiuscolo e minuscolo.
<<>> Non uguale a sensibile al maiuscolo e minuscolo.
IS NULL TRUE se la colonne è al momento NULL. Quando si utilizza l'operatore IS NULL, il valore del campo della colonna corrispondente non è rilevante. Tuttavia, il campo corrispondente alla colonna deve essere presente.
IS NOT NULL TRUE se la colonna non è al momento NULL. Quando si utilizza l'operatore IS NOT NULL, il valore attuale del campo della colonna corrispondente non è rilevante. Tuttavia, il campo corrispondente alla colonna deve essere presente.

Valori intervallo campo

I suffissi _LO e _HI indicano i valori di intervallo low e high per il campo. Ad esempio, se age è un campo corrispondente ad una colonna della tabella e age_lo è uguale a 21 e age_hi è uguale a 65, viene creato il seguente criterio di inquiry:

'(age >= 21) AND (age <= 65)'. s:

Quando si utilizzano gli operatori di intervallo _LO e _HI, il valore del campo della colonna corrispondente non è rilevante. Tuttavia, il campo corrispondente alla colonna deve essere presente.

Se il campo dell'operatore _LO o _HI non esiste o è $Unknown, il dispositivo di intervallo viene disabilitato e viene utilizzato il valore del campo della colonna corrispondente. Se esiste un campo operatore _OP e il valore è <>, gli operatori dell'intervallo sono > e <. In caso contrario vengono utilizzati i valori di default (>= e <=).

Ricerche dei caratteri jolly

Se la colonna è un tipo di stringa, è possibile eseguire la inquiry dei caratteri jolly utilizzando i caratteri jolly * e ?:

Internamente, i caratteri jolly * e ? sono convertiti nella clausola SQL LIKE compatibile con % e _. Se un campo operatore _OP esiste e il valore è <>, vengono selezionate le righe che non corrispondono ai criteri di inquiry (cioè, viene creata una clausola NOT LIKE).

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
  TYPES
SearchRecord IS RECORD
 ssn: INTEGER;
 title: STRING;
 title_op: STRING;
      salary : REAL;
 age_lo:integer;
 age_hi:integer;
 age_op:string;
   name :STRING;
 name_lo:string;
 name_hi:string;
 name_op:string;
      age :INTEGER;
  married                      : BOOLEAN;
 MARRIED_OP:STRING;
 rating: REAL;
 addr: STRING;
 addr_OP: STRING;
 bDate: DATE;
 bTime: TIME;
 sysDT: STRING;
 sysDT_op: STRING;
END; (* SearchRecord *)
VARIABLES
r : SearchRecord;
searchString : STRING;
  cursor: SQLCursor;
ret : INTEGER;
ACTIONS
 (* These values would normally come from a custom dialog box. *)
 r.title_op := '<>';
 r.title := 'PROGRAMMER'; (* ( (title <> 'PROGRAMMER) AND *)
 r.ssn := 315687890; (* (ssn = 316700056) AND *)
 r.name := 'Pamela*'; (* (name LIKE 'Pamela%') AND *)
 r.name_op := '=='; (* perform a case-sensitive search *)
 r.age := 30; (* ((age >= 13) AND (age <= 49)) AND *)
 r.age_lo := 13;
 r.age_hi := 49;
 r.age_op := '=';
 r.MARRIED_OP := 'is NOT null'; (* (married IS NOT NULL) AND *)
 r.rating := 43.457; (* (rating = 43.457) *)
 r.addr := '5051 ?. Morris *'; (* (addr NOT LIKE '5050 _. Morris %') AND *)
 r.bTime := {14,09,16}:TIME; (* (bTime = '14:09:16') AND *)
 r.bDate := {06,26,1985}:DATE; (* (bDate= '06/26/1985') AND *)
 r.sysDT := '1961-10-10-14.09.16.00'; (* (sysDT >= '1961-10-10-14.09.16.00)) *)
 r.sysDT_op := '>=';
 SQLCreateSearchString('emps',searchString,r);
 ret := SQLSelect(cursor, 'emps',searchString);
 IF ret < 0 THEN
 Exit ret;
          END;
 ret := SQLFetch(cursor,r);
 WHILE ret > 0 DO
 (* process r... *)
 ret := SQLFetch(cursor);
          END;
   SQLCloseCursor(cursor);
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

SQLDelete

Descrizione

Cancella una riga specificata da una tabella.

Sintassi

SQLDelete(tableName: STRING,
          queryString: STRING [,expressionList...]):
 INTEGER;

Attenzione: Poiché una chiamata a SQLDelete può cancellare molte righe, è importante specificare correttamente la clausola WHERE.

Note argomento

Nome dell'argomento Descrizione
tableName Il nome dalla tabella dalla quale effettuare la cancellazione.
queryString La clausola WHERE.
expressionList Questo è un elenco di zero o di più espressioni, ognuna separata da virgole. Ad esempio:
3.4, age + 100, nome, 'Fred', Sin(45), ...

Note

La parola chiave WHERE nella stringa query è facoltativa.

SQLDelete consente la sostituzione dell'indicatore dei parametri. Per utilizzare gli indicatori dei parametri, inserire un punto interrogativo (?) nella stringa dell'istruzione. Questo funge da segnaposto per un valore che dovrà essere sostituito in seguito.

Il valore deriva dall'elenco delle espressioni facoltative che segue la stringa dell'istruzione. Il numero di espressioni deve corrispondere al numero degli indicatori di parametri (?) e l'ordine delle espressioni deve corrispondere a quello degli indicatori.

Il Tivoli Service Desk Developer's Toolkit non è in grado di fornire un controllo affidabile con gli indicatori dei parametri. Ad esempio:

retCd = SQLDelete('emp','WHERE name = ?',name);

La stringa contenuta nel nome della variabile non deve essere compresa tra singoli apici. Non è necessario utilizzare le variabili. Ad esempio:

retCd = SQLDelete('emp','WHERE name = ?','Smith');

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF AGE: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF AGE: INTEGER):INTEGER IS
VARIABLES
   retCd : INTEGER;
ACTIONS
(* delete all employees from Indiana, and whose age is greater than *)
(* the age passed into this function. *)
retCd := SQLDelete('emp','(state = ''IN'') AND (age >> ' & age & ')');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLDeleteCurrent

Descrizione

Cancella la riga nella posizione corrente del cursore.

Sintassi

SQLDeleteCurrent(cursor: SQLCURSOR): INTEGER;

Note argomento

Nome dell'argomento Descrizione
cursor Il cursore deve essere precedentemente aperto da una chiamata effettuata a SQLSelect

Note

SQLDeleteCurrent viene supportato solo nel driver CLI DB2.

Sebbene non si esegua un aggiornamento, è necessario utilizzare la clausola FOR UPDATE OF in SQLSelect quando si cancella una riga. L'interprete SQL applica quindi i blocchi in modo appropriato. Se non si fornisce nessuna clausola FOR UPDATE OF, la selezione viene trattata come se fosse di sola lettura.

A differenza di SQLUpdateCurrent, dove ogni colonna aggiornata deve essere specificata nella clausola FOR UPDATE OF, è sufficiente specificare solo una colonna quando si utilizza SQLDeleteCurrent. E' necessario specificare almeno una colonna valida; impossibile utilizzare *.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
   retCd : INTEGER;
ACTIONS
SQLBeginWork
(* select all employees from Indiana, and whose age is greater than *)
(* the age passed into this function. *)
retCd := SQLSelect(cursor,'name from emp WHERE (state =
 ''IN'') AND ' & '(age > ' & age & ')
 FOR UPDATE OF NAME');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate this transaction *)
      EXIT retCd;
          END;
retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* possibly perform some operation(s) based on "name" *)
 (* now delete this row *)
 retCd := SQLDeleteCurrent(cursor);
 IF (retCd < 0) THEN
  SQLCloseCursor(cursor);
 SQLRollback; (* reverse any changes, and release locks *)
      EXIT retCd;
          END;
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
   SQLCloseCursor(cursor);
 SQLCommit; (* accept changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche

SQLDelete


SQLExecute

Descrizione

Esegue un'istruzione preparata.

Sintassi

SQLExecute(statement: STATEMENT [,expressionList...]): INTEGER;

Avvertenze

Un'operazione di rollback chiude automaticamente tutte le istruzioni aperte (preparate) e i cursori aperti (consultare SQLRollBack). Un'operazione di commit chiude automaticamente tutte le istruzioni aperte che non fanno riferimento ad un cursore aperto.

Nota: Limite massimo di 20 istruzioni aperte alla volta.

Note argomento

Nome dell'argomento Descrizione
statement Questa è l'istruzione nel proprio modulo preparato, ottenuto da SQLPrepare.
expressionList Questo è un elenco di zero o di più espressioni, ognuna separata da virgole. Ad esempio: 3.4, age + 100, name, 'Fred', $Sin(45), ...

Note

Se si esegue un comando molte volte in un loop, è più veloce preparare il comando una volta utilizzando SQLPrepare ed eseguire quindi la versione preparata nel loop utilizzando SQLExecute.

SQLExecute consente la sostituzione dell'indicatore dei parametri. Per utilizzare gli indicatori dei parametri, inserire un punto interrogativo (?) nella stringa dell'istruzione.

Questo funge da segnaposto per un valore che dovrà essere sostituito in seguito. Il valore deriva dall'elenco delle espressioni facoltative che segue la stringa dell'istruzione. Il numero di espressioni deve corrispondere al numero degli indicatori di parametri (?) e l'ordine delle espressioni deve corrispondere a quello degli indicatori.

Il Tivoli Service Desk Developer's Toolkit non è in grado di fornire un controllo affidabile con gli indicatori dei parametri. Ad esempio:

retCd = SQLPrepare(stmt, 'UPDATE emp SET name= ? WHERE ssn=?);

La stringa contenuta nel nome della variabile non deve essere compresa tra singoli apici. Non è necessario utilizzare le variabili. Ad esempio:

retCd = SQLExecute (stmt, 'Smith', 317689630);

Gli indicatori dei parametri consentono all'utente di eseguire determinate operazioni (come ad esempio questo aggiornamento) nei loop intasati utilizzando la combinazione efficiente SQLPrepare/SQLExecute invece di SQLUpdate, SQLExecuteImmediate, e così via.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER IS
VARIABLES
  stmt: SQLStatement;
   retCd : INTEGER;
ACTIONS
SQLBeginWork; (* start a transaction *)
  (* insert the user names passed in *)
 retCd := SQLPrepare(stmt,'INSERT INTO USERS VALUES (?)');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate this transaction *)
      EXIT retCd;
          END;
  FOR users DO
    retCd := SQLExecute(stmt,users[$current]);
 IF (retCd < 0) THEN
 SQLRollBack; (* reverse changes and release locks *)
      EXIT retCd;
          END;
   END; (* for *)
   SQLCloseStatement(stmt);
 SQLCommit; (* accept changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLExecuteImmediate

Descrizione

Esegue un'istruzione SQL direttamente dal modulo stringa.

Sintassi

SQLExecuteImmediate(sqlCommand: STRING [,expressionList...]): INTEGER;

Note argomento

Nome dell'argomento Descrizione
sqlCommand Questo deve essere un comando SQL (istruzione) sintatticamente corretto e completo che può essere preparato in modo dinamico e che non deve essere un comando SELECT.
expressionList Questo è un elenco di zero o di più espressioni, ognuna separata da virgole. Ad esempio: 3.4, age + 100, name, 'Fred', $Sin(45), ...

Note

SQLExecuteImmediate consente di eseguire quasi tutti i comandi SQL, fatta eccezione per i comandi SELECT e per i comandi che non possono essere preparati in modo dinamico.

Se si esegue un comando molte volte in un loop, è più facile preparare il comando una volta e quindi eseguire la versione preparata nel loop.

E' possibile utilizzare le funzioni di gestione delle stringhe incorporate del Tivoli Service Desk Developer's Toolkit per un aiuto nella creazione della stringa dei comandi.

Il Tivoli Service Desk Developer's Toolkit non esegue l'espansione della qualifica in SQLExecuteImmediate. E' possibile utilizzare ancora $QUAL e $SYSQUAL.

Nota: SQLExecuteImmediate consente la sostituzione dell'indicatore dei parametri.

Per utilizzare gli indicatori dei parametri, inserire un punto interrogativo (?) nella stringa dell'istruzione. Questo funge da segnaposto per un valore che dovrà essere sostituito in seguito. Il valore deriva dall'elenco delle espressioni facoltative che segue la stringa dell'istruzione. Il numero di espressioni deve corrispondere al numero degli indicatori di parametri (?) e l'ordine delle espressioni deve corrispondere a quello degli indicatori.

Il Tivoli Service Desk Developer's Toolkit non è in grado di fornire un controllo affidabile con gli indicatori dei parametri. Ad esempio:

retCd = SQLExecuteImmediate('UPDATE emp SET name = ? WHERE ssn = ?',name,ssn);

La stringa contenuta nel nome della variabile non deve essere compresa tra singoli apici. Non è necessario utilizzare le variabili. Ad esempio:

retCd =SQLExecuteImmediate('UPDATE emp SET name = ? WHERE ssn?','Smith', 316798965);

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
(* table columns of emp *)
sDate: DATE; (* 'integer' *)
name: STRING; (* 'char(15)' *)
age: INTEGER; (* 'smallint' *)
ssn: INTEGER; (* 'integer' *)
married: BOOLEAN; (* 'smallint' *)
salary: REAL; (* 'float' *)
rating: REAL; (* 'decimal(8,3)' *)
addr: STRING; (* 'varchar(81)' *)
sp: SPACE; (* 'varchar(2500) *)
lsp: SPACE; (* 'long varchar for bit data *)
bDate: DATE; (* 'date' *)
bTime: TIME; (* 'time' *)
sTime: TIME; (* 'integer' *)
sysDT: STRING; (* 'timestamp' *)
(* misc *)
   retCd : INTEGER;
  s : STRING;
ACTIONS
 SQLExecuteImmediate('DROP TABLE tsql');
 s := 'CREATE TABLE tsql (name CHAR(15), ' &
 'age SMALLINT, ' &
 'married SMALLINT, ' &
 'ssn INTEGER, ' &
 'salary FLOAT, ' &
 'rating DECIMAL(8,3), ' &
 'addr VARCHAR(81), ' &
 'sp VARCHAR(2500), ' &
 'lsp LONG VARCHAR FOR BIT DATA, ' &
 'bdate DATE, ' &
 'btime TIME, ' &
 'sdate INTEGER, ' &
 'stime INTEGER, ' &
 'sysDT TIMESTAMP) ' &
 'PRIMARY KEY(ssn))';
 retCd := SQLExecuteImmediate(s);
       EXIT retCd;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche

Consultare la documentazione SQL per informazioni aggiuntive.


SQLFetch

Descrizione

Sottopone a fetch la riga successiva del cursore nei parametri specificati.

Sintassi

SQLFetch(cursor: SQLCURSOR [,parameterList...]): INTEGER;

Attenzione: Se si utilizza l'ottimizzazione fetch preinizializzata, è necessario assicurarsi che i parametri elencati (variabili delle colonne) nel primo fetch (quello di inizializzazione) siano ancora visibili quando vengono eseguiti i fetch successivi (inizializzati). Questo si verifica sempre quando il fetch di inizializzazione, i parametri e i fetch inizializzati si trovano nella stessa funzione.

Nota: Un rollback chiude tutti i cursori. Se si verifica un rollback a metà di un loop fetch, la chiamata successiva a SQLFetch ha esito negativo.

Note argomento

Nome dell'argomento Descrizione
cursor Il cursore deve essere precedentemente aperto da una chiamata a SQLSelect.
parameters Questo è un elenco di zero o più parametri (variabili di colonna) delimitato da una virgola i cui nomi devono corrispondere ai nomi della colonna (consultare Note per questa istruzione).

Note

SQLFetch ha due moduli per l'ottimizzazione. Il primo modulo ha tutti i parametri (variabili di colonna) elencati dopo il cursore; il secondo modulo ha solo il cursore. Il primo modulo viene considerato come un fetch di inizializzazione in quanto inizializza il Tivoli Service Desk Developer's Toolkit per consentire un rapido inserimento nei parametri. Il secondo modulo presuppone che i parametri da sottoporre a fetch siano gli stessi specificati nella chiamata più recente effettuata al fetch del primo modulo. Il secondo modulo viene definito fetch inizializzato o preinizializzato.

Dopo che il Tivoli Service Desk Developer's Toolkit è venuto a conoscenza dei parametri fetch, diviene molto più veloce se l'utente non specifica nuovamente i parametri. (Questo fa sì che il Tivoli Service Desk Developer's Toolkit non inizializzi nuovamente i parametri.)

Nota: Per maggiori informazioni sull'utilizzo dei fetch preinizializzati, consultare le Avvertenze per questa istruzione.

Corrispondenza dei nomi dei parametri con i nomi delle colonne

I nomi dei parametri devono corrispondere ai rispettivi nomi di colonna. Ogni parametro il cui nome non corrisponde ad un nome di colonna viene ignorato. L'eccezione si verifica se il nome della colonna inizia con SQLColumn_ e termina con il numero della colonna che corrisponde alla posizione nell'elenco di selezione. Con questo metodo, è possibile accedere ai risultati delle funzioni della colonna (aggregata).
Ad esempio, se la stringa di selezione è

SELECT count(*) FROM emp

e si dichiara SQLColumn_1 come una variabile di tipo INTEGER, è possibile eseguire il fetch del conteggio con:

SQLFetch(cursor,$SQLColumn_1);

L'ordine dei parametri $SQLColumn_xx non è rilevante all'interno dell'elenco dei parametri.

Ad esempio, se name è una colonna di caratteri, e age è una colonna numerica, e la stringa di selezione è:

SELECT name,age FROM emp

e si dichiarano le variabili $SQLColumn_xx come

$SQLColumn_1: STRING; $SQLColumn_2: INTEGER;

name viene sottoposto a fetch in $SQLColumn_1, e age in $SQLColumn_2:

SQLFetch(cursor,$SQLColumn_1,$SQLColumn_2);

e:

SQLFetch(cursor,$SQLColumn_2,$SQLColumn_1);

Sebbene questo esempio utilizzi STRING e INTEGER, è possibile definire ogni tipo di dati TSD Script valido per $SQLColumn tranne LIST o WINDOWS.

Inoltro dei record come parametri

E' possibile inoltrare un record come se fosse un parametro. In questo caso, i nomi dei campi devono corrispondere ai nomi delle colonne della tabella oppure vengono ignorati.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
   retCd : INTEGER;
ACTIONS
SQLBeginWork; (* start a transaction *)
(* select all employees from Indiana, and whose age is greater *)
(* than the age passed into this function. *)
retCd := SQLSelect(cursor,'name from emp WHERE (state = ''IN'') AND ' &
 '(age > ' & age & ') FOR UPDATE OF NAME');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate the transaction *)
      EXIT retCd;
          END;
retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* possibly perform some operations based on "name"
 .
 .
 .
 *)
 (* set name to uppercase *)
 name := StrUpper(name);
 (* now update this row *)
 retCd := SQLUpdateCurrent(cursor,name);
 IF (retCd < 0) THEN
  SQLCloseCursor(cursor);
 SQLRollback; (* reverse any changes, and release locks *)
      EXIT retCd;
          END;
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
  SQLCloseCursor(cursor);
 SQLCommit; (* accept changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLFormat

Descrizione

Converte il valore dei dati in una stringa nel formato dati appropriato per il DBMS al quale l'utente è al momento connesso.

Sintassi

SQLFormat(value: SIMPLE EXPRESSION): STRING;

Avvertenze

I formati della data e dell'ora richiesti dal DBMS possono differire dai formati della data e dell'ora che vengono utilizzati per la visualizzazione. Ad esempio, il formato della data di Oracle di default è DD-MON-YY, mentre il formato della data del Tivoli Service Desk Developer's Toolkit di default su una workstation degli Stati Uniti è MM/DD/YYYY.

Note argomento

Nome dell'argomento Descrizione
valore Questo deve essere di tipo semplice (come ad esempio DATE o STRING)

Note

SQLFormat restituisce una stringa formattata, non un codice di ritorno, che indica se un'operazione ha avuto esito positivo. Se il valore inoltrato è $Unknown, viene restituita la stringa 'NULL'. La formattazione specifica della stringa dipende dal tipo della stringa:

Codici di ritorno

La stringa formattata viene restituita. Se il valore inoltrato è $Unknown, viene restituita la stringa 'NULL'.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
 FUNCTION GetCount(VAL d: DATE): INTEGER;
PRIVATE
    ROUTINES
 FUNCTION GetCount(VAL d: DATE): INTEGER IS
VARIABLES
   retCd : INTEGER;
   cmd : STRING;
   $SQLColumn_1 : INTEGER;
ACTIONS
 cmd := 'SELECT COUNT(*) FROM COMPANIES WHERE name = ' &
 SQLFormat('Joe''s place') & ' AND founded_date ' & SQLFormat(d);
   retCd := SQLSelectInto(cmd, $SQLColumn_1);
   IF retCd < 0 THEN
     Exit( retCd );
      ELSE
     Exit( $SQLColumn_1 );
          END;
          END;

Consultare anche

Per maggiori informazioni sui formati data e ora, e i formati dei numeri interi e reali, consultare "Indicatori formato del tipo di dati" nel capitolo 3.

Per ulteriori informazioni sul file sai_sql.cfg, consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script .


SQLGetCursorName

Descrizione

Richiama il nome del cursore attuale internamente utilizzato dall'Interprete SQL per il cursore specificato.

Sintassi

SQLGetCursorName(cursor: SQLCURSOR, cursorName: STRING):
  INTEGER;

Note argomento

Nome dell'argomento Descrizione
cursor Il cursore deve essere precedentemente aperto da una chiamata effettuata a SQLSelect
cursorName Il nome del cursore

Note

SQLGetCursorName viene supportato solo nel driver CLI DB2.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
cursorName: STRING;
   retCd : INTEGER;
ACTIONS
(* select all employees from Indiana, and whose age is
 greater *)
(* than the age passed into this function. *)
retCd := SQLSelect(cursor,'name from emp WHERE (state =
 ''IN'') AND ' & '(age > ' & age & ')
 FOR UPDATE OF NAME');
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
 SQLGetCursorName(cursor,cursorName);
 retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* possibly perform some operations based on "name" and "cursorName"
 .
 .
 .
 *)
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
  SQLCloseCursor(cursor);
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLGetOption

Descrizione

Richiama il valore di un'opzione dello stato del contesto o della configurazione.

Sintassi

SQLGetOption(VAL option: STRING,
             REF optionValue : <ANY SIMPLE VARIABLE>
             [, VAL srcOrConn : <INTEGER OR STRING EXPRESSION>])
                    : INTEGER;

Attenzione: A differenza delle opzioni nel file di configurazione SQL (sai_sql.cfg), i nomi delle opzioni inoltrate a SQLGetOption utilizzano gli spazi, non le sottolineature, per la indicare gli spazi.

Nota: La maggior parte delle opzioni che possono essere richiamate con SQLGetOption, possono essere impostate con SQLSetOption.

Note argomento

Nome dell'argomento Descrizione
option Il nome dell'opzione (come: 'DATE FORMAT'). Consultare la sezione Note per un elenco completo.
optionValue La variabile che viene impostata sul valore dell'opzione;
srcOrConn Questo argomento è facoltativo, e se fornito deve contenere un nome origine (STRING) o un handle di connessione (INTEGER). Se questo argomento non viene inoltrato, si utilizza $CURRENT.

Note

La funzione restituisce un codice di esito positivo o di errore. I codici di errore più comuni sono: INVALID_OPTION e NOT_CONNECTED (per quelle opzioni che richiedono che l'utente sia connesso, cioè per la maggior parte delle opzioni).

Questa funzione incorpora la precedente funzionalità in SQLCommand ('GET ... '); con il vantaggio di poter restituire i dati STRING.

Di seguito sono elencate le opzioni che possono essere specificate con questo comando:

Opzione Descrizione
'BIND PARAMETER BUFFER SIZE' Restituisce la dimensione buffer utilizzata per il collegamento dei parametri.
'BIND PARAMETER FILL OUTPUT NULL VALS' Restituisce TRUE se i valori di emissione che sono NULL sono impostati su zero.
'BIND PARAMETER PAD OUTPUT STRINGS' Restituisce TRUE se le stringhe del parametro di emissione sono riempite con caratteri vuoti sulla precisione specificata.
'BOOLEAN FORMAT' Restituisce il formato utilizzato per memorizzare i valori booleani nel DBMS. Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'BOOLEAN PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori booleani.
'BOOLEAN PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori booleani.
'BOOLEAN STORAGE TYPE' Restituisce il tipo di memorizzazione utilizzata per rappresentare i valori booleani. I valori possibili sono:
1 - INTEGER
2 - STRING
3 - BOOLEAN
'CASE CONVERSION' Restituisce la conversione del caso (maiuscolo e minuscolo) utilizzata dal Tivoli Service Desk Developer's Toolkit per i nomi oggetti (non si applica ai dati). I valori possibili sono:
1 - Upper
2 - Lower
3 - None
'CASE SENSITIVITY' Restituisce TRUE se il database ha nomi oggetto sensibili al maiuscolo e minuscolo (non si applica alla funzione di sensibilità al maiuscolo e minuscolo di DATA).
'CATALOG CASE CONVERSION' Restituisce la conversione del caso (maiuscolo o minuscolo) utilizzata dal Tivoli Service Desk Developer's Toolkit per i dati nelle viste del catalogo (SAI_SYSCOLUMNS e SAI_SYSTABLES). I valori possibili sono:
1 - Upper
2 - Lower
3 - None
'CHECK DRIVER' Restituisce TRUE se Tivoli Service Desk Developer's Toolkit esegue un controllo per accertarsi che il driver sia elencato come non supportato.
'COLUMN CATALOG METHOD' Restituisce il metodo utilizzato dal Tivoli Service Desk Developer's Toolkit per ottenere i valori del catalogo della colonna. I valori possibili sono:
1 - Utilizzare il metodo standard per interrogare il catalogo
della colonna.
2 - Utilizzare una query specifica del DBMS per un catalogo
della colonna.
3 - Utilizzare una funzione ODBC SQLColumn().
'COMMIT SELECTS' Applicabile se il commit manuale è TRUE. Informa se i commit sono eseguiti dopo le unità di lavoro di sola lettura.
'CONFIG FILE' Restituisce il nome del file di configurazione utilizzato dal Tivoli Service Desk Developer's Toolkit quando si stabilisce una connessione. Non è necessario essere collegati per richiamare questo valore.
'CONNECTION' Restituisce l'handle di connessione. E' possibile richiamare questa opzione con SQLGetOption ma non è possibile impostarla con SQLSetOption.
'CURRENT COL BUFFER' Restituisce la dimensione del buffer della colonna corrente.
'CURRENT ROW BUFFER' Restituisce la dimensione del buffer della riga corrente.
'DATE FORMAT' Restituisce il formato data del DBMS. Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'DATE PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori della data.
'DATE PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori della data.
'DATE STORAGE TYPE' Restituisce il tipo di memorizzazione utilizzata per rappresentare le date. I valori possibili sono:
1 - INTEGER
2 - STRING
6 - DATE
'DBMS' Restituisce il DBMS (numero). I DBMS attualmente riconosciuti sono:
0 - DB2/2, DB2/6000, DB2/NT, DB2/UX
1 - ORACLE
2 - DB2
3 - SQL SERVER 4.x
4 - SYBASE
5 - NETWARE SQL
6 - GUPTAN SQLBASE
7 - XDB
8 - DBASE
9 - BTRIEVE
10 - ASCII TEXT
11 - EXCEL
12 - SYBASE 10 (e superiore)
13 - PARADOX
14 - INGRES3
15 - INGRES4
16 - INFORMIX4
17 - INFORMIX5
18 - TANDEM
19 - PROGRESS
20 - HP ALLBASE
21 - WATCOM
22 - FULCRUM
23 - MS SQL SERVER 6.x
24 - (OTHER)
'DBMS STRING' Restituisce i seguenti nomi di database:
DB2, ORACLE, SQLSERVER, SYBASE o DBMS_OTHER.
'DSN' Restituisce il nome origine dei dati ODBC corrente (solo se ci si collega ad un'origine dati ODBC).
'HAS TRANSACTIONS' Restituisce TRUE se il DBMS supporta le transazioni
'IN TRANSACTION' Restituisce TRUE se una transazione è stata avviata con SQLBeginWork e non è stata sottoposta a commit o roll back. E' possibile richiamare questa opzione con SQLGetOption ma non è possibile impostarla con SQLSetOption.
'INTEGER FORMAT' Restituisce il formato intero del DBMS. Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'INTEGER PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori interi.
'INTEGER PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori interi.
'INTEGER STORAGE TYPE' Restituisce il tipo di memorizzazione utilizzato per rappresentare i valori interi. I valori possibili sono:
1 - INTEGER
2 - STRING
'LAST ERROR MSG' Restituisce il testo dell'ultimo messaggio di errore del DBMS.
'MANUAL COMMITS' Restituisce TRUE se SAI_SQL (invece del driver) controlla la funzione del commit.
'MAX LITERAL LEN' Restituisce il valore della lunghezza massima del literal della stringa dopo il quale il Tivoli Service Desk Developer's Toolkit esegue il collegamento dei parametri su inserimento e aggiornamento.
'MODULE' Solo per la compatibilità backward. Restituisce il tipo di modulo. Il solo valore possibile per il Tivoli Service Desk Developer's Toolkit 5.0 è 5 (X/Open).
'MODULE TYPE' Solo per la compatibilità backward. Restituisce il tipo di modulo. Il solo valore possibile per il Tivoli Service Desk Developer's Toolkit 5.0 è 5 (X/Open).
'MULTI CONNECT' Restituisce TRUE se il DBMS supporta più connessioni provenienti da un'elaborazione client.
'MULTI CONNECT REQUIRED' Restituisce TRUE se il DBMS richiede più connessioni per poter servire più istruzioni SQL ("nested") contemporaneamente.
'NEEDS CODEPAGE TRANSLATION' Restituisce TRUE se il Tivoli Service Desk Developer's Toolkit deve eseguire le conversioni code page da ANSI a OEM e da OEM a ANSI (solo Windows).
'PROCESS RESULTS ON FREESTMT' Restituisce TRUE se il Tivoli Service Desk Developer's Toolkit assicura lo scaricamento completo dei risultati eseguendo il fetch fino a quando le righe non vengono più restituite.
'QUAL' Restituisce il qualificatore (solitamente il creatore o il proprietario) utilizzato per accedere alle tabelle dati dell'utente.
'REAL FORMAT' Restituisce il formato del numero reale del DBMS.Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'REAL PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori reali.
'REAL PARAMETER SCALE' Restituisce la scala utilizzata per collegare i valori reali.
'REAL PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori reali.
'REAL STORAGE TYPE' Restituisce il tipo di memorizzazione utilizzato per rappresentare i numeri reali. I valori possibili sono:
2 - STRING
3 - REAL
'SHOW WARNINGS' Restituisce TRUE se le caselle di messaggio di attenzione vengono visualizzate.
'SOURCE' Restituisce il nome dell'origine dati SAI_SQL al momento collegata.
'STRING FORMAT' Restituisce il formato della stringa del DBMS. Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'STRING PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori della stringa.
'STRING PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori di stringa.
'SYSQUAL' Restituisce il qualificativo richiesto per accedere alle tabelle del catalogo di sistema.
Nota: Il Tivoli Service Desk Developer's Toolkit versioni 4.1.0 e successive utilizzano le viste involucro create da SAI per le informazioni sui cataloghi dove SYSQUAL viene utilizzato per creare le viste (e.g., EXAV), e non il qualificatore del sistema normale (e.g., SYSIBM).
'TABLE CATALOG METHOD' Restituisce il metodo utilizzato dal Tivoli Service Desk Developer's Toolkit per ottenere i valori del catalogo delle tabelle. I valori possibili sono:
1 - Utilizzare il metodo standard per interrogare il catalogo
della colonna.
2 - Utilizzare una query specifica del DBMS per un catalogo
della colonna.
3 - Utilizzare una funzione ODBC SQLTable().
'TIME FORMAT' Restituisce il formato ora del DBMS. Consultare il Capitolo 3 in questo manuale per ulteriori informazioni sulla formattazione dei dati.
'TIME PARAMETER PRECISION' Restituisce la precisione utilizzata per collegare i valori ora.
'TIME PARAMETER TYPE' Restituisce il tipo di dati X/Open utilizzato per collegare i valori ora.
'TIME STORAGE TYPE' Restituisce il tipo di memorizzazione utilizzato per rappresentare le ore. I valori possibili sono:
1 - INTEGER
2 - STRING
5 - TIME
'TRACE ALERT DESTINATION' Restituisce il nome file del file dei messaggi di notifica (se i messaggi di notifica vengono utilizzati).
'TRACE APPEND' Restituisce TRUE se il file di traccia deve essere accodato (invece di essere sovrascritto) ogni volta.
'TRACE AUTO FLUSH' Restituisce TRUE se l'emissione di traccia viene scaricata nel file di traccia dopo ogni scrittura.
'TRACE ENABLED' Restituisce TRUE se la traccia è stata abilitata.
'TRACE FILE' Restituisce il nome del file di emissione di traccia.
'TRACE INDENT INCR' Restituisce l'incremento della rientranza utilizzato.
'TRACE MAX LINE LENGTH' Restituisce la lunghezza massima della riga dopo la quale si verifica il riavvolgimento.
'TRACE NUM EXECUTES' Restituisce il numero massimo di istruzioni loggedSQLFetch e SQLExecute.
'TRACE PARAM SIZE' Restituisce la lunghezza massima per i parametri scritti sul file.
'TRACE SEPARATOR' Restituisce il separatore di emissione della traccia che viene utilizzato.
'TRACE STATEMENT SIZE' Restituisce la lunghezza massima per le istruzioni scritte sul file.
'TRACE STATEMENTS' Restituisce la maschera di bit delle istruzioni al momento tracciate.
'TRANSLATE FUNC' Restituisce il nome della funzione per il maiuscolo per il DBMS dell'utente.
'UPDATE LOCK COLUMN' Restituisce la colonna (nome) utilizzata per il blocco della concorrenza passiva (generalmente MODIFY_DATETIME).
'UPDATE LOCK ERROR FILTER' Restituisce il livello di filtro di errore utilizzato mentre si esegue il blocco dell'aggiornamento della concorrenza passiva. I valori possibili sono:
0 - Fatal (default)
1 - Error
2 - Warning
3 - Informational
'UPDATE LOCK STYLE' Restituisce lo stile di bloccaggio utilizzato per gli aggiornamenti della concorrenza passiva. I valori possibili sono:
1 - SELECT FOR UPDATE
2 - UPDATE
3 - UPDATE CONDITIONAL
'UPDATE MODE' Restituisce la modalità di aggiornamento della concorrenza passiva (algoritmo). I valori possibili sono:
1 - SELECT
2 - DBMS OPTIMISTIC
3 - NONE

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Esempi

 KNOWLEDGEBASE Example;
 --PUBLIC
    ROUTINES
 PROCEDURE Example;
PRIVATE
    ROUTINES
 PROCEDURE Example IS
VARIABLES
   retCd : INTEGER;
 dateFormat : INTEGER;
 lastErrorMsg : STRING;
 hConn : INTEGER;
ACTIONS
 retCd := SQLGetOption('LAST ERROR MSG' lastErrorMsg);
 retCd := SQLGetOption('DATE FORMAT', dateFormat,
 'ADVISOR');
 retCd := SQLGetOption('CONNECTION', hConn);
 retCd := SQLGetOption('DATE FORMAT', dateFormat, hConn);
          END;

Consultare anche


SQLInsert

Descrizione

Inserisce una nuova riga nella tabella specificata.

Sintassi

SQLInsert(tableName: STRING [,parameters...]): INTEGER;

Note argomento

Nome dell'argomento Descrizione
tableName Il nome della tabella nella quale si stanno inserendo i dati.
parameters Questo è un elenco di zero o più parametri delimitato da una virgola (variabili di colonna) i cui nomi devono corrispondere ai nomi colonna (consultare Note per questa istruzione per ulteriori informazioni).

Note

I parametri (variabili delle colonne) inoltrati in SQLInsert devono avere lo stesso nome delle colonne attuali della tabella. Se un nome di parametro non corrisponde a nessun nome della colonna, il parametro viene ignorato.

Nota: Non è necessario inoltrare i parametri per tutte le colonne della tabella, ma solo per quelle create come NOT NULL.

Non tentare di inserire un parametro del Tivoli Service Desk Developer's Toolkit il cui valore è $Unknown in una tabella in cui la colonna corrispondente è stata creata con l'opzione NOT NULL. E' possibile inoltrare un record come un parametro. In questo caso, i nomi del campo devono corrispondere ai nomi delle colonne delle tabelle, oppure vengono ignorati.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
(* column names *)
   name :STRING;
 ssn: INTEGER;
(* misc *)
   retCd : INTEGER;
ACTIONS
(* set the column values *)
name := 'Fred';
ssn := 316768990;
(* insert new row *)
retCd := SQLInsert('emp',name,ssn);
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLPrepare

Descrizione

SQLPrepare prepara una stringa comandi SQL per un'esecuzione successiva. Questa stringa comandi, una volta preparata, viene definita istruzione preparata. Se l'operazione SQLPrepare ha esito positivo, la variabile inoltrata come parametro dell'istruzione contiene un handle delle istruzioni valido.

Sintassi

SQLPrepare(statement: SQLSTATEMENT, sqlCommand: STRING):
 INTEGER;

Avvertenze

Un'operazione di rollback chiude automaticamente tutti i cursori e le istruzioni aperte (preparate). Un'operazione di commit chiude automaticamente tutte le istruzioni aperte che non fanno riferimento ad un cursore aperto dichiarato WITH HOLD (consultare SQLCommit).

Note argomento

Nome dell'argomento Descrizione
statement L'handle delle istruzioni che viene utilizzato nell'istruzione SQLExecute successiva
sqlCommand Questa è un'istruzione SQL sintatticamente corretta e completa

Note

SQLPrepare consente di preparare quasi tutti i comandi SQL, ad eccezione dei comandi SELECT e dei comandi che non possono essere preparati dinamicamente.

Se si esegue un comando (come ad esempio SQLDelete) molte volte in un loop, è più veloce preparare il comando una volta ed eseguire la versione preparata con SQLExecute invece di eseguire il comando direttamente ogni volta.

Nota: E' possibile utilizzare le funzioni di gestione delle stringhe incorporate del Tivoli Service Desk Developer's Toolkit per un aiuto nella creazione della stringa dei comandi da preparare.

Il Tivoli Service Desk Developer's Toolkit non esegue l'espansione della qualifica in SQLPrepare. Tuttavia, è possibile utilizzare $QUAL e $SYSQUAL.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF users: LIST OF STRING):INTEGER IS
VARIABLES
  stmt: SQLStatement;
   retCd : INTEGER;
ACTIONS
SQLBeginWork; (* start a transaction *)
   (* insert the user names passed in *)
 retCd := SQLPrepare(stmt,'INSERT INTO USERS VALUES (?)');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate the transaction *)
      EXIT retCd;
          END;
   FOR users DO
    retCd := SQLExecute(stmt,users[$current]);
 IF (retCd < 0) THEN
 SQLRollBack; (* reverse changes and release locks *)
      EXIT retCd;
          END;
   END; (* for *)
   SQLCloseStatement(stmt);
 SQLCommit; (* accept changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche

Per ulteriori informazioni, consultare la documentazione SQL.


SQLRollBack

Descrizione

Emette un comando ROLLBACK WORK all'interprete SQL, eliminando/annullando perciò tutte le modifiche apportate durante questa transazione.

Sintassi

FUNCTION SQLRollBack: INTEGER;

Attenzione: Un rollback provoca la chiusura automatica di tutti i cursori aperti e delle istruzioni preparate.

Note

SQLRollBack termina la transazione corrente. E' necessario chiamare nuovamente SQLBeginWork se si desidera avviare un'altra transazione; altrimenti, il TSD Script riprende il commit automatico di ogni istruzione SQL.

Utilizzare SQLRollBack per eliminare le transazioni piccole e non riuscite che non interessano l'immissione dell'utente. Evitare di utilizzare un rollback come un'operazione di annullamento generica per le operazioni di interfaccia utente.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF ssnList: LIST OF INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF ssnList: LIST OF INTEGER):INTEGER IS
VARIABLES
(* misc *)
   retCd : INTEGER;
ACTIONS
(* Start a logical transaction *)
  SQLBeginWork;
(* delete all employees whose ssn is in the ssn list passed in *)
FOR ssnList DO
 retCd := SQLDelete('emp','ssn = ' & ssnList[$CURRENT]);
   IF retCd < 0 THEN
 SQLRollBack; (* reverse the changes and release locks *)
      EXIT retCd;
          END;
          END;
(* commit changes and release locks *)
    SQLCommit;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLSelect

Descrizione

Apre un cursore in base alle righe specificate per il fetch successivo tramite SQLFetch.

Sintassi

SQLSelect(cursor: SQLCURSOR,
 queryString: STRING [,expressionList...]): INTEGER;

Avvertenze

Limite massimo di 20 cursori aperti alla volta.

Un'operazione di rollback chiude automaticamente tutti i cursori.

La maggior parte dei driver non consente all'utente di specificare i cursori che possono espandere le unità di lavoro (i.e., dichiararle con WITH HOLD). Un'eccezione consiste nel driver CLI DB2. Dopo un'operazione di commit tutti i cursori vengono chiusi. Tuttavia, se si eseguono le operazioni SQL (come ad esempio gli aggiornamenti) in un loop fetch, è necessario disabilitare il commit automatico dopo ogni istruzione SQL.

Nota: E' necessario chiudere tutti i cursori prima di eseguire un'operazione di commit o di rollback.

Note argomento

Nome dell'argomento Descrizione
cursor L'handle del cursore per la query.
queryString Questa è la stringa di selezione. Deve essere completa e sintatticamente corretta.
expressionList... Questo è un elenco di zero o di più espressioni, ognuna separata da virgole. Ad esempio:
3.4, age + 100, name, 'Fred', $Sin(45), ...

Note

Se si aggiorna o cancella ogni riga sottoposta a fetch, è necessario utilizzare la clausola FOR UPDATE OF per chiarire le proprie intenzioni all'interprete SQL. Questo viene richiesto se si desidera, in seguito, eseguire un SQLUpdateCurrent.

L'utilizzo di SQLDeleteCurrent si rileva un'ottima scelta. Se non si utilizza una clausola FOR UPDATE OF, la selezione viene trattata come di sola lettura.

Nota: Per le stringe di selezione semplici (come quella dell'esempio), la parola chiave SELECT è facoltativa.

SQLSelect consente la sostituzione dell'indicatore dei parametri. Per utilizzare gli indicatori dei parametri, inserire un punto interrogativo (?) nella stringa dell'istruzione. Questo funge da segnaposto per un valore che dovrà essere sostituito in seguito. Il valore deriva dall'elenco delle espressioni facoltative che segue la stringa dell'istruzione. Il numero di espressioni deve corrispondere al numero degli indicatori di parametri (?) e l'ordine delle espressioni deve corrispondere a quello degli indicatori.

Il Tivoli Service Desk Developer's Toolkit non è in grado di fornire un controllo affidabile con gli indicatori dei parametri. Ad esempio:

retCd = SQLSelect(cursor,'SELECT * FROM emp WHERE name = ?',name);

La stringa contenuto nel nome della variabile non deve utilizzare i singoli apici. Non è necessario utilizzare le variabili. Ad esempio:

retCd = SQLSelect(cursor,'SELECT * FROM emp WHERE name = ?', 'Smith');

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
   retCd : INTEGER;
ACTIONS
SQLBeginTran; (* start a transaction *)
(* select all employees from Indiana, and whose age is *)
(* greater than the age passed into this function. *)
retCd := SQLSelect(cursor,'SELECT name from emp WHERE
 (state = ''IN'') AND ' & '(age > ' & age & ') FOR UPDATE OF NAME');
 IF (retCd < 0) THEN
 SQLRollBack; (* terminate the transaction *)
      EXIT retCd;
          END;
retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* possibly perform some operations based on "name"
 .
 .
 .
 *)
 (* set name to uppercase *)
 name := StrUpper(name);
 (* now update this row *)
 retCd := SQLUpdateCurrent(cursor,name);
 IF (retCd < 0) THEN
  SQLCloseCursor(cursor);
 SQLRollBack; (* reverse changes and release locks *)
      EXIT retCd;
          END;
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
  SQLCloseCursor(cursor);
 SQLCommit; (* accept changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLSelectInto

Descrizione

Seleziona e sottopone a fetch la riga specificata nei parametri (variabili della colonna).

Sintassi

SQLSelectInto(queryString: STRING [,parameters...]):
 INTEGER;

Note argomento

Nome dell'argomento Descrizione
queryString Questa è la stringa di selezione. Deve essere completa e sintatticamente corretta.
parameters Questo è un elenco di zero o più parametri delimitato da una virgola (variabili di colonna) i cui nomi devono corrispondere ai nomi della colonna.
Consultare la sezione Note per ulteriori informazioni.

Note

SQLSelectInto equivale alla seguente sequenza di codici:

SQLSelect SQLFetch SQLCloseCursor.

Tuttavia, se la query della selezione specifica più di una riga, solo la prima riga viene sottoposta a fetch.

Se si aggiorna o cancella ogni riga sottoposta a fetch, utilizzare la clausola FOR UPDATE OF per chiarire le proprie intenzioni all'interprete SQL. Se non si utilizza una clausola FOR UPDATE OF, la selezione viene trattata come di sola lettura.

Corrispondenza dei nomi dei parametri con i nomi delle colonne

I nomi dei parametri devono corrispondere ai rispettivi nomi di colonna. Ogni parametro il cui nome non corrisponde ad un nome di colonna viene ignorato. L'eccezione si verifica se il nome della colonna inizia con SQLColumn_ e termina con il numero della colonna che corrisponde alla posizione nell'elenco di selezione. Con questo metodo, è possibile accedere ai risultati delle funzioni della colonna (aggregata).

As esempio se si dichiara SQLColumn_1 come una variabile (intero), è necessario eseguire il fetch del conteggio con

SQLSelectInto('SELECT count(*) from emp',$SQLColumn_1);

L'ordine dei parametri $SQLColumn_xx non è rilevante all'interno dell'elenco dei parametri. Ad esempio, se name è una colonna di caratteri, e age è una colonna numerica e si dichiarano le variabili $SQLColumn_xx come:

$SQLColumn_1: STRING; $SQLColumn_2: INTEGER;

name viene sottoposto a fetch in $SQLColumn_1 e age in $SQLColumn_2:

SQLSelectInto('name,age FROM emp',$SQLColumn_1,$SQLColumn_2);

e:

SQLSelectInto('name,age FROM emp',$SQLColumn_2,$SQLColumn_1);


Per le stringe di selezione semplici, come quella dell'esempio, la parola chiave SELECT è facoltativa. E' possibile inoltrare un record come parametro; in questo caso, i nomi dei campi devono corrispondere ai nomi delle colonne della tabella, oppure vengono ignorati.

Se si inoltrano due record dello stesso tipo, SQLSelectInto riempie entrambi. Questo salva un passo di assegnazione quando si utilizza la concorrenza passiva.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
 ssn: INTEGER;
      age :INTEGER;
(* misc *)
   retCd : INTEGER;
ACTIONS
(* select all employees from Indiana *)
retCd := SQLSelectInto('SELECT * from emp WHERE state = ''IN''',
 name, age, ssn);
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLSetOption

Descrizione

Imposta il valore di un'opzione dello stato del contesto o della configurazione.

Sintassi

SQLSetOption(VAL option: STRING,
             VAL optionValue:<ANY SIMPLE VARIABLE>
             [,VAL srcOrConn : <INTEGER OR STRING
             EXPRESSION>
                    ): INTEGER;

Avvertenze

I nomi delle opzioni inoltrati a SQLGetOption utilizzano gli spazi, non le sottolineature, per indicare gli spazi, a differenza delle opzioni nel file di configurazione SQL (sai_sql.cfg).

Tutte le opzioni con SQLGetOption non possono essere impostate con SQLSetOption. Consultare la voce per SQLGetOption per un elenco completo di opzioni valide e di specifiche che indicano se possono essere modificate con SQLSetOption.

Note argomento

Nome dell'argomento Descrizione
option Il nome dell'opzione, come ad esempio 'DATE FORMAT'
optionValue Il valore dell'opzione da impostare.
srcOrConn Questo argomento è facoltativo, e se fornito, deve contenere un nome origine (STRING) o un handle di connessione (INTEGER). Se questo argomento non viene inoltrato, si utilizza $CURRENT.

Nota: A differenza di SQLGetOption, il Tivoli Service Desk Developer's Toolkit al momento non supporta questo argomento; in caso ne venisse fornito uno, viene ignorato.

Note

La funzione restituisce un codice di esito positivo o di errore. I codici di errore più comuni sono: INVALID_OPTION e NOT_CONNECTED (per quelle opzioni che richiedono che l'utente sia connesso, cioè per la maggior parte delle opzioni).

Questa funzione incorpora la maggior parte della funzionalità precedentemente rilevata in SQLCommand('SET ... '). Ulteriori informazioni su ogni parametro (compresi i valori di default) vengono rilevati richiamando l'aiuto per il parametro all'interno dell'editor di configurazione SQL. Con poche eccezioni, i parametri con SQLGetOption possono essere impostati con SQLSetOption. Consultare SQLGetOption per un elenco di opzioni disponibili (vengono trattate inoltre le opzioni che non possono essere impostate).

Esempio

KNOWLEDGEBASE Example;
 --PUBLIC
    ROUTINES
  PROCEDURE Example;
 PRIVATE
    ROUTINES
 PROCEDURE Example IS
VARIABLES
   retCd : INTEGER;
ACTIONS
 retCd := SQLSetOption('CASE CONVERSION', 2);
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLUpdate

Descrizione

Aggiorna la riga specificata con i valori contenuti nei parametri (variabili della colonna).

Sintassi

SQLUpdate(tableName: STRING, queryString: STRING,
 parameters...]
 [,originalParameters...]): INTEGER;

Attenzione: Poichè una chiamata a SQLUpdate può aggiornare molte righe, è importante specificare correttamente la condizione query.

Note argomento

Nome dell'argomento Descrizione
tableName Il nome della tabella o vista da aggiornare.
queryString La clausola WHERE.
parameters Questo è un elenco di uno o più parametri delimitato da una virgola (variabili della colonna) i cui nomi devono corrispondere ai nomi della colonna.
Consultare Note per questa istruzione per ulteriori informazioni.
originalParameters Questo è una serie facoltativa di parametri identici alla prima serie. Questi parametri vengono utilizzati per il controllo della concorrenza passiva.
Consultare Note per questa istruzione per ulteriori informazioni.

Note

La parola chiave WHERE nella stringa query è facoltativa. I parametri (variabili delle colonne) inoltrati in SQLUpdate devono avere lo stesso nome delle attuali colonne della tabella. Se un nome di parametro non corrisponde a nessun nome della colonna, il parametro viene ignorato.

Non tentare di aggiornare una colonna di una tabella che è stata creata con l'opzione NOT NULL, con un parametro del Tivoli Service Desk Developer's Toolkit che è $Unknown. E' possibile inoltrare un record come parametro; in questo caso, i nomi dei campi devono corrispondere ai nomi delle colonne della tabella, oppure vengono ignorati.

Concorrenza passiva

Il Tivoli Service Desk Developer's Toolkit fornisce un supporto incorporato per un meccanismo di concorrenza conosciuto come concorrenza passiva. La concorrenza passiva è un modo semplice ma efficace che consente a più utenti di accedere ad una tabella senza bloccare la tabella. E' passiva nel senso che nessun blocco viene applicato attivamente durante la normale procedura di accesso al record.

La concorrenza passiva opera nella seguente maniera:

Nota: Se viene inoltrato solo un record, SQLUpdate non esegue nessun controllo della concorrenza passiva.

Non è necessario utilizzare i record come parametri. Se si utilizza la concorrenza passiva, è necessario assicurarsi che l'ordine delle due serie di parametri sia lo stesso.

Non tentare di aggiornare una colonna di una tabella che è stata creata con l'opzione NOT NULL con un parametro del Tivoli Service Desk Developer's Toolkit che è $Unknown.

Esempio

KNOWLEDGEBASE Example;
(* This example shows an update without passive concurrency. *)
--PUBLIC
    ROUTINES
FUNCTION Test:INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test:INTEGER IS
VARIABLES
(* table columns *)
      age :INTEGER;
(* misc *)
   retCd : INTEGER;
ACTIONS
age := 29;
(* Set all female employee's ages to 29 if they are 30 or over *)
retCd := SQLUpdate('emp','age > 29',age);
 IF (retCd < 0) THEN
      EXIT retCd;
          END;
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


SQLUpdateCurrent

Descrizione

Aggiorna la riga correntemente posizionata del cursore con i valori nei parametri (variabili della colonna).

Sintassi

SQLUpdateCurrent(cursor: SQLCURSOR, parameters): INTEGER;

Note argomento

Nome dell'argomento Descrizione
cursor Il cursore deve essere precedentemente aperto da una chiamata a SQLSelect.
parameters Questo è un elenco di uno o più parametri delimitato da una virgola (variabili di colonna) i cui nomi devono corrispondere ai nomi della colonna.
Consultare la sezione Note per ulteriori informazioni.

Note

SQLUpdateCurrent viene supportato solo nel driver CLI DB2. Ogni colonna che deve essere aggiornata deve essere specificata nella clausola FOR UPDATE OF nella stringa di selezione (Consultare l'istruzione SQLSelect).

I parametri (variabili delle colonne) inoltrati in SQLUpdateCurrent devono avere gli stessi nomi delle colonne attuali della tabella. Se un nome di un parametro non corrisponde a nessun nome della colonna, il parametro viene ignorato. E' possibile inoltrare un record come se fosse un parametro. In questo caso, i nomi dei campi devono corrispondere ai nomi delle colonne della tabella oppure vengono ignorati.

Nota: E' necessario utilizzare la clausola FOR UPDATE OF... su ogni colonna da aggiornare.

Non tentare di aggiornare una colonna di una tabella che è stata creata con l'opzione NOT NULL con un parametro del Tivoli Service Desk Developer's Toolkit che è $Unknown.

Esempio

KNOWLEDGEBASE Example;
--PUBLIC
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER;
PRIVATE
    ROUTINES
FUNCTION Test(REF age: INTEGER):INTEGER IS
VARIABLES
(* columns *)
   name :STRING;
(* misc *)
  cursor: SQLCursor;
   retCd : INTEGER;
ACTIONS
SQLBeginWork; (* start a transaction *)
(* select all employees from Indiana, and whose age is
 greater *)
(* than the age passed into this function. *)
retCd := SQLSelect(cursor,'name from emp WHERE (state =
 ''IN'') AND ' & '(age > ' & age & ') FOR UPDATE OF NAME');
 IF (retCd < 0) THEN
 SQLRollBack; (* must terminate the transaction *)
      EXIT retCd;
          END;
retCd := SQLFetch(cursor,name);
 WHILE (retCd > 0) DO
 (* possibly perform some operations based on "name"
 .
 .
 .
 *)
 (* set name to uppercase *)
 name := StrUpper(name);
 (* now update this row *)
 retCd := SQLUpdateCurrent(cursor,name);
 IF (retCd < 0) THEN
  SQLCloseCursor(cursor);
 SQLRollback; (* reverse any changes, and release locks *)
      EXIT retCd;
          END;
 (* get the next record *)
 retCd := SQLFetch(cursor);
          END;
  SQLCloseCursor(cursor);
SQLCommit; (* commit changes and release locks *)
          END;

Codici di ritorno

Codice di ritorno Descrizione
1 Completamento riuscito
(altro) Consultare il Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script

Consultare anche


Riferimento Lingua del Tivoli Service Desk 6.0 Developer's Toolkit Script

Ritorna alla pagina principale

Copyright