Cette section décrit plusieurs constructions spécialisées pour réaliser plusieurs comparaisons entre des groupes de valeurs. Ces formes sont syntaxiquement en relation avec les formes de sous-requêtes de la section précédente, mais n'impliquent pas de sous-requêtes. Les formes qui impliquent des sous-expressions de tableau sont des extensions PostgreSQL ; le reste est compatible avec la norme SQL. Toutes les formes d'expression documentées dans cette section renvoient des résultats booléens (true/false).
IN
expression
IN (value
[, ...])
Le côté droit est une liste entre parenthèses d'expressions. Le résultat est « true » si le résultat de l'expression côté gauche est égal à une des expressions côté droit. Cette notation est un raccourci pour
expression
=value1
ORexpression
=value2
OR ...
Notez que si l'expression côté gauche renvoie NULL ou s'il n'existe pas de
valeurs identiques côté droit et qu'au moins une expression côté droit
renvoie NULL, le résultat de la construction IN
sera NULL,
et non pas false. Ceci est en accord avec les règles SQL habituelles pour
les combinaisons booléennes de valeurs NULL.
NOT IN
expression
NOT IN (value
[, ...])
Le côté droit est une liste entre parenthèses d'expressions. Le résultat est « true » si le résultat de l'expression côté gauche est différent à toutes les expressions côté droit. Cette notation est un raccourci pour
expression
<>value1
ANDexpression
<>value2
AND ...
Notez que si l'expression côté gauche renvoie NULL ou s'il n'existe pas de
valeurs identiques côté droit et qu'au moins une expression côté droit
renvoie NULL, le résultat de la construction NOT IN
sera
NULL, et non pas true comme on pourrait s'y attendre. Ceci est en accord
avec les règles SQL habituelles pour les combinaisons booléennes de valeurs
NULL.
x NOT IN y
est équivalent à NOT (x IN
y)
dans tous les cas. Néanmoins, les valeurs NULL risquent bien
plus souvent de tromper le novice lorsqu'il travaille avec NOT
IN
que quand il travaille avec IN
. Il est préférable
d'exprimer votre condition de façon positive si possible.
ANY
/SOME
(array)expression
operator
ANY (array expression
)expression
operator
SOME (array expression
)
Le côté droit est une expression entre parenthèses, qui doit renvoyer une
valeur de type tableau. L'expression côté gauche est évaluée et comparée à
chaque élément du tableau en utilisant l'opérateur
operator
indiqué, qui doit renvoyer un résultat
booléen. Le résultat de ANY
vaut « true » si
aucun résultat true n'est obtenu. Le résultat vaut « false » si
aucun résultat true n'est trouvé (y compris dans le cas où le tableau a
zéro élément).
Si l'expression de tableau renvoie un tableau NULL, le résultat de
ANY
sera NULL. Si l'expression côté gauche renvoie NULL, le
résultat de ANY
est habituellement NULL (bien qu'un
opérateur de comparaison non strict pourrait renvoyer un résultat
différent). De plus, si le tableau côté droit contient des éléments NULL et
qu'aucun résultat de la comparaison ne renvoie true, le résultat d'
ANY
sera NULL, et non pas false (encore une fois, en
supposant un opérateur de comparaison strict). Ceci est en accord avec les
règles SQL habituelles pour la combinaison booléenne de valeurs NULL.
SOME
est un synonyme pour ANY
.
ALL
(array)expression
operator
ALL (array expression
)
Le côté droit est une expression entre parenthèses, qui doit renvoyer une
valeur de type tableau. L'expression côté gauche est évaluée et comparée à
chaque élément du tableau en utilisant l'opérateur
operator
indiqué, qui doit renvoyer un résultat
booléen. Le résultat de ALL
vaut « true » si
toutes les comparaisons ramènent true (y compris dans le cas où le tableau
a zéro élément). Le résultat vaut « false » si au moins un
résultat false est trouvé.
Si l'expression de tableau renvoie un tableau NULL, le résultat de
ALL
sera NULL. Si l'expression côté gauche renvoie NULL, le
résultat de ALL
est habituellement NULL (bien qu'un
opérateur de comparaison non strict pourrait renvoyer un résultat
différent). De plus, si le tableau côté droit contient au moins un élément
NULL et qu'aucun résultat de la comparaison ne renvoie false, le résultat
de ALL
sera NULL, et non pas true (encore une fois, en
supposant un opérateur de comparaison strict). Ceci est en accord avec les
règles SQL habituelles pour la combinaison booléenne de valeurs NULL.
row_constructor
operator
row_constructor
Chaque côté est un constructeur de lignes, comme décrit dans Section 4.2.13.
Les deux constructeurs de lignes doivent avoir le même nombre de champs.
L'opérateur
indiqué est appliqué à chaque paire
de champs correspondant. (Comme les champs pourraient être de types
différents, ceci signifie qu'un opérateur spécifique différent pourrait être
sélectionné pour chaque paire.)
Tous les opérateurs sélectionnés doivent être les membres
d'une classe d'opérateur B-tree ou être l'inverse d'un membre
=
d'une classe d'opérateur B-tree, ceci signifiant
que la comparaison de constructeur de lignes est seulement possible
quand l'opérateur operator
est
=
,
<>
,
<
,
<=
,
>
ou
>=
, ou a une sémantique similaire à l'une d'entre
elles.
Les cas =
et <>
fonctionnent
légèrement différemment des autres. Les deux lignes sont considérées égales
si tous leurs membres correspondant sont non NULL et égaux ; les
lignes sont différentes si un des membres correspondant est non NULL et
différent ; sinon le résultat de la comparaison est inconnu (NULL).
Pour les cas <
, <=
,
>
et >=
, les éléments de ligne
sont comparés de gauche à droite, en s'arrêtant dès qu'une paire
d'éléments différents ou NULL est trouvée. Si un des éléments est NULL, le
résultat de la comparaison est inconnu (NULL) ,; sinon la comparaison
de cette paire d'éléments détermine le résultat. Par exemple,
ROW(1,2,NULL) < ROW(1,3,0)
renvoie true, et non pas
NULL, parce que la troisième paire d'éléments n'est pas considérée.
Avant PostgreSQL 8.2, les cas
<
, <=
, >
et >=
n'étaient pas gérés par la spécification SQL.
Une comparaison comme ROW(a,b) < ROW(c,d)
était
implémentée comme a < c AND b < d
alors que le
comportement correct est équivalent à a < c OR (a = c AND b
< d)
.
row_constructor
IS DISTINCT FROMrow_constructor
Cette construction est similaire à une comparaison de ligne
<>
mais elle ne renvoie pas NULL pour des entrées
NULL. À la place, toute valeur NULL est considérée différente (distincte
de) toute valeur non NULL, et deux valeurs NULL sont considérées égales
(non distinctes). De ce fait, le résultat sera soit true, soit false, mais
jamais NULL.
row_constructor
IS NOT DISTINCT FROMrow_constructor
Cette construction est similaire à une comparaison de ligne
=
mais elle ne renvoie pas NULL pour des entrées NULL. À
la place, toute valeur NULL est considérée différente (distincte de) toute
valeur non NULL, et deux valeurs NULL sont considérés égales (non
distinctes). De ce fait, le résultat sera toujours soit true soit false,
mais jamais NULL.
record
operator
record
La spécification SQL requiert que la comparaison de lignes renvoie NULL si le résultat depend de la comparaison de deux valeurs NULL, ou d'un NULL et d'un non NULL. PostgreSQL le fait seulement lors de la comparaison des résultats de deux constructeurs de ligne (comme dans Section 9.24.5) ou lors de la comparaison d'un constructeur de ligne et de la sortie d'une sous-requête (comme dans Section 9.23). Dans les autres contextes où les valeurs de deux types composites sont comparées, deux valeurs NULL sont considérées égales et un NULL est considéré plus grand qu'un non NULL. Ceci est nécessaire pour avoir un tri et une indexation cohérentes pour les types composites.
Chaque côté est évalué, puis comparé ligne par ligne. Les comparaisons de
type composite sont autorisées quand l'opérateur
operator
vaut
=
,
<>
,
<
,
<=
,
>
ou
>=
,
ou a une sémantique similaire à ces derniers. (Pour être précis, un
opérateur peut être un opérateur de comparaison de ligne s'il est membre
d'une classe d'opérateur B-tree, ou s'il est la négation du membre
=
d'une classe d'opérateur B-tree.) Le comportement par
défaut des opérateurs ci-dessus est identique à celui de IS [ NOT
] DISTINCT FROM
pour les constructeurs de lignes (voir Section 9.24.5).
Pour supporter la comparaison des lignes qui incluent des éléments sans une
classe d'opérateur B-tree par défaut, les opérateurs suivants sont définis
pour la comparaison de type composite :
*=
,
*<>
,
*<
,
*<=
,
*>
et
*>=
.
Ces opérateurs comparent la représentation binaire interne de deux lignes.
Les deux lignes peuvent avoir une représentation binaire différente même si
la comparaison des deux lignes avec l'opérateur d'égalité est vraie.
L'ordre des lignes sous ces opérateurs de comparaison est déterministique,
mais sans sens. Ces opérateurs sont utilisés en interne pour les vues
matérialisées et peuvent se révéler utile pour d'autres buts spécialisés
tels que la réplication et la déduplication de B-Tree (voir Section 67.4.3). Ils n'ont pas pour but d'être utilisés
dans l'écriture de requêtes.