Mysql en cláusula

Este tutorial discutirá usando el Mysql en consulta Para verificar si un valor específico está dentro de un conjunto de valores, que es útil para reemplazar un conjunto de operadores.

Sintaxis básica

El Mysql en operador es bastante simple. Funciona verificando si un conjunto tiene una coincidencia para el valor especificado.

La sintaxis general para la consulta es:

Seleccione col_names de table_name donde exprese en (value_sets);

En la sintaxis anterior, especificamos la función para llevar a cabo. Puede ser un Seleccione, inserte, elimine, actualice, etc.

A continuación, especificamos el nombre de la tabla para realizar la acción especificada anterior.

La siguiente parte es la Dónde cláusula, donde especificamos la expresión o valor para evaluar. Este es el valor que probamos en los conjuntos de valores en el lado derecho del En la cláusula.

En la mano derecha de la cláusula, especificamos los valores de los cuales buscar la expresión coincidente.

Si el En la cláusula Encuentra una coincidencia en el conjunto de valores especificado, devuelve un 1, que indica verdadero, y un 0, que indica falso.

Mysql en ejemplos de cláusula

Aquí hay ejemplos para ilustrar la cláusula en:

Ejemplo 1

Un simple caso de uso para el En operador es verificar un valor único dentro de un conjunto. Por ejemplo, podemos verificar si el personaje 'A' está en un conjunto de caracteres.

Seleccione 'a' en ('a', 'b', 'c', 'd');

En el ejemplo anterior, verificamos si el personaje 'A' es En un conjunto de caracteres ABCD.

La consulta anterior debe devolver 1 si es verdadero, como se muestra en la salida a continuación:

+-----------------------------+
| 'A' in ('a', 'b', 'c', 'd') |
+-----------------------------+
| 1 |
+-----------------------------+
1 fila en el set (0.00 seg)

Ejemplo 2

Se aplica un caso similar si el valor no está en un conjunto de valores. Por ejemplo, la consulta a continuación devolverá 0 o falso.

Seleccione 'Z' en ('a', 'b', 'c', 'd');

Como Z no está en el conjunto, la declaración devuelve falso como se muestra:

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

Ejemplo 3

Vamos a ilustrar el En la consulta con un ejemplo más práctico. Tomemos la mesa del actor del muestra de la base de datos de Sakila.

Seleccionar * del límite del actor 10; +----------+------------+--------------+---------------------+
| actor_id | First_Name | Last_Name | Last_Update |
+----------+------------+--------------+---------------------+
| 1 | Penélope | Guiness | 2006-02-15 04:34:33 |
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Persecución | 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 | Gracia | Mostel | 2006-02-15 04:34:33 |
| 8 | Matthew | Johansson | 2006-02-15 04:34:33 |
| 9 | Joe | Swank | 2006-02-15 04:34:33 |
| 10 | Cristiano | Gable | 2006-02-15 04:34:33 |
+----------+------------+--------------+---------------------+

En la tabla de ejemplo anterior, tenemos las columnas actor_id, first_name, last_name y last_update.

Podemos usar el En la consulta Para obtener solo las columnas donde el primer nombre es un conjunto de valores.

Considere la consulta a continuación:

Seleccione * del actor donde primero_name en ('ed', 'bette', 'gracia', 'John', 'nick');

La consulta anterior debe devolver las columnas solo para los actores especificados. Un resultado de ejemplo está a continuación:

+----------+------------+-----------+---------------------+
| actor_id | First_Name | Last_Name | Last_Update |
+----------+------------+-----------+---------------------+
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Persecución | 2006-02-15 04:34:33 |
| 6 | Bette | Nicholson | 2006-02-15 04:34:33 |
| 7 | Gracia | Mostel | 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 |
+----------+------------+-----------+---------------------+

Ejemplo 4

También podemos usar el En operador Para verificar los valores numéricos. Cambiemos las cosas y usemos la mesa de la película desde el base de datos de Sakila.

Supongamos que queremos obtener solo las películas donde el Rental_duration es 7.

Seleccione Film_id, Título, Rental_Duration de Film Where Rental_duration en (7) Límite 5;

La consulta de ejemplo anterior debe devolver las columnas donde el alquiler_duration es igual a 7.

+---------+------------------+-----------------+
| Film_id | título | Rental_duration |
+---------+------------------+-----------------+
| 3 | Agujeros de adaptación | 7 |
| 27 | Humano anónimo | 7 |
| 36 | Argonauts pueblo | 7 |
| 70 | Bikini prestatarios | 7 |
| 78 | Apagón privado | 7 |
+---------+------------------+-----------------+
5 filas en el set (0.00 seg)

Ejemplo 5 - Negación

Mysql también proporciona una negación para el En operador. Para usarlo, agregue el No es una palabra clave antes de la entrada como:

Seleccionar * de table_name donde la expresión no en (valores);

Por ejemplo, obtengamos las películas que no incluyan las letras S en el título.

Seleccione Film_id, Título, Rental_Duration de Film Where 's' no en el límite (título) 5;

Una salida de ejemplo está a continuación:

+---------+------------------+-----------------+
| Film_id | título | Rental_duration |
+---------+------------------+-----------------+
| 1 | Dinosaurio de la Academia | 6 |
| 2 | Ace Goldfinger | 3 |
| 3 | Agujeros de adaptación | 7 |
| 4 | Prejuicio de asuntos | 5 |
| 5 | Huevo africano | 6 |
+---------+------------------+-----------------+
5 filas en el set (0.00 seg)

Para concluir

En este artículo, nos centramos en usar Mysql en operador para determinar si un valor está dentro de un conjunto de valores. Esto puede ayudar a reemplazar encadenado U operadores, hacer que la consulta sea más legible y más fácil de administrar.