Sintassi SQL supportata

SELECT

L'istruzione SELECT viene utilizzata per eseguire query nel database. Un'istruzione SELECT restituisce zero o più righe di dati in cui ogni riga ha un numero fisso di colonne. Il numero di colonne nel risultato è specificato dal nome colonna result o dall'elenco di espressioni tra SELECT e le parole chiave facoltative FROM.

sql-statement   ::=  SELECT [ALL | DISTINCT] result 
                     [FROM table-list] 
                     [WHERE expr] 
                     [GROUP BY expr-list] 
                     [HAVING expr] 
                     [compound-op select-statement]* 
                     [ORDER BY sort-expr-list] 
                     [LIMIT integer [( OFFSET | , ) integer]] 
result          ::=  result-column [, result-column]* 
result-column   ::=  * | table-name . * | expr [[AS] string] 
table-list      ::=  table [ join-op table join-args ]* 
table           ::=  table-name [AS alias] | 
                     ( select ) [AS alias] 
join-op         ::=  , | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN 
join-args       ::=  [ON expr] [USING ( id-list )] 
compound-op     ::=  UNION | UNION ALL | INTERSECT | EXCEPT 
sort-expr-list  ::=  expr [sort-order] [, expr [sort-order]]* 
sort-order      ::=  [COLLATE collation-name] [ASC | DESC] 
collation-name  ::=  BINARY | NOCASE

Come risultato può essere utilizzata qualsiasi espressione arbitraria. Se l'espressione del risultato è *, tutte le colonne di tutte le tabelle vengono sostituite con quell'espressione. Se l'espressione è il nome della tabella seguito da .*, il risultato sarà tutte colonne in quell'unica tabella.

La parola chiave DISTINCT causa la restituzione di un sottoinsieme di righe di risultati, in cui ogni riga è diversa. I valori NULL non sono considerati distinti gli uni dagli altri. In base al comportamento predefinito, vengono restituite tutte le righe di risultati; ciò può essere reso esplicito con la parola chiave ALL.

La query viene eseguita su una o più tabelle specificate dopo la parola chiave FROM. Se più tabelle sono separate da virgole, la query utilizza il cross join delle diverse tabelle. La sintassi JOIN può anche essere utilizzata per specificare la modalità di join delle tabelle. Il solo tipo di outer join supportato è LEFT OUTER JOIN. L'espressione della clausola ON in join-args deve restituire un valore booleano. Una sottoquery tra parentesi può essere usata come tabella nella clausola FROM. L'intera clausola FROM può essere omessa, nel qual caso il risultato è una singola riga contenente i valori dell'elenco di espressioni result.

La clausola WHERE viene utilizzata per limitare il numero di righe recuperate dalla query. Le espressioni della clausola WHERE devono restituire un valore booleano. Il filtro della clausola WHERE viene applicato prima di qualsiasi raggruppamento, pertanto le espressioni della clausola WHERE potrebbero non includere funzioni di aggregazione.

La clausola GROUP BY determina la combinazione di una o più righe del risultato in un'unica riga di output.. Una clausola GROUP BY è particolarmente utile quando il risultato contiene funzioni di aggregazione. Le espressioni nella clausola GROUP BY non devono necessariamente essere espressioni presenti nell'elenco di espressioni SELECT.

La clausola HAVING è analoga a WHERE per il fatto che limita le righe restituite dall'istruzione. Tuttavia, la clausola HAVING viene applicata dopo che sono stati eseguiti eventuali raggruppamenti specificati da una clausola GROUP BY. Di conseguenza, l'espressione HAVING potrebbe fare riferimento a valori che includono funzioni di aggregazione. Non è necessario che un'espressione della clausola HAVING sia presente nell'elenco SELECT. In modo analogo a un'espressione WHERE, un'espressione HAVING deve restituire un valore booleano.

La clausola ORDER BY determina l'ordinamento delle righe di output. L'argomento sort-expr-list della clausola ORDER BY è un elenco di espressioni utilizzate come chiave di ordinamento. Le espressioni non devono far parte del risultato per una semplice istruzione SELECT, mentre in un'istruzione composta SELECT (un'istruzione SELECT che utilizza uno degli operatori compound-op) ogni espressione di ordinamento deve corrispondere esattamente a una delle colonne dei risultati. Ogni espressione di ordinamento può essere seguita, facoltativamente, da una clausola sort-order composta dalla parola chiave COLLATE e dal nome di una funzione di confronto utilizzata per l'ordinamento del testo e/o della parola chiave ASC o DESC per specificare il tipo di ordinamento (crescente o decrescente). La clausola sort-order può essere omessa; in tal caso viene utilizzato l'ordinamento predefinito (crescente). Per una definizione della clausola COLLATE e delle funzioni di confronto, vedete COLLATE.

La clausola LIMIT applica un limite superiore al numero di righe restituito nel risultato. Una clausola LIMIT negativa indica l'assenza di un limite superiore. La parola chiave opzionale OFFSET following LIMIT specifica il numero di righe da ignorare all'inizio del set di risultati. In una query SELECT composta, la clausola LIMIT può apparire solo dopo l'istruzione SELECT finale e il limite viene applicato all'intera query. Se la parola chiave OFFSET viene utilizzata nella clausola LIMIT, il limite è il primo numero intero e l'offset è il secondo. Se anziché la parola chiave OFFSET si utilizza una virgola, l'offset è il primo numero e il limite è il secondo. Questa apparente contraddizione è intenzionale in quanto ottimizza la compatibilità con i sistemi di database SQL legacy.

Un'istruzione SELECT composta è formata da due o più semplici istruzioni SELECT collegate da uno degli operatori UNION, UNION ALL, INTERSECT o EXCEPT. In un'istruzione SELECT composta, tutte le istruzioni SELECT che la costituiscono devono specificare lo stesso numero di colonne dei risultati. Può essere presente una sola clausola ORDER BY dopo l'istruzione finale SELECT (e prima della singola clausola LIMIT, se è specificata). Gli operatori UNION e UNION ALL combinano i risultati delle istruzioni SELECT precedenti e seguenti in un'unica tabella. La differenza è data dal fatto che in UNION tutte le righe dei risultati sono distinte, mentre in UNION ALL possono essere presenti duplicati. L'operatore INTERSECT utilizza l'intersezione dei risultati delle istruzioni SELECT precedenti e seguenti. EXCEPT utilizza il risultato dell'istruzione SELECT precedente dopo avere rimosso i risultati dell'istruzione SELECT seguente. Quando tre o più istruzioni SELECT sono collegate in un'istruzione composta, vengono raggruppate dalla prima all'ultima.

