Declaración WHERE de SQL Introducción
- La cláusula WHERE se usa para incluir una condición al obtener datos de las tablas.
- Cuando tiene que especificar una condición que debe cumplirse mientras se extraen datos de las tablas, en ese caso se usa la cláusula.
- La cláusula Where se utiliza para filtrar los registros que recupera de la declaración de selección para que obtenga un subconjunto de datos más pequeño.
- La cláusula Where también se usa para realizar operaciones de combinación.
- La cláusula Where devuelve solo aquellos registros de la tabla que cumplen la condición especificada con ella.
- Esta cláusula no solo se usa con SELECT Query, sino que también se puede usar con UPDATE y DELETE Queries.
- Uso de la cláusula where con la consulta SELECT
- Cláusula Where con consulta SELECT para recuperar todas las columnas de una tabla.
- Para recuperar todos los registros de una tabla, asterisco (*) se utiliza el símbolo.
Sintaxis:
SELECT *FROM TABLE_NAME WHERE condition;
Ejemplo:
Primero, crearemos una base de datos con el nombre "bookdb". Luego, en esa base de datos, crearemos una tabla "libro" e insertaremos registros en la tabla. Consideraremos la misma base de datos y también la misma tabla para ejemplos posteriores.
Ahora, aplicaremos la cláusula where con la consulta SELECT para recuperar todas las columnas de la tabla donde el precio del libro es 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) 
Solo hay un registro con Book_ID =4, cuyo precio es igual a 200. Por lo tanto, se muestran todas las columnas de ese registro en particular.
- Cláusula Where con consulta SELECT para recuperar una o más columnas específicas de una tabla.
- Para recuperar columnas específicas de una tabla, los nombres de todas las columnas que se van a recuperar deben especificarse en la consulta misma.
- Los nombres de las columnas específicas que se van a recuperar estarán separados por comas.
Sintaxis:
SELECT COLUMN_NAME1,….,COLUMN_NAMEn FROM TABLE_NAME WHERE condition;
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar columnas específicas (Book_ID, Book_Price) del libro tabla donde el precio del libro es 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)
Solo hay un registro con Book_ID =4, cuyo precio es igual a 200. Por lo tanto, se muestran Book_ID y Book_Price de ese registro en particular.
- Uso de la cláusula where con la consulta UPDATE
Sintaxis:
UPDATE TABLE_NAME SET column_name = newvalue WHERE column_name1 = value1;
Ejemplo:
Aplicaremos la cláusula where con la consulta ACTUALIZAR en la tabla de libros para actualizar Book_Name y Book_Author de un registro en particular especificando Book_ID como una condición en la 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)
Solo hay un registro con Book_ID =3, hemos cambiado Book_name y Book_Author de ese registro. Por lo tanto, se muestra la tabla actualizada.
- Uso de la cláusula where con la consulta DELETE
Sintaxis:
DELETE FROM TABLE_NAME WHERE column_name1 = value1;
Ejemplo:
Aplicaremos la cláusula where con la consulta DELETE en la tabla del libro a
elimine un libro con Book_ID particular especificando Book_ID como una condición en la 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)
Solo hay un registro con Book_ID =5, hemos eliminado ese registro completo de la tabla de libros. Por lo tanto, se muestra la tabla actualizada.
Operadores con instrucción WHERE
Puede utilizar operadores con la cláusula where. Estos operadores se pueden usar junto con la cláusula where en las consultas SELECCIONAR, ACTUALIZAR y ELIMINAR.
- Igual(=)
Cuando se usa el operador igual a (=) con la cláusula where, recuperará esos registros de la tabla siempre que el valor del nombre de la columna presente en una tabla sea igual al valor del nombre de la columna especificado en la consulta.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar esos registros de la tabla donde el precio del libro es 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)
Solo hay un registro con Book_ID =4, cuyo precio es igual a 200. Por lo tanto, se muestran todas las columnas de ese registro en particular.
- Mayor que (>)
Cuando se usa el operador mayor que (>) con la cláusula Where, recuperará esos registros de la tabla siempre que el valor del nombre de columna presente en una tabla sea mayor que el valor del nombre de columna especificado en la consulta.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar esos registros de la tabla donde el precio del libro es superior 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 | | 3 | Database Management Systems | Raghu Ramakrishnan | 250 | | 4 | murach's MySQL | Joel Murach | 200 | +---------+-----------------------------+--------------------+------------+ 3 rows in set (0.00 sec)
Hay tres registros con Book_ID =1, 3 y 4 cuyos precios son superiores a 150. Por lo tanto, se muestran todas las columnas de esos registros.
- Menos de (<)
Cuando se usa el operador menor que (<) con la cláusula where, recuperará esos registros de la tabla siempre que el valor del nombre de la columna presente en una tabla sea menor que el valor del nombre de la columna especificado en la consulta.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar esos registros de la tabla donde el precio del libro es inferior 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 | +---------+-----------------+---------------+------------+ 2 rows in set (0.00 sec)
Hay dos registros con Book_ID =1 y 2 cuyos precios son inferiores a 200. Por lo tanto, se muestran todas las columnas de esos registros.
- Mayor o igual (>=)
Cuando se usa el operador mayor o igual (>=) con la cláusula where, recuperará esos registros de la tabla siempre que el valor del nombre de columna presente en una tabla sea mayor o igual que el valor del nombre de columna especificado en el consulta.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar aquellos registros de la tabla donde el precio del libro sea mayor o 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 hay cuatro registros con Book_ID =1, 2, 3 y 4 cuyos precios son mayores o iguales a 150. Por lo tanto, se muestran todas las columnas de esos registros.
- Menor que o igual (<=)
Cuando se usa el operador menor o igual (<=) con la cláusula where, recuperará esos registros de la tabla siempre que el valor del nombre de columna presente en una tabla sea menor o igual que el valor del nombre de columna especificado en la consulta.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar esos registros de la tabla donde el precio del libro es menor o 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)
Hay tres registros con Book_ID =1, 2 y 4 cuyos precios son menores o iguales a 200. Por lo tanto, se muestran todas las columnas de esos registros.
- No es igual (<>)
Cuando se usa el operador no igual (<>) con la cláusula where, recuperará esos registros de la tabla siempre que el valor del nombre de columna especificado en la consulta no coincida con el valor del nombre de columna presente en una tabla.
Ejemplo:
Aplicaremos la cláusula where con la consulta SELECT para recuperar aquellos registros de la tabla donde el precio del libro no es 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)
Hay tres registros con Book_ID =1, 2 y 4 cuyos precios no son iguales a 250. Por lo tanto, se muestran todas las columnas de esos registros.
