PostgreSQLLa base de données la plus sophistiquée au monde.
Documentation PostgreSQL 13.1 » Langage SQL » Fonctions et opérateurs » Comparaisons de ligne et de tableau

9.24. Comparaisons de ligne et de tableau

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).

9.24.1. IN

expression IN (value [, ...])

Le côté droit est une liste entre parenthèses d'expressions scalaires. 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.

9.24.2. NOT IN

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

Le côté droit est une liste entre parenthèses d'expressions scalaires. 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.

Astuce

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.

9.24.3. 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.

9.24.4. 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.

9.24.5. Comparaison de constructeur de lignes

row_constructor operator row_constructor

Chaque côté est un constructeur de lignes, comme décrit dans Section 4.2.13. Les deux valeurs de lignes doivent avoir le même nombre de champs. Chaque côté est évalué et est comparé ligne par ligne. Les comparaisons de constructeur de lignes sont autorisées quand l'opérateuroperator est =, <>, <, <=, > ou >=. Chaque élément de ligne doit être d'un type disposant d'une classe d'opérateur B-tree par défaut. Dans le cas contraire, la tentative de comparaison renverra une erreur.

Note

Les erreurs relatives au nombre ou aux types des éléments ne surviennent pas si la comparaison est résolue en utilisant les premières colonnes.

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.

Note

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

9.24.6. Comparaison de type composite

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 63.4.2). Ils n'ont pas pour but d'être utilisés dans l'écriture de requêtes.