Documentazione di PostgreSQL 9.0 > Il linguaggio SQL > Funzioni e Operatori > Confronti di array e righe
PrecedenteEspressioni sottoqueryFunzioni che ritornano insiemiSuccessivo

9.21. Confronti di array e righe

Questa sezione descrive diversi costrutti specializzati per fare confronti multipli tra gruppi di valori. Queste forme sono riferite sintatticamente alle forme di sottoquery della sezione precedente, ma non coinvolgono le sottoquery. Le forme che coinvolgono subespressioni array sono estensioni di PostgreSQL™; le restanti sono conformi-SQL. Tutte le forme di espressioni documentate in questa sezione restituiscono risultati Booleani (true/false).

9.21.1. IN

    expression 
    IN (value [, ...])

La parte destra è una lista di espressioni scalari tra parentesi. Il risultato è «vero» se il risultato dell'espressione nella parte sinistra è uguale a qualcuna delle righe nell'espressione della parte destra. Questa è una notazione abbreviata per

expression = value1
OR
expression = value2
OR
...

Notare che se l'espressione a sinistra rende null, o se non ci sono valori uguali nella parte destra e almeno una espressione nella parte destra rende null, il risultato del costrutto IN sarà null, non falso. Questo è conforme con le normali regole SQL per le combinazioni Booleane di valori null.

9.21.2. NOT IN

    expression 
    NOT IN (value [, ...])

La parte destra è un elenco di espressioni scalari tra parentesi. Il risultato è «vero» se il risultato dell'espressione della parte sinistra è non uguale a tutte le espressioni della parte destra. Questa è una notazione abbreviata per

expression <> value1
AND
expression <> value2
AND
...

Notare che se l'espressione nella parte sinistra rende null, o se non ci sono valori uguali nella parte destra e almeno una espressione nella parte destra rende null, il risultato del costrutto NOT IN sarà null, non vero come ci si potrebbe ingenuamente aspettare. Questo è conforme alle normali regole SQL per le combinazioni Booleane di valori null.

[Suggerimento]

Suggerimento

La forma x NOT IN y è equivalente a NOT (x IN y) in tutti i casi. Tuttavia, è molto più probabile inciampare in valori null quando si lavora con NOT IN, che quando si lavora con IN. Se possibile, è meglio esprimere le condizioni positivamente.

9.21.3. ANY/SOME (array)

expression operator 
ANY (array expression)
expression operator 
SOME (array expression)

La parte destra è una espressione tra parentesi, che rende un valore array. L'espressione a sinistra viene valutata e confrontata con ogni elemento dell'array utilizzando l'operatore fornito, che deve rendere un risultato booleano. Il risultato di ANY è «true» se viene ottenuto qualche risultato vero. Il risultato è «false» se non viene ottenuto nessun risultato vero (compreso il caso speciale in cui l'array ha zero elementi).

Se l'espressione array rende un array null, il risultato di ANY sarà null. Se l'espressione della parte sinistra rende null, il risultato di ANY è normalmente null (sebbene un operatore di confronto non-rigoroso potrebbe dare un risultato diverso). Inoltre, se l'array nella parte destra contiene alcuni elementi null e non viene ottenuto nessun risultato di confronto vero, il risultato di ANY sarà null, non falso (ancora, presumendo un operatore di confronto rigoroso). Questo è conforme alle normali regole SQL per le combinazioni Booleane di valori null.

SOME è un sinonimo di ANY.

9.21.4. ALL (array)

expression operator ALL (array expression)

La parte destra è una espressione tra parentesi, che deve rendere un valore array. L'espressione a sinistra viene valutata e confrontata con ogni elemento dell'array usando l'operatore fornito, che deve rendere un risultato Booleano. Il risultato di ALL è «true» se tutti i confronti rendono vero (compreso il caso speciale in cui l'array ha zero elementi). Il risultato è «false» se viene trovato qualche risultato falso.

