Instrução SQL WHERE Introdução
- A cláusula WHERE é usada para incluir uma condição ao buscar dados de tabelas.
- Quando você precisa especificar uma condição que deve ser obedecida enquanto os dados são extraídos das tabelas, nesse caso onde a cláusula é usada.
- A cláusula Where é usada para filtrar os registros que você recupera da instrução select para obter um subconjunto menor de dados.
- A cláusula Where também é usada para realizar operações de junção.
- A cláusula Where retorna apenas os registros da tabela que atendem à condição especificada.
- Esta cláusula não é usada apenas com consultas SELECT, mas também pode ser usada com consultas UPDATE e DELETE.
- Usando a cláusula where com consulta SELECT
- Cláusula Where com consulta SELECT para recuperar todas as colunas de uma tabela.
- Para recuperar todos os registros de uma tabela, asterisco (*) símbolo é usado.
Sintaxe:
SELECT *FROM TABLE_NAME WHERE condition;
Exemplo:
Primeiro, vamos criar um banco de dados com o nome “bookdb”. Então nesse banco de dados vamos criar uma tabela “book” e inserir registros na tabela. Consideraremos o mesmo banco de dados e também a mesma tabela para exemplos subsequentes.
Agora, vamos aplicar a cláusula where com a consulta SELECT para recuperar todas as colunas da tabela onde o preço do livro é igual a 200.
mysql> CREATE DATABASE bookdb;
Query OK, 1 row affected (0.07 sec)
mysql> USE bookdb;
Database changed
mysql> CREATE TABLE book(Book_ID INT NOT NULL AUTO_INCREMENT, Book_Name VARCHAR(100) NOT NULL, Book_Author VARCHAR(40) NOT NULL, Book_Price INT NOT NULL, PRIMARY KEY(Book_ID));
Query OK, 0 rows affected (0.24 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Learn MySQL","Abdul S", 180);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Explained","Andrew Comeau", 150);
Query OK, 1 row affected (0.04 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("MySQL Cookbook","Paul DuBois", 250);
Query OK, 1 row affected (0.08 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("murach's MySQL","Joel Murach", 200);
Query OK, 1 row affected (0.07 sec)
mysql> INSERT INTO book(Book_Name,Book_Author,Book_Price) VALUES ("Head First SQL","Lynn Beighley", 300);
Query OK, 1 row affected (0.07 sec)
mysql> SELECT *FROM book;
+---------+-----------------------------+--------------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+-----------------------------+--------------------+------------+
| 1 | Learn MySQL | Abdul S | 180 |
| 2 | MySQL Explained | Andrew Comeau | 150 |
| 3 | Database Management Systems | Raghu Ramakrishnan | 250 |
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+-----------------------------+--------------------+------------+
4 rows in set (0.00 sec)
mysql> SELECT *FROM book WHERE Book_Price=200;
+---------+----------------+-------------+------------+
| Book_ID | Book_Name | Book_Author | Book_Price |
+---------+----------------+-------------+------------+
| 4 | murach's MySQL | Joel Murach | 200 |
+---------+----------------+-------------+------------+
1 row in set (0.00 sec) 
Existe apenas um registro com Book_ID =4, cujo preço é igual a 200. Assim, todas as colunas desse registro específico são exibidas.
- Cláusula Where com consulta SELECT para recuperar uma ou mais colunas específicas de uma tabela.
- Para recuperar colunas específicas de uma tabela, os nomes de todas as colunas a serem recuperadas devem ser especificados na própria consulta.
- Os nomes de coluna específicos que devem ser recuperados serão separados por vírgula.
Sintaxe:
SELECT COLUMN_NAME1,….,COLUMN_NAMEn FROM TABLE_NAME WHERE condition;
Exemplo:
Aplicaremos a cláusula where com a consulta SELECT para recuperar colunas específicas (Book_ID, Book_Price) do book tabela onde o preço do livro é igual a 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT Book_ID,Book_Price FROM book where Book_Price=200; +---------+------------+ | Book_ID | Book_Price | +---------+------------+ | 4 | 200 | +---------+------------+ 1 row in set (0.00 sec)
Existe apenas um registro com Book_ID =4, cujo preço é igual a 200. Assim, Book_ID e Book_Price desse registro específico são exibidos.
- Usando a cláusula where com consulta UPDATE
Sintaxe:
UPDATE TABLE_NAME SET column_name = newvalue WHERE column_name1 = value1;
Exemplo:
Aplicaremos a cláusula where com a consulta UPDATE na tabela book para atualizar o Book_Name e Book_Author de um registro específico, especificando o Book_ID como uma condição na cláusula where.
mysql> SELECT *FROM book; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | MySQL Cookbook | Paul DuBois | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------+---------------+------------+ 5 rows in set (0.00 sec) mysql> UPDATE book SET Book_name="Database Management Systems", Book_Author="Raghu Ramakrishnan" WHERE Book_ID=3; Query OK, 1 row affected (0.19 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec)
Existe apenas um registro com Book_ID =3, alteramos o Book_name e Book_Author desse registro. Assim, a tabela atualizada é exibida.
- Usando a cláusula where com consulta DELETE
Sintaxe:
DELETE FROM TABLE_NAME WHERE column_name1 = value1;
Exemplo:
Vamos aplicar a cláusula where com a consulta DELETE na tabela book para
exclua um livro com um Book_ID específico especificando o Book_ID como uma condição na cláusula where.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | | 5 | Head First SQL | Lynn Beighley | 300 | +---------+-----------------------------+--------------------+------------+ 5 rows in set (0.00 sec) mysql> DELETE FROM book WHERE Book_ID=5; Query OK, 1 row affected (0.23 sec) mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Há apenas um registro com Book_ID =5, excluímos todo esse registro da tabela de livros. Assim, a tabela atualizada é exibida.
Operadores com declaração WHERE
Você pode usar operadores com a cláusula where. Esses operadores podem ser usados junto com a cláusula where em consultas SELECT, UPDATE e DELETE.
- Igual(=)
Quando o operador igual a (=) for usado com a cláusula where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna presente em uma tabela for igual ao valor do nome da coluna especificado na consulta.
Exemplo:
Aplicaremos a cláusula where com consulta SELECT para recuperar esses registros da tabela onde o preço do livro é igual a 200.
mysql> SELECT *FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT *FROM book WHERE Book_Price=200; +---------+----------------+-------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+----------------+-------------+------------+ | 4 | murach's MySQL | Joel Murach | 200 | +---------+----------------+-------------+------------+ 1 row in set (0.00 sec)
Existe apenas um registro com Book_ID =4, cujo preço é igual a 200. Assim, todas as colunas desse registro específico são exibidas.
- Maior que(>)
Quando o operador maior que (>) é usado com a cláusula Where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna presente em uma tabela for maior que o valor do nome da coluna especificado na consulta.
Exemplo:
Aplicaremos a cláusula where com a consulta SELECT para recuperar esses registros da tabela onde o preço do livro for maior que 150.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price > 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 3 rows in set (0.00 sec)
Existem três registros com Book_ID =1, 3 e 4 cujos preços são maiores que 150. Assim, todas as colunas desses registros são exibidas.
- Menor que(<)
Quando o operador menor que(<) é usado com a cláusula where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna presente em uma tabela for menor que o valor do nome da coluna especificado na consulta.
Exemplo:
Aplicaremos a cláusula where com a consulta SELECT para recuperar esses registros da tabela onde o preço do livro é menor que 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price < 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | +---------+-----------------+---------------+------------+ 2 rows in set (0.00 sec)
Existem dois registros com Book_ID =1 e 2 cujos preços são inferiores a 200. Assim, todas as colunas desses registros são exibidas.
- Maior ou igual (>=)
Quando o operador maior ou igual (>=) é usado com a cláusula where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna presente em uma tabela for maior ou igual ao valor do nome da coluna especificado no inquerir.
Exemplo:
Aplicaremos a cláusula where com consulta SELECT para recuperar esses registros da tabela onde o preço do livro é maior ou igual a 150.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price >= 150; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec)
Podemos ver que existem quatro registros com Book_ID =1, 2, 3 e 4 cujos preços são maiores ou iguais a 150. Assim, todas as colunas desses registros são exibidas.
- Menor ou igual (<=)
Quando o operador menor ou igual (<=) for usado com a cláusula where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna presente em uma tabela for menor ou igual ao valor do nome da coluna especificado em A pergunta.
Exemplo:
Aplicaremos a cláusula where com consulta SELECT para recuperar esses registros da tabela onde o preço do livro é menor ou igual a 200.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <= 200; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Existem três registros com Book_ID =1, 2 e 4 cujos preços são menores ou iguais a 200. Assim, todas as colunas desses registros são exibidas.
- Diferente (<>)
Quando o operador not equal(<>) for usado com a cláusula where, ele recuperará esses registros da tabela sempre que o valor do nome da coluna especificado na consulta não corresponder ao valor do nome da coluna presente em uma tabela.
Exemplo:
Aplicaremos a cláusula where com a consulta SELECT para recuperar esses registros da tabela onde o preço do livro não for igual a 250.
mysql> SELECT * FROM book; +---------+-----------------------------+--------------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------------------+--------------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 4 rows in set (0.00 sec) mysql> SELECT * FROM book WHERE Book_Price <> 250; +---------+-----------------+---------------+------------+ | Book_ID | Book_Name | Book_Author | Book_Price | +---------+-----------------+---------------+------------+ | 1 | Learn MySQL | Abdul S | 180 | | 2 | MySQL Explained | Andrew Comeau | 150 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------+---------------+------------+ 3 rows in set (0.00 sec)
Existem três registros com Book_ID =1, 2 e 4 cujos preços não são iguais a 250. Assim, todas as colunas desses registros são exibidas.
