MySQL WHERE Clause: Filtrado de Datos en Consultas SELECT

La cláusula WHERE en MySQL es una herramienta fundamental para filtrar resultados de consultas SELECT, permitiendo la selección de registros específicos que cumplan con una condición determinada. Actúa como un filtro que elige únicamente las filas que coincidan con la condición establecida, proporcionando un control preciso sobre los datos que se recuperan.

La sintaxis básica de la cláusula WHERE es simple y se integra directamente dentro de la consulta SELECT:

sql
SELECT columna1, columna2, ...
FROM nombre_de_la_tabla
WHERE condición;


Donde condición representa una expresión que se evalúa como verdadera o falsa para cada fila de la tabla. Esta condición puede incluir comparaciones de valores, operadores lógicos, y funciones que operan sobre los datos de la tabla.

Operadores de Comparación en la Cláusula WHERE

La cláusula WHERE admite una amplia variedad de operadores de comparación que permiten establecer las condiciones de filtro. Algunos de los operadores más comunes son:

• = (Igual a): Devuelve las filas donde el valor del campo coincide exactamente con el valor especificado.
• != (Diferente de): Devuelve las filas donde el valor del campo no coincide con el valor especificado.
• > (Mayor que): Devuelve las filas donde el valor del campo es mayor que el valor especificado.
• < (Menor que): Devuelve las filas donde el valor del campo es menor que el valor especificado.
• >= (Mayor o igual que): Devuelve las filas donde el valor del campo es mayor o igual que el valor especificado.
• <= (Menor o igual que): Devuelve las filas donde el valor del campo es menor o igual que el valor especificado.

Operadores Lógicos en la Cláusula WHERE

Para combinar múltiples condiciones en la cláusula WHERE, se utilizan operadores lógicos:

• AND: Devuelve las filas que cumplen con todas las condiciones especificadas.
• OR: Devuelve las filas que cumplen con al menos una de las condiciones especificadas.
• NOT: Invierte la condición especificada.

Ejemplos de Uso de la Cláusula WHERE

1. Seleccionar filas donde un campo sea igual a un valor específico:

sql
SELECT * FROM clientes WHERE nombre = 'Juan Pérez';


Este ejemplo recupera todas las filas de la tabla clientes donde el campo nombre sea igual a ‘Juan Pérez’.

2. Seleccionar filas donde un campo sea mayor que un valor específico:

sql
SELECT * FROM pedidos WHERE fecha > '2023-10-01';


Este ejemplo recupera todas las filas de la tabla pedidos donde el campo fecha sea mayor que ‘2023-10-01’.

3. Seleccionar filas donde un campo sea igual a uno de varios valores:

sql
SELECT * FROM productos WHERE categoria IN ('Electronica', 'Deportes');


Este ejemplo recupera todas las filas de la tabla productos donde el campo categoria sea igual a ‘Electronica’ o ‘Deportes’.

4. Seleccionar filas que cumplan con varias condiciones:

sql
SELECT * FROM empleados WHERE departamento = 'Ventas' AND salario > 50000;


Este ejemplo recupera todas las filas de la tabla empleados donde el campo departamento sea igual a ‘Ventas’ y el campo salario sea mayor que 50000.

WHERE en Combinación con JOINs

La cláusula WHERE se puede utilizar en conjunto con JOINs para filtrar resultados de consultas que combinan datos de múltiples tablas.

Ejemplo:

sql
SELECT *
FROM clientes
INNER JOIN pedidos ON clientes.id = pedidos.cliente_id
WHERE pedidos.fecha > '2023-10-01';


Este ejemplo realiza una unión interna (INNER JOIN) entre las tablas clientes y pedidos basada en la condición clientes.id = pedidos.cliente_id, y luego filtra los resultados para incluir solo las filas donde la fecha del pedido (pedidos.fecha) sea mayor que ‘2023-10-01’.

WHERE en DELETE y UPDATE

La cláusula WHERE también se puede usar en las sentencias DELETE y UPDATE para especificar las filas que se eliminarán o actualizarán.