Se l'espressione array rende un array null, il risultato di ALL sarà null. Se l'espressione nella parte sinistra rende null, il risultato di ALL è normalmente null (sebbene un operatore di confronto non-rigoroso potrebbe dare un risultato diverso). Inoltre, se l'array a destra contiene qualche elemento null nessun risultato falso viene ottenuto dal confronto, il risultato di ALL sarà null, non vero (ancora, presumendo un operatore di confronto rigoroso). Questo è conforme alle normali regole SQL per le combinazioni Booleane di valori null.

9.21.5. Confronto Row-wise

row_constructor operator row_constructor

Ambedue le parti destra e sinistra sono costruttori di riga, come descritto dentro Sezione 4.2.12, «Costruttori di riga». I due valori di riga devono avere lo stesso numero di campi. Ogni parte viene valutata e quindi confrontata row-wise. I confronti di riga sono consentiti quando l'operatore è =, <>, <, <=, > o >=, o ha una semantica simile ad uno di questi. (Per chiarire, un operatore può essere un operatore di confronto di riga se è un membro di una classe di operatori B-Tree, oppure è la negazione del membro = di una classe di operatori B-Tree).

I casi = e <> lavorano in modo leggermente diverso dagli altri. Due righe vengono considerate uguali se tutti i loro membri corrispondenti sono non-null ed uguali; le righe sono non uguali se alcuni membri corrispondenti sono non-null e non-uguali; altrimenti il risultato del confronto di riga è sconosciuto (null).

Per i casi <, <=, > e >=, gli elementi di riga sono confrontati da sinistra a destra, fermandosi non appene viene trovata una coppia di elementi non uguali o null. Se ognuno degli elementi della coppia è null, il risultato del confronto di riga è sconosciuto (null); altrimenti il confronto di questa coppia di elementi determina il risultato. Per esempio, ROW(1,2,NULL) < ROW(1,3,0) rende vero, non null, perchè il terzo paio di elementi non viene considerato.

[Nota]

Nota

Prima di PostgreSQL™ 8.2, i casi <, <=, > e >= non erano gestiti per le specifiche SQL. Un confronto tipo ROW(a,b) < ROW(c,d) era implementato come a < c AND b < d mentre il comportamento corretto è equivalente a a < c OR (a = c AND b < d).

row_constructor IS DISTINCT FROM row_constructor

Questo costrutto è simile al confronto di riga <>, ma esso non rende null per valori di input null. Invece, qualsiasi valore null viene considerato non uguale a (distinct from) ogni valore non-null, e ogni due null sono considerati uguali (not distinct). Per cui, il risultato sarà sempre true o false, mai null.

row_constructor IS NOT DISTINCT FROM row_constructor

Questo costrutto è simile al confronto di riga =, ma esso non rende null per ingressi null. Invece ogni valore null viene considerato non uguale a (distinct from) ogni valore non null, e due valori null sono considerati uguali (not distinct). Per cui il risultato sarà sempre vero o falso, mai null.

[Nota]

Nota

La specifica SQL richiede che il confronto row-wise renda NULL se il risultato dipende dal confronto di valori NULL o di un NULL e un non-NULL. PostgreSQL™ fa questo solo quando si confrontano i risultati di 2 costruttori di riga o si confronta un costruttore di riga con l'output di una sottoquery (come in Sezione 9.20, «Espressioni sottoquery»). In altri contesti dove due valori di tipi-composti sono comparati, due valori NULL sono considerati uguali, ue un NULL è considerato più grande di un non-NULL. Questo è necessario per avere comportamenti di ordinamento e indicizzazione consistenti per i tipi composti.

Documentazione di PostgreSQL 9.0 > Il linguaggio SQL > Funzioni e Operatori > Confronti di array e righe
PrecedenteEspressioni sottoqueryFunzioni che ritornano insiemiSuccessivo