FirebirdSQL logo

EXISTS

Disponible en

DSQL, PSQL, ESQL.

Syntaxe
[NOT] EXISTS (<select_stmt>)

Le prédicat EXISTS utilise la sous-requête comme argument.Si le résultat de la sous-requête contient au moins une entrée, le prédicat est évalué comme vrai (TRUE), sinon le prédicat est évalué comme faux (FALSE).

Le résultat d’une sous-requête peut contenir plusieurs colonnes, puisque les valeurs ne sont pas vérifiées, mais que seul le fait qu’il y ait des lignes du résultat est enregistré.Ce prédicat ne peut prendre que deux valeurs : VRAI et FAUX.

Le prédicat NOT EXISTS renvoie FALSE si le résultat de la sous-requête contient au moins une entrée, sinon le prédicat renvoie TRUE.

Example 1. Prédicat EXISTS

Trouvez les employés qui ont des projets.

SELECT *
FROM employee
WHERE EXISTS (SELECT *
              FROM
                employee_project ep
              WHERE
                ep.emp_no = employee.emp_no)
Example 2. Prédicat NOT EXISTS

Trouvez les employés qui n’ont pas de projets.

SELECT *
FROM employee
WHERE NOT EXISTS (SELECT *
                  FROM
                    employee_project ep
                  WHERE
                    ep.emp_no = employee.emp_no)

IN

Disponible en

DSQL, PSQL, ESQL.

Syntaxe
<value> [NOT] IN (<select_stmt> | <value_list>)

<value_list> ::= <value_1> [, <value_2> ...]

Le prédicat IN vérifie si la valeur de l’expression à gauche est présente dans l’ensemble des valeurs spécifiées à droite.L’ensemble des valeurs ne peut pas dépasser 1500 éléments.Le prédicat IN peut être réécrit sous la forme équivalente suivante :

(<value> = <value_1> [OR <value> = <value_2> ...])

Lorsque vous utilisez le prédicat IN dans les termes de recherche des requêtes DML, l’optimiseur de Firebird peut utiliser un index sur la colonne recherchée s’il est défini.

Dans la deuxième forme, le prédicat IN vérifie si la valeur de l’expression de gauche est présente (ou absente, lorsqu’on utilise NOT IN) dans le résultat de la sous-requête de droite.Le résultat de la sous-requête ne peut contenir qu’une seule colonne, sinon une erreur sera émise.“count of column list and variable list do not match”.

Les requêtes utilisant le prédicat IN avec une sous-requête peuvent être réécrites en une requête similaire utilisant le prédicat EXISTS.Par exemple, la requête suivante :

SELECT
  model, speed, hd
FROM PC
WHERE
  model IN (SELECT model
            FROM product
            WHERE maker = 'A');

Vous pouvez réécrire une requête similaire en utilisant un prédicat. EXISTS:

SELECT
  model, speed, hd
FROM PC
WHERE
  EXISTS (SELECT *
          FROM product
          WHERE maker = 'A'
            AND product.model = PC.model);

Cependant, une requête utilisant NOT IN ne donnera pas toujours le même résultat qu’une requête NOT EXISTS.La raison en est que le prédicat EXISTS renvoie toujours TRUE ou FALSE, alors que le prédicat IN peut renvoyer NULL dans les cas suivants :

  1. Lorsque la valeur à vérifier est NULL et que la liste dans IN n’est pas vide.

  2. Lorsque la valeur à vérifier n’est pas une correspondance dans la liste IN et que l’une des valeurs est NULL.