Per una definizione delle espressioni consentite, vedete Espressioni.

A partire da AIR 2.5, l'operatore SQL CAST è supportato durante la lettura per convertire dati BLOB in oggetti ByteArray di ActionScript. Ad esempio, il codice seguente legge dati raw non memorizzati nel formato AMF e li memorizza in un oggetto ByteArray:

stmt.text = "SELECT CAST(data AS ByteArray) AS data FROM pictures;"; 
stmt.execute(); 
var result:SQLResult = stmt.getResult(); 
var bytes:ByteArray = result.data[0].data;

INSERT

sql-statement  ::=  INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] select-statement 
                    REPLACE INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    REPLACE INTO [database-name.] table-name [(column-list)] select-statement

Il primo formato (con la parola chiave VALUES) crea una singola riga nuova in una tabella esistente. Se non si specifica column-list, il numero dei valori deve corrispondere al numero di colonne nella tabella. Se si specifica column-list, il numero dei valori deve corrispondere al numero di colonne specificate. Le colonne della tabella che non sono presenti nell'elenco di colonne vengono riempite con il valore predefinito specificato al momento della creazione dalla tabella oppure con NULL se non è specificato un valore predefinito.

Il secondo formato dell'istruzione INSERT utilizza i dati da un'istruzione SELECT. Il numero di colonne nel risultato di SELECT deve corrispondere esattamente al numero di colonne nella tabella, se non si specifica column-list, oppure deve corrispondere al numero di colonne indicate in column-list. Viene creata una nuova voce nella tabella per ogni riga del risultato di SELECT. L'istruzione SELECT può essere semplice o composta. Per una definizione delle istruzioni SELECT consentite, vedete SELECT.

conflict-algorithm (facoltativo) consente di specificare un algoritmo alternativo per la risoluzione dei conflitti di vincoli da utilizzare durante questo singolo comando. Per una spiegazione e definizione degli algoritmi relativi ai conflitti, vedete Istruzioni e clausole speciali.

I due formati REPLACE INTO dell'istruzione equivalgono all'uso del formato INSERT [OR conflict-algorithm] standard con l'algoritmo relativo ai conflitti REPLACE (ovvero il formato INSERT OR REPLACE...).

I due formati REPLACE INTO dell'istruzione equivalgono all'uso del formato INSERT [OR conflict-algorithm] standard con l'algoritmo relativo ai conflitti REPLACE (ovvero il formato INSERT OR REPLACE...).

UPDATE

Il comando di aggiornamento cambia i record esistenti in una tabella.

sql-statement  ::=  UPDATE [database-name.] table-name SET column1=value1, column2=value2,... [WHERE expr]

Il comando è composto dalla parola chiave UPDATE seguita dal nome della tabella in cui si desidera aggiornare i record. Dopo la parola chiave SET, fornire il nome della colonna e il valore in cui modificare la colonna come un elenco separato da virgole. L'espressione della clausola WHERE fornisce la riga o le righe in cui i record vengono aggiornati.

DELETE

sql-statement  ::=  DELETE FROM [database-name.] table-name [WHERE expr]

Il comando è composto dalle parole chiave DELETE FROM, seguite dal nome della tabella da cui devono esser rimossi i record.

Senza una clausola WHERE, vengono rimosse tutte le righe della tabella. Se viene fornita una clausola WHERE, vengono rimosse solo le righe corrispondenti all'espressione. L'espressione della clausola WHERE deve restituire un valore booleano. Per una definizione delle espressioni consentite, vedete Espressioni.

CREATE TABLE

sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [IF NOT EXISTS] [database-name.] table-name 
                         ( column-def [, column-def]* [, constraint]* ) 
sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [database-name.] table-name AS select-statement 
column-def          ::=  name [type] [[CONSTRAINT name] column-constraint]* 
type                ::=  typename | typename ( number ) | typename ( number , number ) 
column-constraint   ::=  NOT NULL [ conflict-clause ] | 
                         PRIMARY KEY [sort-order] [ conflict-clause ] [AUTOINCREMENT] | 
                         UNIQUE [conflict-clause] | 
                         CHECK ( expr ) | 
                         DEFAULT default-value | 
                         COLLATE collation-name 
constraint          ::=  PRIMARY KEY ( column-list ) [conflict-clause] | 
                         UNIQUE ( column-list ) [conflict-clause] | 
                         CHECK ( expr ) 
conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | ABORT | FAIL | IGNORE | REPLACE 
default-value       ::=  NULL | string | number | CURRENT_TIME | CURRENT_DATE | CURRENT_TIMESTAMP 
sort-order          ::=  ASC | DESC 
collation-name      ::=  BINARY | NOCASE 
column-list         ::=  column-name [, column-name]*

Ogni definizione di colonna corrisponde al nome della colonna seguito dal tipo di dati per quella colonna, quindi da uno o più vincoli di colonna opzionali. Il tipo di dati della colonna limita i dati che possono essere memorizzati in quella colonna. Se si tenta di memorizzare un valore in una colonna con un tipo di dati diverso, il runtime converte il valore nel tipo appropriato, se possibile, oppure genera un errore. Per ulteriori informazioni, vedete la sezione Supporto per i tipi di dati.

Il vincolo di colonna NOT NULL indica che la colonna non può contenere valori NULL.

Un vincolo UNIQUE determina la creazione di un indice nella colonna o nelle colonne specificate. L'indice deve contenere chiavi univoche, ovvero non devono essere presenti due righe contenenti valori o combinazioni di valori duplicati per la colonna o le colonne specificate. Un'istruzione CREATE TABLE può avere più vincoli UNIQUE, incluse colonne multiple con un vincolo UNIQUE nella definizione della colonna e/o più vincoli UNIQUE a livello di tabella.

Un vincolo CHECK definisce un'espressione che viene valutata e deve essere vera affinché i dati di una riga siano inseriti o aggiornati. L'espressione CHECK deve restituire un valore booleano.

Una clausola COLLATE in una definizione di colonna specifica la funzione di confronto di testo da utilizzare quando si confrontano immissioni di testo per la colonna. Viene utilizzata per impostazione predefinita la funzione di confronto BINARY. Per ulteriori dettagli sulla clausola COLLATE e sulle funzioni di confronto, vedete COLLATE.

