MySQL na cláusula

Este tutorial discutirá usando o Mysql em consulta Para verificar se um valor específico está dentro de um conjunto de valores, o que é útil para substituir um conjunto de ou operadores.

Sintaxe básica

O MySQL no operador é simples o suficiente. Funciona verificando se um conjunto tiver uma correspondência para o valor especificado.

A sintaxe geral para a consulta é:

Selecione col_names de tabela_name onde a expressão em (value_sets);

Na sintaxe acima, especificamos a função a ser executada. Pode ser um Selecione, insira, exclua, atualize, etc.

Em seguida, especificamos o nome da tabela a partir da qual executar a ação especificada acima.

A próxima parte é o Onde cláusula, onde especificamos a expressão ou valor para avaliar. Este é o valor que testamos nos conjuntos de valores no lado direito do Na cláusula.

Na mão direita da cláusula, especificamos os valores dos quais procurar a expressão correspondente.

Se o Na cláusula Encontra uma correspondência no conjunto especificado de valores, ele retorna um 1, indicando verdadeiro e um 0, indicando falso.

MySQL em exemplos de cláusula

Aqui estão exemplos para ilustrar a cláusula IN:

Exemplo 1

Um caso de uso simples para o No operador é verificar se há um único valor dentro de um conjunto. Por exemplo, podemos verificar se o personagem 'A' está em um conjunto de personagens.

Selecione 'a' em ('a', 'b', 'c', 'd');

No exemplo acima, verificamos se o personagem 'A' é Em um conjunto de caracteres ABCD.

A consulta acima deve retornar 1 se verdadeira, como mostrado na saída abaixo:

+-----------------------------+
| 'A' em ('a', 'b', 'c', 'd') |
+-----------------------------+
| 1 |
+-----------------------------+
1 linha no conjunto (0.00 seg)

Exemplo 2

Um caso semelhante se aplica se o valor não estiver em um conjunto de valores. Por exemplo, a consulta abaixo retornará 0 ou falsa.

Selecione 'z' em ('a', 'b', 'c', 'd');

Como Z não está no conjunto, a declaração retorna falsa como mostrado:

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

Exemplo 3

Vamos ilustrar o Em consulta com um exemplo mais prático. Vamos pegar a tabela do ator do Exemplo de banco de dados Sakila.

Selecione * do limite do ator 10; +----------+------------+--------------+---------------------+
| ator_id | primeiro_name | Último nome | last_update |
+----------+------------+--------------+---------------------+
| 1 | Penelope | Guiness | 2006-02-15 04:34:33 |
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Perseguir | 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 | Graça | 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 | Cristão | Gable | 2006-02-15 04:34:33 |
+----------+------------+--------------+---------------------+

Na tabela de exemplo acima, temos as colunas ator_id, primeiro_name, last_name e last_update.

Podemos usar o Em consulta Para obter apenas as colunas onde o primeiro nome é um conjunto de valores.

Considere a consulta abaixo:

Selecione * do ator onde First_Name em ('ed', 'bette', 'graça', 'John', 'nick');

A consulta acima deve retornar as colunas apenas para os atores especificados. Um exemplo de resultado está abaixo:

+----------+------------+-----------+---------------------+
| ator_id | primeiro_name | Último nome | last_update |
+----------+------------+-----------+---------------------+
| 2 | Nick | Wahlberg | 2006-02-15 04:34:33 |
| 3 | Ed | Perseguir | 2006-02-15 04:34:33 |
| 6 | Bette | Nicholson | 2006-02-15 04:34:33 |
| 7 | Graça | 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 |
+----------+------------+-----------+---------------------+

Exemplo 4

Também podemos usar o No operador Para verificar valores numéricos. Vamos mudar as coisas e usar a tabela de filme do banco de dados Sakila.

Suponha que queremos obter apenas os filmes onde o Rental_Duration é 7.

Selecione Film_id, título, Rental_duration no filme onde Rental_duration in (7) limite 5;

A consulta de exemplo acima deve retornar as colunas em que a realidade é igual a 7.

+---------+------------------+-----------------+
| film_id | título | Rental_Duration |
+---------+------------------+-----------------+
| 3 | Orifícios de adaptação | 7 |
| 27 | Humano anônimo | 7 |
| 36 | Cidade de Argonauts | 7 |
| 70 | Matores de biquíni | 7 |
| 78 | Blackout privado | 7 |
+---------+------------------+-----------------+
5 linhas no set (0.00 seg)

Exemplo 5 - Negação

MySQL também fornece uma negação para o No operador. Para usá -lo, adicione o Não palavra -chave antes do in como:

Selecione * da tabela_name onde a expressão não está em (valores);

Por exemplo, vamos obter os filmes que não incluem as cartas no título.

Selecione Film_Id, título, Rental_duration no filme Where 'S' no (título) limite 5;

Um exemplo de saída está abaixo:

+---------+------------------+-----------------+
| film_id | título | Rental_Duration |
+---------+------------------+-----------------+
| 1 | DINOSAURO da Academia | 6 |
| 2 | Ace Goldfinger | 3 |
| 3 | Orifícios de adaptação | 7 |
| 4 | Preconceito de caso | 5 |
| 5 | Ovo africano | 6 |
+---------+------------------+-----------------+
5 linhas no set (0.00 seg)

Para encerrar

Neste artigo, focamos em usar MySQL no operador Para determinar se um valor está dentro de um conjunto de valores. Isso pode ajudar a substituir o encadeado Ou operadores, Tornando a consulta mais legível e fácil de gerenciar.