Dans ces deux cas, le prédicat IN renverra NULL, tandis que le prédicat EXISTS correspondant renverra FALSE.Dans les conditions de recherche ou l’opérateur IF, les deux résultats indiquent `Fail' et sont traités de la même manière.

Cependant, sur les mêmes données, NOT IN retournera NULL, alors que EXISTS retournera TRUE, ce qui provoquera le résultat inverse.

C’est ce que montre l’exemple suivant.

Supposons que vous ayez une requête comme celle-ci :

-- Je cherche des gens qui ne sont pas nés le même jour que...
-- Des habitants célèbres de New York
SELECT P1.name AS NAME
FROM Personnel P1
WHERE P1.birthday NOT IN (SELECT C1.birthday
                          FROM Celebrities C1
                          WHERE C1.birthcity = 'New York');

On peut supposer qu’une requête utilisant un prédicat produira un résultat similaire NOT EXISTS:

-- Je cherche des gens qui ne sont pas nés le même jour que...
-- des habitants célèbres de New York
SELECT P1.name AS NAME
FROM Personnel P1
WHERE NOT EXISTS (SELECT *
                  FROM Celebrities C1
                  WHERE C1.birthcity = 'New York'
                    AND C1.birthday = P1.birthday);

Supposons qu’il n’y ait qu’un seul résident connu à New York et que sa date de naissance soit inconnue.Lorsque vous utilisez le prédicat EXISTS, la sous-requête qu’il contient ne produira pas de résultats car la comparaison des dates de naissance à NULL donnera UNKNOWN.Ainsi, le résultat du prédicat NOT EXISTS sera vrai pour chaque ligne de la requête principale.Alors que le résultat du prédicat NOT IN sera UNKNOWN et aucune ligne ne sera affichée.

Example 1. Prédicat IN

Trouver des employés avec des noms “Pete”, “Ann” et “Roger”:

SELECT *
FROM EMPLOYEE
WHERE FIRST_NAME IN ('Pete', 'Ann', 'Roger');
Example 2. Prédicat de recherche IN

Trouvez tous les ordinateurs pour lesquels il existe des modèles dont le fabricant commence par la lettre “A”:

SELECT
  model, speed, hd
FROM PC
WHERE
  model IN (SELECT model
            FROM product
            WHERE maker STARTING WITH 'A');
Voir aussi :

EXISTS.

SINGULAR

Disponible en

DSQL, PSQL, ESQL.

Syntaxe
[NOT] SINGULAR (<select_stmt>)

Le prédicat SINGULAR utilise la sous-requête comme argument et l’évalue comme vrai si la sous-requête retourne une et une seule ligne de résultat, sinon le prédicat est évalué comme faux.Le résultat de la sous-requête peut contenir plusieurs colonnes, puisque les valeurs ne sont pas vérifiées.Ce prédicat ne peut prendre que deux valeurs : vrai (TRUE) et faux (FALSE).

Example 1. Prédicat SINGULAR

Trouvez les employés qui n’ont qu’un seul projet.

SELECT *
FROM employee
WHERE SINGULAR (SELECT *
                FROM
                  employee_project ep
                WHERE
                  ep.emp_no = employee.emp_no)

Prédicats de sous-requêtes quantitatives

Un quantor est un opérateur logique qui spécifie le nombre d’objets pour lesquels une déclaration donnée est vraie.Il s’agit d’une quantité logique, et non d’une quantité numérique ; elle associe l’énoncé à l’ensemble des objets possibles.Ces prédicats sont basés sur les quantificateurs logiques formels de généralité et d’existence, qui sont reconnus par la logique formelle.

Dans les expressions de sous-requêtes, les prédicats quantitatifs permettent de comparer des valeurs individuelles aux résultats des sous-requêtes ; leur forme courante :

<value expression> <comparison operator> <quantifier> <subquery>

ALL

Disponible en

DSQL, PSQL.

Syntaxe
<value> <op> ALL (<select_stmt>)

En utilisant le quantificateur ALL, le prédicat est vrai si chaque valeur sélectionnée par la sous-requête satisfait à la condition du prédicat de la requête externe.Si la sous-requête ne renvoie aucune chaîne, le prédicat est automatiquement considéré comme vrai.

Example 1. Prédicat ALL

Ne faites resortir que les clients dont le score est supérieur à celui de chaque client de Paris.

SELECT *
FROM Customers
WHERE rating > ALL
      (SELECT rating
       FROM Customers
       WHERE city = 'Paris')
Important

Si la sous-requête renvoie un ensemble vide, alors le prédicat sera vrai pour chaque valeur gauchère, quel que soit l’opérateur.Cela peut sembler étrange et contradictoire, car dans ce cas, chaque valeur de la main gauche est traitée comme étant simultanément supérieure, inférieure, égale et inégale à toute valeur du courant de la main droite.

Cependant, ceci est normalement cohérent avec la logique formelle : si un ensemble est vide, alors le prédicat est vrai 0 fois, soitpour chaque ligne de l’ensemble.

ANY et SOME

Disponible en

DSQL, PSQL.

Syntaxe
<value> <op> {ANY | SOME} (<select_stmt>)

Ces deux quantificateurs ont un comportement identique.Apparemment, les deux sont introduits dans la norme SQL pour une utilisation interchangeable afin d’améliorer la lisibilité des déclarations.Lorsque le quantificateur ANY ou SOME est utilisé, le prédicat est vrai si l’une des valeurs sélectionnées par la sous-requête satisfait à la condition du prédicat de la requête externe.Si la sous-requête ne renvoie aucune chaîne, le prédicat est automatiquement considéré comme faux.

Example 1. Prédicat ANY

Ne faites resortir que les clients dont les scores sont supérieurs à ceux de tous les clients de Rome.

SELECT *
FROM Customers
WHERE rating > ANY
      (SELECT rating
       FROM Customers
       WHERE city = 'Rome')