Il vincolo DEFAULT specifica un valore predefinito da utilizzare durante l'esecuzione di INSERT. Il valore può essere NULL, una costante di stringa o un numero. Il valore predefinito può inoltre essere una delle speciali parole chiave senza distinzione tra maiuscole e minuscole CURRENT_TIME, CURRENT_DATE o CURRENT_TIMESTAMP. Se il valore è NULL, una costante di stringa o un numero, viene inserito in formato letterale nella colonna ogni volta che un'istruzione INSERT non specifica un valore per la colonna. Se il valore è CURRENT_TIME, CURRENT_DATE o CURRENT_TIMESTAMP, vengono inserite nella colonna la data e/o l'ora UTC. Per CURRENT_TIME, il formato è HH:MM:SS. Per CURRENT_DATE, il formato è YYYY-MM-DD. Il formato per CURRENT_TIMESTAMP è YYYY-MM-DD HH:MM:SS.

Se si specifica PRIMARY KEY normalmente, viene creato solo un indice UNIQUE per la colonna o le colonne corrispondenti. Tuttavia, se il vincolo PRIMARY KEY è impostato su una sola colonna con il tipo di dati INTEGER (o uno dei suoi sinonimi, ad esempio int), tale colonna viene utilizzata dal database come effettiva chiave primaria per la tabella. Ciò significa che la colonna può contenere solo valori interi univoci. (Notate che in molte implementazioni SQLite, solo il tipo di colonna INTEGER fa si che la colonna venga utilizzata come chiave primaria interna, ma in Adobe AIR anche i sinonimi di INTEGER, come int, specificano questo comportamento.)

Se in una tabella non è presente una colonna INTEGER PRIMARY KEY, quando si inserisce una riga viene generata automaticamente una chiave con numero intero. È sempre possibile accedere a una chiave primaria di una riga utilizzando uno dei nomi speciali ROWID, OID o _ROWID_. Questi nomi possono essere utilizzati sia che si tratti di una INTEGER PRIMARY KEY dichiarata in modo esplicito, che di un valore generato internamente. Tuttavia, se la tabella dispone di una INTEGER PRIMARY KEY esplicita, il nome della colonna nei dati risultanti è il nome colonna effettivo anziché il nome speciale.

Una colonna INTEGER PRIMARY KEY può anche includere la parola chiave AUTOINCREMENT. Quando si usa la parola chiave AUTOINCREMENT, il database genera automaticamente e inserisce una chiave con numero intero che viene incrementata in modo sequenziale nella colonna INTEGER PRIMARY KEY quando si esegue un'istruzione INSERT che non specifica un valore esplicito per la colonna.

In un'istruzione CREATE TABLE può essere presente solo un vincolo PRIMARY KEY. Può far parte della definizione di una colonna o essere un vincolo PRIMARY KEY a livello di singola tabella. Una colonna chiave primaria è implicitamente NOT NULL.

conflict-clause (facoltativo) che segue molti vincoli consente di specificare un algoritmo predefinito alternativo per la risoluzione dei conflitti di vincoli per tale vincolo. Il valore predefinito è ABORT. Diversi vincoli all'interno della stessa tabella possono avere diversi algoritmi predefiniti per la risoluzione di conflitti. Se un'istruzione INSERT o UPDATE specifica un diverso algoritmo di risoluzione dei conflitti, tale algoritmo viene utilizzato al posto di quello specificato nell'istruzione CREATE TABLE. Per ulteriori informazioni, vedete la sezione ON CONFLICT di Istruzioni e clausole speciali.

Ulteriori vincoli, ad esempio FOREIGN KEY, non causano errori ma vengono ignorati dal runtime.

Se la parola chiave TEMP o TEMPORARY viene utilizzata tra CREATE e TABLE, la tabella creata sarà visibile solo durante la stessa connessione al database (istanza SQLConnection). Alla chiusura della connessione al database, viene eliminata automaticamente. Anche gli eventuali indici creati su una tabella temporanea sono temporanei. Le tabelle e gli indici temporanei vengono memorizzati in un file distinto e separato dal file di database principale.

Se si specifica il prefisso facoltativo database-name, la tabella viene creata in un database con nome (un database connesso all'istanza SQLConnection mediante una chiamata al metodo attach() con specificato il nome del database). È errato specificare sia un prefisso database-name che la parola chiave TEMP, a meno che il prefisso database-name sia temp. Se non si specifica il nome di un database ed è presente la parola chiave TEMP, la tabella viene creata nel database principale (il database connesso all'istanza SQLConnection utilizzando il metodo open() o openAsync()).

Non vi sono limiti arbitrari al numero di colonne o di vincoli in una tabella. Anche per la quantità di dati in una riga non vi sono limiti arbitrari.

Il formato CREATE TABLE AS definisce la tabella come il risultato di una query. I nomi delle colonne della tabella corrispondono ai nomi delle colonne nel risultato.

Se la clausola opzionale IF NOT EXISTS è presente ed esiste già un'altra tabella con lo stesso nome, il database ignora il comando CREATE TABLE.

È possibile rimuovere una tabella utilizzando l'istruzione DROP TABLE e apportarvi modifiche limitate con l'istruzione ALTER TABLE.

ALTER TABLE

Il comando ALTER TABLE consente all'utente di rinominare o aggiungere una nuova colonna a una tabella esistente. Non è possibile rimuovere una colonna da una tabella.

sql-statement ::= ALTER TABLE [database-name.] table-name alteration 
alteration    ::= RENAME TO new-table-name 
alteration    ::= ADD [COLUMN] column-def

La sintassi RENAME TO viene utilizzata per rinominare la tabella identificata da [database-name.] table-name in new-table-name. Questo comando non può essere utilizzato per spostare una tabella tra database collegati, ma solo per rinominare una tabella all'interno dello stesso database.

Se la tabella da rinominare contiene trigger o indici, questi rimangono collegati alla tabella dopo che è stata rinominata. Tuttavia, se sono presenti definizioni delle viste o istruzioni eseguite da trigger che fanno riferimento alla tabella da rinominare, non verranno modificati automaticamente per utilizzare il nuovo nome di tabella. Se a una tabella rinominata sono associati viste o trigger, dovete eliminare e ricreare manualmente i trigger o le definizioni delle viste utilizzando il nuovo nome della tabella.

