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
OR
expression = 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.

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
AND
expression <> 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.

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.

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'operator indiqué est appliqué à chaque partie de champs correspondants. (Comme les champs peuvent être de type différent, cela signifie qu'un opérateur différent spécifique peut être sélectionné pour chaque paire.) Tous les opérateurs sélectionnés doivent être des membres d'une classe d'opérateur B-tree, ou être la négation d'un membre = d'une classe d'opérateur B-tree, signifiant que la comparaison du constructeur de lignes est seulement possible quand l'opérateur operator est =, <>, <, <=, > ou >=, ou a une sémantique similaire à l'un d'entre eux.

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.

row_constructor IS DISTINCT FROM row_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 FROM row_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.25.5) ou lors de la comparaison d'un constructeur de ligne et de la sortie d'une sous-requête (comme dans Section 9.24). 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.25.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 64.1.4.3). Ils n'ont pas pour but d'être utilisés dans l'écriture de requêtes.