Ejemplo de DELETE:

sql
DELETE FROM clientes WHERE nombre = 'Juan Pérez';


Este ejemplo elimina todas las filas de la tabla clientes donde el campo nombre sea igual a ‘Juan Pérez’.

Ejemplo de UPDATE:

sql
UPDATE clientes SET nombre = 'Juan Pablo Pérez' WHERE id = 12345;


Este ejemplo actualiza el campo nombre de la tabla clientes a ‘Juan Pablo Pérez’ para la fila con ID 12345.

Utilizando WHERE desde Programas Externos

Se puede utilizar la cláusula WHERE dentro de consultas SQL realizadas desde programas externos como PHP, Node.js, Java o Python.

Ejemplo en PHP:

«`php
dedatos»);

if ($conn->connecterror) {
die(«Error de conexión: » . $conn->connecterror);
}

$sql = «SELECT * FROM clientes WHERE nombre = ‘Juan Pérez'»;
$result = $conn->query($sql);

if ($result->numrows > 0) {
// Procesa los resultados
while($row = $result->fetchassoc()) {
echo «ID: » . $row[«id»] . » – Nombre: » . $row[«nombre»] . «
«;
}
} else {
echo «No se encontraron resultados.»;
}

$conn->close();
?>
«`

Ejemplo en Node.js:

«`javascript
const mysql = require(‘mysql’);

const connection = mysql.createConnection({
host: ‘localhost’,
user: ‘usuario’,
password: ‘contraseña’,
database: ‘basededatos’
});

connection.connect(function(err) {
if (err) throw err;

let sql = «SELECT * FROM clientes WHERE nombre = ‘Juan Pérez'»;
connection.query(sql, function (err, result) {
if (err) throw err;

if (result.length > 0) {
  // Procesa los resultados
  result.forEach(row => {
    console.log("ID: " + row.id + " - Nombre: " + row.nombre);
  });
} else {
  console.log("No se encontraron resultados.");
}

});

connection.end();
});
«`

Ejemplo en Java:

«`java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Main {
public static void main(String[] args) {
try {
// Establecer conexión
Connection conn = DriverManager.getConnection(«jdbc:mysql://localhost:3306/basededatos», «usuario», «contraseña»);

  // Crear sentencia SQL
  Statement stmt = conn.createStatement();
  String sql = "SELECT * FROM clientes WHERE nombre = 'Juan Pérez'";
  ResultSet rs = stmt.executeQuery(sql);

  // Procesa los resultados
  while (rs.next()) {
    System.out.println("ID: " + rs.getInt("id") + " - Nombre: " + rs.getString("nombre"));
  }

  // Cerrar recursos
  rs.close();
  stmt.close();
  conn.close();
} catch (SQLException e) {
  System.out.println("Error de conexión: " + e.getMessage());
}

}
}
«`

Ejemplo en Python:

«`python
import mysql.connector

mydb = mysql.connector.connect(
host=»localhost»,
user=»usuario»,
password=»contraseña»,
database=»basededatos»
)

mycursor = mydb.cursor()

mycursor.execute(«SELECT * FROM clientes WHERE nombre = ‘Juan Pérez'»)
myresult = mycursor.fetchall()

for x in myresult:
print(«ID: «, x[0], » – Nombre: «, x[1])

mydb.close()
«`

Estos ejemplos muestran cómo ejecutar consultas SELECT con la cláusula WHERE desde diferentes lenguajes de programación, accediendo a la base de datos MySQL y obteniendo los resultados deseados.

Conclusiones

La cláusula WHERE en MySQL es esencial para filtrar resultados de consultas SELECT y obtener los datos específicos que se necesitan. Su versatilidad permite realizar operaciones complejas de filtrado, utilizando operadores de comparación, operadores lógicos y funciones. La integración de WHERE con JOINs y su uso en las sentencias DELETE y UPDATE la convierten en una herramienta indispensable para la manipulación de datos en bases de datos MySQL.