La sintassi ADD [COLUMN] viene utilizzata per aggiungere una nuova colonna a una tabella esistente. La nuova colonna viene sempre aggiunta alla fine dell'elenco di colonne esistenti. La clausola column-def può assumere uno qualsiasi dei formati consentiti in un'istruzione CREATE TABLE, con le seguenti restrizioni:

• La colonna non può avere un vincolo PRIMARY KEY o UNIQUE.

• La colonna non può avere un valore predefinito CURRENT_TIME, CURRENT_DATE o CURRENT_TIMESTAMP.

• Se è specificato un vincolo NOT NULL, la colonna deve avere un valore predefinito diverso da NULL.

La quantità di dati presenti nella tabella non incide sul tempo di esecuzione dell'istruzione ALTER TABLE.

DROP TABLE

sql-statement  ::=  DROP TABLE [IF EXISTS] [database-name.] table-name

Per impostazione predefinita, l'istruzione DROP TABLE non riduce le dimensioni del file di database. Lo spazio vuoto nel database viene mantenuto e utilizzato nelle successive operazioni INSERT. Per rimuovere lo spazio libero nel database, potete utilizzare il metodo SQLConnection.clean(). Se il parametro autoClean è impostato su true quando il database viene creato inizialmente, lo spazio viene liberato automaticamente.

La clausola opzionale IF EXISTS elimina l'errore che verrebbe normalmente generato quando la tabella non esiste.

CREATE INDEX

Il comando CREATE INDEX è composto dalle parole chiave CREATE INDEX seguite dal nome del nuovo indice, dalla parola chiave ON, dal nome di una tabella creata in precedenza da indicizzare e da un elenco di nomi tra parentesi delle colonne presenti nella tabella i cui valori vengono utilizzati per la chiave di indice.

sql-statement  ::=  CREATE [UNIQUE] INDEX [IF NOT EXISTS] [database-name.] index-name 
                    ON table-name ( column-name [, column-name]* ) 
column-name    ::=  name [COLLATE collation-name] [ASC | DESC]

Ogni nome di colonna può essere seguito dalla parola chiave ASC o DESC per indicare l'ordinamento, tuttavia questo viene ignorato dal the runtime. L'ordinamento viene sempre applicato in ordine crescente.

La clausola COLLATE che segue ogni nome di colonna definisce una sequenza di confronto utilizzata per i valori di testo in quella colonna. La sequenza di confronto predefinita è quella definita per tale colonna nell'istruzione CREATE TABLE. Se non ne viene specificata una, viene utilizzata la sequenza di confronto BINARY. Per una definizione della clausola COLLATE e delle funzioni di confronto, vedete COLLATE.

Non vi sono limiti arbitrari al numero di indici che è possibile collegare a una singola tabella. Non vi sono inoltre limiti al numero di colonne in un indice.

DROP INDEX

L'istruzione drop index rimuove un indice aggiunto con l'istruzione CREATE INDEX. L'indice specificato viene completamente rimosso dal file del database. Il solo modo di recuperare l'indice consiste nell'immettere di nuovo il comando CREATE INDEX appropriato.

sql-statement ::= DROP INDEX [IF EXISTS] [database-name.] index-name

Per impostazione predefinita, l'istruzione DROP INDEX non riduce le dimensioni del file di database. Lo spazio vuoto nel database viene mantenuto e utilizzato nelle successive operazioni INSERT. Per rimuovere lo spazio libero nel database, potete utilizzare il metodo SQLConnection.clean(). Se il parametro autoClean è impostato su true quando il database viene creato inizialmente, lo spazio viene liberato automaticamente.

CREATE VIEW

Il comando CREATE VIEW assegna un nome a un'istruzione SELECT predefinita. Questo nuovo nome può essere utilizzato in una clausola FROM di un'altra istruzione SELECT al posto del nome di una tabella. Le viste vengono normalmente utilizzate per semplificare le query, combinando un set di dati complesso (e usato di frequente) in una struttura utilizzabile in altre operazioni.

sql-statement ::= CREATE [TEMP | TEMPORARY] VIEW [IF NOT EXISTS] [database-name.] view-name AS select-statement

Se la parola chiave TEMP o TEMPORARY si trova tra CREATE e VIEW, la vista creata è visibile solo nell'istanza SQLConnection con cui è stato aperto il database e viene eliminata automaticamente alla chiusura del database.

