Mysql dans la clause

Ce tutoriel discutera de l'utilisation du Mysql dans la requête Pour vérifier si une valeur spécifique se situe dans un ensemble de valeurs, ce qui est utile pour remplacer un ensemble ou des opérateurs.

Syntaxe de base

Le MySQL dans l'opérateur est assez simple. Il fonctionne en vérifiant si un ensemble a une correspondance pour la valeur spécifiée.

La syntaxe générale de la requête est:

Sélectionnez Col_Names dans Table_Name Where Expression in (Value_Sets);

Dans la syntaxe ci-dessus, nous spécifions la fonction à exécuter. Ça peut être un Sélectionnez, insérer, supprimer, mettre à jour, etc.

Ensuite, nous spécifions le nom du tableau à partir de laquelle effectuer l'action spécifiée ci-dessus.

La partie suivante est la Où clause, où nous spécifions l'expression ou la valeur pour évaluer. C'est la valeur que nous testons dans les ensembles de valeurs sur le côté droit du En clause.

À droite de la clause, nous spécifions les valeurs à partir desquelles la recherche de l'expression correspondante.

Si la En clause trouve une correspondance sur l'ensemble de valeurs spécifié, il renvoie un 1, indiquant vrai, et un 0, indiquant faux.

Mysql dans des exemples de clause

Voici des exemples pour illustrer la clause in:

Exemple 1

Un cas d'utilisation simple pour le Dans l'opérateur est de vérifier une seule valeur dans un ensemble. Par exemple, nous pouvons vérifier si le personnage 'UN' est dans un ensemble de caractères.

Sélectionnez 'A' dans ('A', 'B', 'C', 'D');

Dans l'exemple ci-dessus, nous vérifions si le personnage 'UN' est Dans un ensemble de caractères ABCD.

La requête ci-dessus doit retourner 1 si elle est vraie, comme indiqué dans la sortie ci-dessous:

+-----------------------------+
| 'A' in ('a', 'b', 'c', 'd') |
+-----------------------------+
| 1 |
+-----------------------------+
1 ligne en jeu (0.00 sec)

Exemple 2

Un cas similaire s'applique si la valeur n'est pas dans un ensemble de valeurs. Par exemple, la requête ci-dessous retournera 0 ou false.

Sélectionnez 'Z' dans ('A', 'B', 'C', 'D');

Étant donné que z n'est pas dans l'ensemble, l'instruction renvoie false comme indiqué:

+-----------------------------+
| 'Z' dans ('a', 'b', 'c', 'd') |
+-----------------------------+
| 0 |
+-----------------------------+

Exemple 3

Illustrons le En requête avec un exemple plus pratique. Prenons la table des acteurs du Exemple de base de données Sakila.

SELECT * FROM ACTOR LIMIT 10; +----------+------------+--------------+---------------------+
| acteur_id | First_name | Last_name | last_update |
+----------+------------+--------------+---------------------+
| 1 | Penelope | Guiness | 2006-02-15 04:34:33 |
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Chase | 2006-02-15 04:34:33 |
| 4 | Jennifer | Davis | 2006-02-15 04:34:33 |
| 5 | Johnny | Lollobrigida | 2006-02-15 04:34:33 |
| 6 | Bette | Nicholson | 2006-02-15 04:34:33 |
| 7 | Grâce | Mossel | 2006-02-15 04:34:33 |
| 8 | Matthieu | Johansson | 2006-02-15 04:34:33 |
| 9 | Joe | Swank | 2006-02-15 04:34:33 |
| 10 | Christian | Pignon | 2006-02-15 04:34:33 |
+----------+------------+--------------+---------------------+

Dans l'exemple du tableau ci-dessus, nous avons les colonnes actor_id, first_name, last_name et last_update.

Nous pouvons utiliser le En requête Pour obtenir uniquement les colonnes où le prénom est un ensemble de valeurs.

Considérez la requête ci-dessous:

Sélectionnez * à partir de l'acteur où d'abord_name dans («ed», «bette», «Grace», «John», «Nick»);

La requête ci-dessus doit renvoyer les colonnes pour uniquement les acteurs spécifiés. Un exemple de résultat est ci-dessous:

+----------+------------+-----------+---------------------+
| acteur_id | First_name | Last_name | last_update |
+----------+------------+-----------+---------------------+
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Chase | 2006-02-15 04:34:33 |
| 6 | Bette | Nicholson | 2006-02-15 04:34:33 |
| 7 | Grâce | Mossel | 2006-02-15 04:34:33 |
| 44 | Nick | Stallone | 2006-02-15 04:34:33 |
| 136 | Ed | Mansfield | 2006-02-15 04:34:33 |
| 166 | Nick | DeGeneres | 2006-02-15 04:34:33 |
| 179 | Ed | Guiness | 2006-02-15 04:34:33 |
| 192 | John | Suvari | 2006-02-15 04:34:33 |
+----------+------------+-----------+---------------------+

Exemple 4

Nous pouvons également utiliser le Dans l'opérateur Pour vérifier les valeurs numériques. Changeons les choses et utilisons la table de films de la base de données Sakila.

Supposons que nous ne voulons obtenir que les films où le Rental_Duration est 7.

Sélectionnez Film_id, Title, Rental_Duration à partir du film où Rental_Duration dans (7) Limit 5;

L'exemple de requête ci-dessus doit renvoyer les colonnes où la location_duration est égale à 7.

+---------+------------------+-----------------+
| Film_id | Titre | Rental_Duration |
+---------+------------------+-----------------+
| 3 | Trous d'adaptation | 7 |
| 27 | Humain anonyme | 7 |
| 36 | Argonauts Town | 7 |
| 70 | Bikini Emprunteurs | 7 |
| 78 | Blackout Private | 7 |
+---------+------------------+-----------------+
5 lignes en jeu (0.00 sec)

Exemple 5 - Négation

MySQL fournit également une négation pour le Dans l'opérateur. Pour l'utiliser, ajoutez le Pas de mot-clé avant le comme:

SELECT * FROM TABLE_NAME où l'expression non dans (valeurs);

Par exemple, obtenons les films qui n'incluons pas la lettre S dans le titre.

SELECT FILM_ID, Title, Rental_Duration à partir du film Where 'S' Not In (Title) Limit 5;

Un exemple de sortie est ci-dessous:

+---------+------------------+-----------------+
| Film_id | Titre | Rental_Duration |
+---------+------------------+-----------------+
| 1 | Dinosaure de l'Académie | 6 |
| 2 | Ace Goldfinger | 3 |
| 3 | Trous d'adaptation | 7 |
| 4 | Préjugés d'affaires | 5 |
| 5 | Œuf africain | 6 |
+---------+------------------+-----------------+
5 lignes en jeu (0.00 sec)

De clôture

Dans cet article, nous nous sommes concentrés sur l'utilisation MySQL dans l'opérateur Pour déterminer si une valeur se situe dans un ensemble de valeurs. Cela peut aider à remplacer le sang Ou opérateurs, Rendre la requête plus lisible et plus facile à gérer.