expression IN (valeur [, ...])

Le côté droit est une liste entre parenthèses d'expressions scalaires. Le résultat est vrai (« true ») si le côté gauche de l'expression est égal à une des expressions du côté droit. C'est une notation raccourcie de

expression = valeur1
OR
expression = valeur2
OR
...

Si l'expression du côté gauche renvoie NULL, ou s'il n'y a pas de valeur égale du côté droit et qu'au moins une expression du côté droit renvoie NULL, le résultat de la construction IN est NULL et non pas faux. Ceci est en accord avec les règles du standard SQL pour les combinaisons booléennes de valeurs NULL.

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

Le côté droit est une liste entre parenthèses d'expressions scalaires. Le résultat est vrai (« true ») si le résultat de l'expression du côté gauche est différent de toutes les expressions du côté droit. C'est une notation raccourcie de

expression <> valeur1
AND
expression <> valeur2
AND
...

Si l'expression du côté gauche renvoie NULL, ou s'il existe des valeurs différentes du côté droit et qu'au moins une expression du côté droit renvoie NULL, le résultat de la construction NOT IN est NULL et non pas vrai. Ceci est en accord avec les règles du standard du SQL pour les combinaisons booléennes de valeurs NULL.

expression opérateur ANY (expression tableau)
expression opérateur SOME (expression tableau)

Le côté droit est une expression entre parenthèses qui doit renvoyer une valeur de type array. L'expression du côté gauche est évaluée et comparée à chaque élément du tableau en utilisant l'opérateur donné, qui doit renvoyer un résultat booléen. Le résultat de ANY est vrai (« true ») si un résultat vrai est obtenu. Le résultat est faux (« false ») si aucun résultat vrai n'est trouvé (ce qui inclut le cas spécial du tableau qui ne contient aucun élément).

Si l'expression de tableau ramène un tableau NULL, le résultat de ANY est NULL. Si l'expression du côté gauche retourne NULL, le résultat de ANY est habituellement NULL (bien qu'un opérateur de comparaison non strict puisse conduire à un résultat différent). De plus, si le tableau du côté droit contient des éléments NULL et qu'aucune comparaison vraie n'est obtenue, le résultat de ANY est NULL, et non pas faux (« false ») (là aussi avec l'hypothèse d'un opérateur de comparaison strict). Ceci est en accord avec les règles du standard SQL pour les combinaisons booléennes de valeurs NULL.

SOME est un synonyme de ANY.

expression opérateur ALL (expression tableau)

Le côté droit est une expression entre parenthèses qui doit renvoyer une valeur de type tableau. L'expression du côté gauche est évaluée et comparée à chaque élément du tableau à l'aide de l'opérateur donné, qui doit renvoyer un résultat booléen. Le résultat de ALL est vrai (« true ») si toutes les comparaisons renvoient vrai (ce qui inclut le cas spécial du tableau qui ne contient aucun élément). Le résultat est faux (« false ») si un résultat faux est trouvé.

Si l'expression de tableau ramène un tableau NULL, le résultat de ALL est NULL. Si l'expression du côté gauche retourne NULL, le résultat de ALL est habituellement NULL (bien qu'un opérateur de comparaison non strict puisse conduire à un résultat différent). De plus, si le tableau du côté droit contient des éléments NULL et qu'aucune comparaison false n'est obtenue, le résultat de ALL est NULL, et non pas true (là aussi avec l'hypothèse d'un opérateur de comparaison strict). Ceci est en accord avec les règles du standard SQL pour les combinaisons booléennes de valeurs NULL.

constructeur_ligne opérateur constructeur_ligne

Chaque côté est un constructeur de lignes, tel que décrit dans la Section 4.2.13. Les deux valeurs de lignes doivent avoir le même nombre de colonnes. Chaque côté est évalué. Ils sont alors comparés sur toute la ligne. Les comparaisons de constructeur de lignes sont autorisées quand l'opérateur est =, <>, <, <=, >, >=. Chaque élément de ligne doit être d'un type qui dispose d'une classe d'opérateur B-tree. Dans le cas contraire, la tentative de comparaison pourrait générer une erreur.

Les cas = et <> fonctionnent légèrement différemment des autres. Les lignes sont considérées égales si leurs membres correspondants sont non-nuls et égaux ; les lignes sont différentes si des membres correspondants sont non-nuls et différents ; autrement, le résultat de la comparaison de ligne est inconnu (NULL).

Pour les cas <, <=, > et >=, les éléments de ligne sont comparés de gauche à droite. La comparaison s'arrête dès qu'une paire d'éléments différents ou NULL est découverte. Si un des éléments de cette paire est NULL, le résultat de la comparaison de la ligne est inconnu, donc 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) est vrai, non NULL, car la troisième paire d'éléments n'est pas considérée.

constructeur_ligne IS DISTINCT FROM constructeur_ligne

Cette construction est similaire à une comparaison de ligne <>, mais elle ne conduit pas à un résultat NULL pour des entrées NULL. Au lieu de cela, une valeur NULL est considérée différente (distincte) d'une valeur non-NULL et deux valeurs NULL sont considérées égales (non distinctes). Du coup, le résultat est toujours soit true soit false, jamais NULL.

constructeur_ligne IS NOT DISTINCT FROM constructeur_ligne
    

Cette construction est similaire à une comparaison de lignes =, mais elle ne conduit pas à un résultat NULL pour des entrées NULL. Au lieu de cela, une valeur NULL est considérée différente (distincte) d'une valeur non NULL et deux valeurs NULL sont considérées identiques (non distinctes). Du coup, le résultat est toujours soit true soit false, jamais NULL.

record opérateur record
    

Le standard SQL requiert que les comparaisons de ligne renvoient NULL si le résultat dépend de la comparaison de valeurs NUL ou d'une valeur NULL et d'une valeur non NULL. PostgreSQL ne fait cela que lors de la comparaison de deux constructeurs de ligne (comme dans Section 9.23.5) ou lors de la comparaison d'un constructeur de ligne avec la sortie d'une sous-requête (comme dans Section 9.22). Dans les autres contextes où deux valeurs de type composite sont comparés, deux valeurs NULL sont considérées identiques et une valeur NULL est considérée plus grande qu'une valeur non NULL. Ceci est nécessaire pour avoir un comportement cohérent des tris et de l'indexage pour les types composites.

Chaque côté est évalué et est comparé au niveau de la ligne. Les comparaisons de type composite sont autorisées quand l'opérateur est =, <>, <, <=, > ou >=, ou a une sémantique similaire à l'une d'entre elles. (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 un opérateur de négation du membre = d'une classe d'opérateur B-tree.) Le comportement par défaut des opérateurs ci-dessus est le même que pour IS [ NOT ] DISTINCT FROM pour les constructeurs de lignes (voir Section 9.23.5).

Pour accepter la correspondance des lignes qui incluent des éléments sans 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 des deux lignes. Les deux lignes peuvent avoir une représentation binaire différente même si leur comparaison avec l'opérateur d'égalité est vraie. L'ordre des lignes avec ces opérateurs de comparaison est déterminé, mais sans sens particulier. Ces opérateurs sont utilisés en interne pour les vues matérialisées et pourraient être utiles dans d'autres cas très ciblés, comme la réplication. Cependant, elles ne sont pas généralement utiles pour écrire des requêtes.