Se viene specificato [database-name], la vista viene creata nel database con nome (un database connesso all'istanza SQLConnection mediante il metodo attach(), con specificato l'argomento name. È errato specificare sia [database-name] che la parola chiave TEMP, a meno che [database-name] sia temp. Se non si specifica il nome di un database e la parola chiave TEMP non è presente, la vista viene creata nel database principale (il database connesso all'istanza SQLConnection mediante il metodo open() o openAsync()).

Le viste sono di sola lettura. Un'istruzione DELETE, INSERT o UPDATE non può essere utilizzata in una vista, a meno che non sia definito almeno un trigger del tipo associato (INSTEAD OF DELETE, INSTEAD OF INSERT, INSTEAD OF UPDATE). Per informazioni sulla creazione di un trigger per una vista, vedete CREATE TRIGGER.

Per rimuovere una vista da un database, utilizzate l'istruzione DROP VIEW.

DROP VIEW

L'istruzione DROP VIEW rimuove una vista creata con un'istruzione CREATE VIEW.

sql-statement ::= DROP VIEW [IF EXISTS] view-name

L'argomento view-name specificato è il nome della vista da eliminare. Viene rimossa dal database, ma i dati nelle tabelle sottostanti non vengono modificate.

CREATE TRIGGER

L'istruzione create trigger viene utilizzata per aggiungere trigger allo schema di database. Un trigger è un'operazione di database (trigger-action) che viene eseguita automaticamente quando si verifica un evento del database specificato (database-event).

sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     [BEFORE | AFTER] database-event 
                     ON table-name 
                     trigger-action 
sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     INSTEAD OF database-event 
                     ON view-name 
                     trigger-action 
database-event  ::=  DELETE | 
                     INSERT | 
                     UPDATE | 
                     UPDATE OF column-list 
trigger-action  ::=  [FOR EACH ROW] [WHEN expr] 
                     BEGIN 
                       trigger-step ; 
                       [ trigger-step ; ]* 
                     END 
trigger-step    ::=  update-statement | 
                     insert-statement | 
                     delete-statement | 
                     select-statement 
column-list     ::=  column-name [, column-name]*

Un trigger è impostato in modo che sia attivato quando si verifica un evento DELETE, INSERT o UPDATE di una particolare tabella di database o quando una o più colonne specificate di una tabella vengono aggiornate tramite UPDATE. I trigger sono permanenti, a meno che venga utilizzata la parola chiave TEMP o TEMPORARY. In tal caso, il trigger viene rimosso quando si chiude la connessione dell'istanza SQLConnection al database principale. Se non si specifica una temporizzazione (BEFORE o AFTER), il trigger utilizza per impostazione predefinita BEFORE.

Sono supportati solo i trigger FOR EACH ROW, quindi il testo FOR EACH ROW è opzionale. Con un trigger FOR EACH ROW, le istruzioni trigger-step vengono eseguite per ogni riga di database inserita, aggiornata o eliminata dall'istruzione che causa l'attivazione del trigger, se l'espressione della clausola WHEN restituisce true.

Se viene fornita una clausola WHEN, le istruzioni SQL specificate come fasi del trigger vengono eseguite solo per le righe per cui la clausola WHEN è true. Se non viene fornita alcuna clausola WHEN, le istruzioni SQL vengono eseguite per tutte le righe.

Nel corpo di un trigger (la clausola trigger-action) i valori precedenti e successivi la modifica della tabella interessata sono disponibili utilizzando i nomi di tabella speciali OLD e NEW. La struttura delle tabelle OLD e NEW corrisponde a quella della tabella in cui è stato creato il trigger. La tabella OLD contiene le righe modificate o eliminate dall'istruzione di attivazione del trigger, nello stato in cui erano prima che venissero eseguite le operazioni di tale istruzione. La tabella NEW contiene le righe modificate o create dall'istruzione di attivazione del trigger, nello stato in cui erano dopo l'esecuzione delle operazioni di tale istruzione. Sia la clausola WHEN che le istruzioni trigger-step possono accedere ai valori della riga da inserire, eliminare o aggiornare utilizzando i riferimenti nel formato NEW.column-name e OLD.column-name, dove column-name è il nome di una colonna dalla tabella a cui è associato il trigger. La disponibilità dei riferimenti di tabella OLD e NEW dipende dal tipo di database-event che il trigger gestisce:

• INSERT – NEW sono riferimenti validi

• UPDATE – NEW e OLD sono riferimenti validi

• DELETE – OLD sono riferimenti validi

La temporizzazione specificata (BEFORE, AFTER o INSTEAD OF) determina il tempo di esecuzione delle istruzioni trigger-step relativamente all'inserimento, alla modifica o alla rimozione della riga associata. Una clausola ON CONFLICT può essere specificata come parte di un'istruzione UPDATE o INSERT in un trigger-step. Tuttavia, se si specifica una clausola ON CONFLICT come parte dell'istruzione che determina l'attivazione del trigger, viene invece utilizzato quel criterio di gestione del conflitto.

Oltre ai trigger delle tabelle, è possibile creare un trigger INSTEAD OF in una vista. Se si definiscono uno o più trigger INSTEAD OF INSERT, INSTEAD OF DELETE o INSTEAD OF UPDATE in una vista, non viene considerato come un errore eseguire il tipo di istruzione associato (INSERT, DELETE o UPDATE) sulla vista. In tal caso, l'esecuzione di INSERT, DELETE o UPDATE sulla vista determina l'attivazione dei trigger associati. Poiché il trigger è di tipo INSTEAD OF, le tabelle sottostanti la vista non vengono modificate dall'istruzione che determina l'attivazione del trigger. I trigger possono, tuttavia, essere utilizzati per eseguire operazioni di modifica sulle tabelle sottostanti.

È importante tenere presente un dato importante quando si creano trigger su una tabella con una colonna INTEGER PRIMARY KEY. Se un trigger BEFORE modifica la colonna INTEGER PRIMARY KEY di una riga che deve essere aggiornata da un'istruzione che determina l'attivazione del trigger, l'aggiornamento non viene eseguito. Una soluzione alternativa consiste nel creare la tabella con una colonna PRIMARY KEY anziché una colonna INTEGER PRIMARY KEY.

Per rimuovere un trigger potete utilizzare l'istruzione DROP TRIGGER. Quando si elimina una tabella o una vista, vengono eliminati automaticamente anche tutti i trigger associati alla tabella o alla vista.

Funzione RAISE()

In un'istruzione trigger-step di un trigger può essere utilizzata una speciale funzione SQL RAISE(). La sintassi di questa funzione è la seguente:

raise-function  ::=  RAISE ( ABORT, error-message ) | 
                     RAISE ( FAIL, error-message ) | 
                     RAISE ( ROLLBACK, error-message ) | 
                     RAISE ( IGNORE )

Quando viene chiamato uno dei primi tre formati durante l'esecuzione del trigger, l'azione di elaborazione specificata ON CONFLICT (ABORT, FAIL o ROLLBACK) viene eseguita e l'esecuzione dell'istruzione corrente termina. ROLLBACK è considerato un errore di esecuzione dell'istruzione, quindi il metodo execute() dell'istanza SQLStatement in esecuzione genera un evento error (SQLErrorEvent.ERROR). La proprietà details dell'oggetto SQLError, nella proprietà error dell'oggetto evento inviato, è impostata sull'argomento error-message specificato nella funzione RAISE().

Quando si chiama RAISE(IGNORE), la parte rimanente del trigger corrente, l'istruzione che ha determinato l'esecuzione del trigger e qualsiasi trigger successivo che avrebbe dovuto essere eseguito, vengono abbandonati. Le modifiche del database non vengono annullate. Se l'istruzione che ha determinato l'esecuzione del trigger fa anch'essa parte di un trigger, quel programma trigger riprende l'esecuzione dall'inizio della fase successiva. Per ulteriori informazioni sugli algoritmi di risoluzione dei conflitti, vedete la sezione ON CONFLICT (algoritmi relativi ai conflitti).

DROP TRIGGER

L'istruzione DROP TRIGGER rimuove un trigger creato con l'istruzione CREATE TRIGGER.

sql-statement  ::=  DROP TRIGGER [IF EXISTS] [database-name.] trigger-name

Il trigger viene eliminato dal database. I trigger vengono eliminati automaticamente quando si elimina la tabella associata.

COLLATE

La clausola COLLATE viene utilizzata nelle istruzioni SELECT, CREATE TABLE e CREATE INDEX per specificare l'algoritmo di confronto utilizzato per confrontare oppure ordinare i valori.

sql-statement   ::=  COLLATE collation-name 
collation-name  ::=  BINARY | NOCASE

Il tipo di confronto predefinito per le colonne è BINARY. Quando si utilizza la sequenza di confronto BINARY con i valori della classe di archiviazione TEXT, viene eseguito un confronto binario mediante il confronto dei byte in memoria che rappresentano il valore, indipendentemente dalla codifica del testo.

La sequenza di confronto NOCASE viene applicata solo per i valori della classe di archiviazione TEXT. Quando viene utilizzata, la sequenza di confronto NOCASE esegue un confronto senza distinzione tra maiuscole e minuscole.

Per le classi di archiviazione di tipo NULL, BLOB, INTEGER o REAL non viene utilizzata alcuna sequenza di confronto.

Per utilizzare un tipo di confronto diverso da BINARY con una colonna, è necessario specificare una clausola COLLATE nella definizione della colonna nell'istruzione CREATE TABLE. Ogni volta che si confrontano due valori TEXT, viene utilizzata una sequenza di confronto per determinare i risultati del confronto in base alle seguenti regole:

EXPLAIN

Il modificatore del comando EXPLAIN è un'estensione non standard di SQL.

sql-statement  ::=  EXPLAIN sql-statement

Se la parola chiave EXPLAIN viene inserita prima di qualsiasi altra istruzione SQL, anziché eseguire effettivamente il comando, il risultato riporta la sequenza di istruzioni della macchina virtuale che avrebbe utilizzato per eseguire il comando, se non fosse stata presente la parola chiave EXPLAIN. EXPLAIN è una funzione avanzata che consente agli sviluppatori di modificare il testo delle istruzioni SQL allo scopo di ottimizzare le prestazioni o di eseguire il debug di un'istruzione che apparentemente non funziona nel modo corretto.

ON CONFLICT (algoritmi relativi ai conflitti)

La clausola ON CONFLICT non è un comando SQL separato. È una clausola non standard che può essere inserita in molti altri comandi SQL.

conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-clause     ::=  OR conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | 
                         ABORT | 
                         FAIL | 
                         IGNORE | 
                         REPLACE

Il primo formato della clausola ON CONFLICT, che utilizza le parole chiave ON CONFLICT, viene utilizzato in un'istruzione CREATE TABLE. Per un'istruzione INSERT o UPDATE viene utilizzato il secondo formato, dove ON CONFLICT è sostituito da OR per rendere la sintassi più naturale. Anziché INSERT ON CONFLICT IGNORE, ad esempio, l'istruzione diventa INSERT OR IGNORE. Sebbene la parole chiave siano diverse, il significato della clausola è lo stesso in entrambi i formati.

La clausola ON CONFLICT specifica l'algoritmo utilizzato per risolvere i conflitti dei vincoli. I cinque algoritmi sono ROLLBACK, ABORT, FAIL, IGNORE e REPLACE. L'algoritmo predefinito è ABORT. Di seguito è riportata una spiegazione dei cinque algoritmi relativi ai conflitti:

ROLLBACK

Quando si verifica la violazione di un vincolo, viene eseguito un ROLLBACK immediato che termina la transazione corrente. Il comando si interrompe e l'istruzione SQLStatement invia un evento error. Se non vi sono transazioni attive (oltre alla transazione implicita che viene creata ad ogni comando), questo algoritmo funziona come ABORT.

ABORT

Quando si verifica la violazione di un vincolo, il comando annulla qualsiasi modifica precedentemente apportata e l'istanza SQLStatement invia un evento error. Non viene eseguito alcun ROLLBACK, quindi le modifiche dei comandi precedenti nell'ambito di una transazione vengono mantenute. ABORT corrisponde al comportamento predefinito.

FAIL

Quando si verifica la violazione di un vincolo, il comando si interrompe e SQLStatement invia un evento error. Tuttavia, le eventuali modifiche al database effettuate dall'istruzione prima della violazione del vincolo vengono mantenute ovvero non annullate. Se, ad esempio, un'istruzione UPDATE incontra la violazione di un vincolo alla centesima riga in corso di aggiornamento, le modifiche alle prime 99 righe vengono mantenute, mentre le modifiche alla riga 100 e a quelle successive non vengono applicate.

IGNORE

Quando si verifica la violazione di un vincolo, la riga che contiene tale violazione non viene inserita o modificata. A parte la riga che viene ignorata, l'esecuzione del comando continua normalmente. Le altre righe, prima e dopo quella che contiene la violazione del vincolo, continuano a essere inserite o aggiornate normalmente. Non viene restituito alcun errore.

REPLACE

Quando si verifica la violazione di un vincolo UNIQUE, le righe pre-esistenti che causano tale violazione vengono rimosse prima di inserire o aggiornare la riga corrente. Di conseguenza, l'inserimento o l'aggiornamento viene sempre eseguito e l'esecuzione del comando continua normalmente. Non viene restituito alcun errore. Se si verifica la violazione di un vincolo NOT NULL, il valore NULL viene sostituito dal valore predefinito per quella colonna. Se alla colonna non è associato un valore predefinito, viene utilizzato l'algoritmo ABORT. Se si verifica la violazione di un vincolo CHECK, viene utilizzato l'algoritmo IGNORE. Quando questa strategia di risoluzione dei conflitti elimina delle righe per soddisfare un vincolo, non richiama i trigger di eliminazione su tali righe.

L'algoritmo specificato nella clausola OR di un'istruzione INSERT o UPDATE ignora gli eventuali algoritmi specificati in un'istruzione CREATE TABLE. Se non sono specificati algoritmi nell'istruzione CREATE TABLE oppure nell'istruzione INSERT o UPDATE in esecuzione, viene utilizzato l'algoritmo ABORT.

REINDEX

Il comando REINDEX viene utilizzato per eliminare e ricreare uno o più indici. Questo comando è utile qualora la definizione di una sequenza di confronto sia stata modificata.

sql-statement  ::=  REINDEX collation-name 
sql-statement  ::=  REINDEX [database-name .] ( table-name | index-name )

Nel primo formato, vengono ricreati tutti gli indici in tutti i database collegati che utilizzano la sequenza di confronto denominata. Nel secondo formato, quando è specificato table-name, tutti gli indici associati alla tabella vengono ricreati. Se è specificato un index-name, viene eliminato e ricreato solo l'indice indicato.

COMMENTS

I commenti non sono comandi SQL, ma possono essere presenti nelle query SQL. Vengono gestiti come spazio vuoto dal runtime. Possono iniziare ovunque sia presente uno spazio vuoto, incluse le espressioni interne che si estendono su più righe.

comment             ::=  single-line-comment | 
                         block-comment 
single-line-comment ::=  -- single-line 
block-comment       ::=  /* multiple-lines or block [*/]

Un'unica riga di commento è indicata da due trattini. Un'unica riga di commento si estende solo fino alla fine della riga corrente.

I blocchi di commenti possono estendersi a un numero illimitato di righe o essere incorporati in un'unica riga. Se non è presente un delimitatore di terminazione, un blocco di commenti si estende fino alla fine dell'input. Questa condizione non viene considerata come un errore. Una nuova istruzione SQL può iniziare sulla riga successiva alla fine del blocco di commenti. I blocchi di commenti possono essere incorporati ovunque possa essere inserito uno spazio vuoto, incluse le espressioni interne, e all'interno di altre istruzioni SQL. I blocchi di commenti non vengono nidificati. I commenti a riga singola all'interno di un blocco di commenti vengono ignorati.

EXPRESSIONS

Le espressioni sono sottocomandi all'interno di altri blocchi SQL. Di seguito viene descritta la sintassi valida per un'espressione all'interno di un'istruzione SQL:

expr            ::=  expr binary-op expr | 
                     expr [NOT] like-op expr [ESCAPE expr] | 
                     unary-op expr | 
                     ( expr ) | 
                     column-name | 
                     table-name.column-name | 
                     database-name.table-name.column-name | 
                     literal-value | 
                     parameter | 
                     function-name( expr-list | * ) | 
                     expr ISNULL | 
                     expr NOTNULL | 
                     expr [NOT] BETWEEN expr AND expr | 
                     expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name | 
                     [EXISTS] ( select-statement ) | 
                     CASE [expr] ( WHEN expr THEN expr )+ [ELSE expr] END | 
                     CAST ( expr AS type ) | 
                     expr COLLATE collation-name 
like-op         ::=  LIKE | GLOB 
binary-op       ::=  see Operators 
unary-op        ::=  see Operators 
parameter       ::=  :param-name | @param-name | ? 
value-list      ::=  literal-value [, literal-value]* 
literal-value   ::=  literal-string | literal-number | literal-boolean | literal-blob | literal-null 
literal-string  ::=  'string value' 
literal-number  ::=  integer | number 
literal-boolean  ::=  true | false 
literal-blob  ::=  X'string of hexadecimal data' 
literal-null  ::=  NULL

Un'espressione è una qualsiasi combinazione di valori e operatori che possono essere risolti in un unico valore. Le espressioni possono essere divise in due tipi generali, a seconda se restituiscono un valore booleano (true o false) oppure un valore non booleano.

In molte situazioni comuni, se si include in una clausola WHERE di una clausola HAVING, l'espressione ON in una clausola JOIN e un'espressione CHECK, l'espressione deve restituire un valore booleano. I seguenti tipi di espressioni soddisfano questa condizione:

• ISNULL

• NOTNULL

• IN () �

• EXISTS ()

• LIKE

• GLOB

• Determinate funzioni

• Determinati operatori (in particolare gli operatori di confronto)

I valori letterali

Un valore letterale numerico viene scritto come un numero intero o un numero a virgola mobile. È supportata la notazione scientifica. Come separatore decimale viene sempre utilizzato il carattere . (punto).

Un valore letterale di stringa viene indicato racchiudendo la stringa tra virgolette semplici '. Per includere una virgoletta semplice in una stringa, inserire due virgolette semplici di seguito, come nel seguente esempio: ''.

Un valore letterale booleano viene indicato dal valore true o false. I valori letterali booleani sono utilizzati con il tipi di dati di colonna Boolean.

Un valore letterale BLOB è un valore letterale di stringa che contiene dati esadecimali ed è preceduto da un singolo carattere x o X, ad esempio X'53514697465'.

Un valore letterale può anche essere il token NULL.

Nome di colonna

Un nome di colonna può essere qualsiasi nome definito nell'istruzione CREATE TABLE o uno dei seguenti identificatori speciali: ROWID, OID o _ROWID_. Tutti questi identificatori speciali descrivono la chiave univoca del numero intero casuale (la “chiave di riga”) associata a tutte le righe di tutte le tabelle. Gli identificatori speciali fanno riferimento alla chiave di riga solo se l'istruzione CREATE TABLE non definisce una colonna reale con lo stesso nome. Le chiavi di riga si comportano come colonne di sola lettura. Una chiave di riga può essere utilizzata ovunque possa essere utilizzata una normale colonna, ad eccezione del fatto che non potete modificare il valore di una chiave di riga in un'istruzione UPDATE o INSERT. Nel set di risultati dell'istruzione SELECT * FROM table non è inclusa la chiave di riga.

Istruzione SELECT

Un'istruzione SELECT può essere inclusa in un'espressione come operando a destra dell'operatore IN, come una quantità scalare (un unico valore come risultato), oppure come operando di un operatore EXISTS. Quando viene utilizzata come quantità scalare o come operando di un operatore IN, nel risultato di SELECT può essere presente una sola colonna. È consentita un'istruzione SELECT composta (collegata con parole chiave come UNION o EXCEPT). Con l'operatore EXISTS, le colonne nel set di risultati di SELECT vengono ignorate e l'espressione restituisce TRUE se sono presenti una o più righe e FALSE se il set di risultati è vuoto. Se nessun termine nell'espressione SELECT fa riferimento al valore nella query che la contiene, l'espressione viene valutata una volta prima di qualsiasi altra elaborazione e il risultato viene riutilizzato, se necessario. Se l'espressione SELECT contiene variabili dalla query esterna, nota come sottoquery correlata, l'istruzione SELECT viene valutata di nuovo ogni qualvolta è necessaria.

Quando SELECT è l'operando a destra dell'operatore IN, l'operatore IN restituisce TRUE se il risultato dell'operando a sinistra è uguale a uno qualsiasi dei valori nel set di risultati dell'istruzione SELECT. L'operatore IN può essere preceduto dalla parola chiave NOT per invertire il senso del test.

Quando un'istruzione SELECT è inclusa in un'espressione ma non è l'operando a destra di un operatore IN, la prima riga del risultato di SELECT diventa il valore utilizzato nell'espressione. Se SELECT restituisce più di una riga di risultati, tutte le righe dopo la prima sono ignorate. Se SELECT non restituisce alcuna riga, il valore di SELECT è NULL.

Espressione CAST

Un'espressione CAST modifica il tipo di dati del valore specificato in quello indicato. Il tipo specificato può essere qualsiasi nome di tipo non vuoto valido per il tipo in una definizione di colonna di un'istruzione CREATE TABLE. Per maggiori dettagli, vedete Supporto per i tipi di dati.

Elementi di espressioni aggiuntivi

In queste sezioni vengono descritti gli elementi SQL aggiuntivi che possono essere utilizzati nelle espressioni:

• Funzioni incorporate: funzioni di aggregazione, funzioni scalari e funzioni di formattazione di data e ora

• Operatori

• Parametri

Funzioni di aggregazione

Le funzioni di aggregazione eseguono operazioni su valori di più righe. Queste funzioni vengono utilizzate soprattutto nelle istruzioni SELECT unitamente alla clausola GROUP BY.

In una qualsiasi delle funzioni di aggregazione precedenti che accetta un singolo argomento, tale argomento può essere preceduto dalla parola chiave DISTINCT. In quel caso, gli elementi duplicati vengono filtrati prima di essere passati alla funzione di aggregazione. La chiamata di funzione COUNT(DISTINCT x), ad esempio, restituisce il numero di valori distinti della colonna X anziché il numero totale di valori non NULL nella colonna x.

Funzioni scalari

Le funzioni scalari vengono eseguite sui valori una riga alla volta.

Funzioni di formattazione di data e ora

Le funzioni di formattazione di data e ora sono un gruppo di funzioni scalari utilizzate per creare dati formattati come data e ora. Queste funzioni agiscono su e restituiscono valori di stringa e numerici. Queste funzioni non sono destinate all'uso con il tipo di dati DATE. Se utilizzate queste funzioni sui dati in una colonna il cui tipo di dati dichiarato è DATE, non funzioneranno come previsto.

Formati di ora

Il carattere T in questi formati è un carattere letterale "T" che separa la data e l'ora. Per i formati che includono l'ora, si presuppone la data 2001-01-01.

Modificatori

Operatori comuni

I seguenti operatori binari sono consentiti in un blocco SQL e sono elencati nell'ordine di precedenza dal più alto al più basso:

*    /    % 
+    - 
<< >> &     | 
< >=   > >= 
=    ==   !=   <> IN 
AND 
OR

Di seguito sono elencati gli operatori unari in forma prefissa supportati:

 !    ~    NOT

L'operatore COLLATE può essere considerato come un operatore unario in forma suffissa. L'operatore COLLATE ha la massima precedenza. Viene sempre associato più strettamente di qualsiasi operatore unario in forma prefissa o qualsiasi operatore binario.

Per gli operatori uguale a e non uguale a sono disponibili due varianti. Uguale a può essere = o ==. L'operatore non uguale a può essere != o <>.

L'operatore || è l'operatore di concatenazione di stringhe—unisce le due stringhe dei relativi operandi.

L'operatore % (modulo) restituisce il resto della divisione intera tra l'operando a sinistra e l'operando a destra.

Il risultato di qualsiasi operatore binario è un valore numerico, ad eccezione dell'operatore di concatenazione || che restituisce un risultato in formato stringa.

Operatori SQL

LIKE

L'operatore LIKE esegue un confronto basato sulla ricerca di modelli.

expr     ::=  (column-name | expr) LIKE pattern 
pattern  ::=  '[ string | % | _ ]'

L'operando a destra dell'operatore LIKE contiene il modello, mente l'operatore a sinistra contiene la stringa da confrontare con il modello. Un simbolo di percentuale (%) nel modello costituisce un carattere jolly; corrisponde a qualsiasi sequenza di zero o più caratteri nella stringa. Un simbolo di sottolineatura (_) nel modello corrisponda a un singolo carattere nella stringa. Qualsiasi altro carattere corrisponde a se stesso o al suo equivalente minuscolo/maiuscolo, ovvero la ricerca non fa distinzione tra maiuscole e minuscole. (Nota: il motore di database riconosce solo le maiuscole/minuscole per i caratteri latini a 7 bit. Di conseguenza, l'operatore LIKE fa distinzione tra maiuscole e minuscole per i caratteri iso8859 a 8 bit o caratteri UTF-8. L'espressione 'a' LIKE 'A', ad esempio, è TRUE ma 'æ' LIKE 'Æ' è FALSE). La differenza tra maiuscole e minuscole per i caratteri latini può essere modificata utilizzando la proprietà SQLConnection.caseSensitiveLike.

Se la clausola opzionale ESCAPE è presente, l'espressione che segue la parola chiave ESCAPE deve restituire una stringa formata da un unico carattere. Questo carattere può essere utilizzato nel modello LIKE per trovare caratteri letterali di sottolineatura o di percentuale. Il carattere di escape seguito da un simbolo di percentuale, da un carattere di sottolineatura o dallo stesso carattere di escape corrisponde rispettivamente a un simbolo di percentuale, un carattere di sottolineatura o un carattere di escape letterale nella stringa.

GLOB

L'operatore GLOB è simile a LIKE ma utilizza la sintassi globbing dei file Unix per i caratteri jolly. A differenza di LIKE, GLOB fa distinzione tra maiuscole e minuscole.

IN

L'operatore IN calcola se l'operando a sinistra è uguale a uno dei valori nell'operando a destra (un set di valori tra parentesi).

in-expr         ::=  expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name 
value-list      ::=  literal-value [, literal-value]*

L'operando a destra può essere un set di valori letterali separati da virgole oppure il risultato di un'istruzione SELECT. Per una spiegazione e una descrizione delle limitazioni per l'uso di un'istruzione SELECT come operando a destra dell'operatore IN, consultate la sezione relativa all'uso delle istruzioni SELECT nelle espressioni.

BETWEEN...AND

L'operatore BETWEEN...AND è equivalente all'utilizzo di due espressioni con gli operatori >= e <=. L'espressione x BETWEEN y AND z, ad esempio, equivale a x >= y AND x <= z.

NOT

L'operatore NOT è un operatore di negazione. Gli operatori GLOB, LIKE e IN possono essere preceduti dalla parola chiave NOT per invertire il senso del test (in altre parole, per verificare che un valore non corrisponde al modello indicato).