【Introducción a SQL】¡Explora a fondo la cláusula WHERE! Aprende a extraer datos con ejemplos listos para copiar
¿Eres un creador web que piensa que “bases de datos” o “SQL” suenan demasiado técnicos y ajenos? ¡No te preocupes! En el desarrollo web moderno, tener conocimientos de SQL se convierte en una poderosa herramienta para llevar tu creatividad al siguiente nivel.
Por ejemplo, en CMS como WordPress, los datos de publicaciones y usuarios se almacenan en bases de datos. Si entiendes SQL, podrás personalizar fácilmente la visualización de artículos que cumplan ciertos criterios. Además, al analizar el comportamiento del usuario para mejorar el sitio web basándose en datos, SQL se vuelve indispensable. Es decir, SQL ya no es solo para ingenieros backend.
En este artículo nos enfocamos en la cláusula más importante de SQL: WHERE. Esta cláusula actúa como una “red mágica” para pescar justo los datos que necesitas entre un mar de información. Aprenderás desde lo básico hasta ejemplos avanzados con muchos códigos que puedes copiar y ejecutar al instante. ¡Siente la emoción de manipular los datos a tu gusto mientras practicas!
¡Primero la preparación! La tabla de ejemplo que usaremos
Antes de comenzar nuestra aventura en SQL, prepararemos la tabla de ejemplo `users`. Imagina que esta tabla contiene información de usuarios de un servicio web ficticio. Comprender bien cada columna te facilitará mucho el aprendizaje.
Definición de tabla: `users`
id: Número único para identificar a cada usuario.name: Nombre del usuario (texto).age: Edad del usuario (número).pref: Prefectura o región donde vive el usuario (texto).points: Puntos que posee el usuario (número). Se permite `NULL` si no hay datos.
Más adelante, verás que esta tabla se carga automáticamente en los ejemplos prácticos. Por ahora, observa tranquilamente los datos de muestra que se insertarán:
-- Estructura de la tabla
CREATE TABLE users (
id INT PRIMARY KEY,
name VARCHAR(50),
age INT,
pref VARCHAR(50),
points INT
);
-- Inserción de datos de ejemplo
INSERT INTO users (id, name, age, pref, points) VALUES
(1, 'Taro Tanaka', 25, 'Tokio', 120),
(2, 'Ichiro Suzuki', 32, 'Osaka', 85),
(3, 'Hanako Sato', 28, 'Tokio', 300),
(4, 'Jiro Takahashi', 45, 'Fukuoka', 50),
(5, 'Sakura Ito', 25, 'Hokkaido', NULL),
(6, 'Saburo Watanabe', 32, 'Tokio', 150),
(7, 'Shiro Yamamoto', 51, 'Osaka', 210);Cláusula WHERE básica - Filtra datos con condiciones simples
La cláusula WHERE se coloca justo después de sentencias como `SELECT * FROM users`. Su forma básica es `WHERE columna operador valor`. Veámoslo en acción con operadores simples:
`=` : Buscar coincidencias exactas
El operador `=` busca coincidencias exactas. Por ejemplo, para encontrar usuarios de 25 años. Los valores numéricos se escriben tal cual, mientras que los de texto van entre comillas simples (`'`).
SELECT * FROM users WHERE age = 25;`<>` o `!=` : Buscar datos que NO coinciden
Para condiciones negativas, usa `<>` o `!=`. Por ejemplo, para listar usuarios que no viven en Tokio:
SELECT * FROM users WHERE pref <> 'Tokio';`>` y `>=` : Comparaciones de mayor o igual
También puedes comparar valores numéricos. Por ejemplo, busca usuarios con más de 100 puntos:
SELECT * FROM users WHERE points > 100;Si deseas incluir también el valor límite (como "32 años o más"), utiliza `>=`:
SELECT * FROM users WHERE age >= 32;WHERE avanzada - Manejo libre de múltiples condiciones
Una vez que dominas lo básico, puedes combinar condiciones y usar operadores más potentes:
`AND` y `OR` : Combinar condiciones
`AND` significa que se deben cumplir todas las condiciones. Ejemplo: usuarios que viven en Tokio y tienen menos de 30 años:
SELECT * FROM users WHERE pref = 'Tokio' AND age < 30;`OR` significa que se cumple al menos una condición. Ejemplo: usuarios de Osaka o mayores de 50 años:
SELECT * FROM users WHERE pref = 'Osaka' OR age >= 50;`IN` : Especificar múltiples valores
En lugar de escribir muchas condiciones con OR, puedes usar `IN` para abreviar. Ejemplo: usuarios que viven en Tokio, Osaka o Fukuoka:
SELECT * FROM users WHERE pref IN ('Tokio', 'Osaka', 'Fukuoka');`BETWEEN`: Especificar un rango determinado
Si deseas filtrar por un rango numérico, como "usuarios entre 30 y 50 años", `BETWEEN` es muy útil. Es equivalente a escribir `age >= 30 AND age <= 50`, pero de una forma más intuitiva. Ten en cuenta que `BETWEEN` incluye ambos valores límite (mayor o igual, menor o igual).
SELECT * FROM users WHERE age BETWEEN 30 AND 50;`LIKE`: El maestro de la búsqueda difusa
`LIKE` es un operador poderoso que permite buscar coincidencias parciales de cadenas. Utiliza símbolos especiales llamados "comodines".
- `%`: Coincide con cualquier secuencia de cero o más caracteres.
- `_`: Coincide con cualquier carácter individual.
Por ejemplo, para encontrar usuarios cuyos nombres contengan "ro" (coincidencia parcial), rodea la cadena de destino con `%`.
SELECT * FROM users WHERE name LIKE '%ro%';Para encontrar usuarios cuyo apellido comience con "Sato" (coincidencia de prefijo), escríbelo así:
SELECT * FROM users WHERE name LIKE 'Sato%';`IS NULL`: Buscar datos "vacíos"
`NULL` en una base de datos representa un estado especial que significa "no existen datos". Es completamente diferente de `0` o una cadena vacía (`''`). Para buscar valores `NULL`, utiliza la sintaxis especial `IS NULL` en lugar de `=`. Vamos a encontrar usuarios que no tengan datos de puntos registrados.
SELECT * FROM users WHERE points IS NULL;Por el contrario, para buscar datos que no sean `NULL` (es decir, que tengan algún valor), usa `IS NOT NULL`.
SELECT * FROM users WHERE points IS NOT NULL;3 errores comunes entre principiantes
Aunque WHERE es muy útil, existen algunos errores que pueden sorprenderte si no tienes cuidado. Veamos tres puntos importantes.
- Precedencia y paréntesis `()` con `AND` y `OR`
En SQL, `AND` tiene mayor precedencia que `OR`. Sin paréntesis, las condiciones complejas pueden comportarse de manera inesperada. Por ejemplo, para extraer "usuarios que vivan en Tokyo u Osaka y tengan 30 años o más", debes agrupar la condición `OR` con paréntesis para indicarle a la base de datos cómo evaluarla. - Presta atención al tipo de datos
Es importante que los valores coincidan con el tipo de dato de la columna. Las cadenas deben ir entre comillas (`'`), mientras que los números no. Algunas bases de datos pueden interpretar `"123"` como un número (conversión implícita), pero esto puede afectar el rendimiento o generar errores inesperados. Siempre utiliza el tipo correcto. - `NULL` significa “vacío”
Como ya se explicó, `NULL` es especial. `points = 0` y `points IS NULL` no son lo mismo. Por ejemplo, `COUNT(points)` no cuenta las filas con `NULL`, pero `COUNT(*)` sí lo hace. Entender esta diferencia ayuda a evitar errores al agregar datos.
-- Condición en la forma (A OR B) AND C
SELECT * FROM users WHERE (pref = 'Tokyo' OR pref = 'Osaka') AND age >= 30;¡No solo para SELECT! El verdadero poder de WHERE
La cláusula WHERE no es solo para consultas `SELECT`. También es esencial al actualizar (`UPDATE`) o eliminar (`DELETE`) datos, para asegurarte de afectar solo los registros deseados.
¿Y si escribes `DELETE FROM users` y olvidas la cláusula WHERE...? El resultado sería catastrófico: ¡todos los registros desaparecerían! Antes de modificar o borrar datos, asegúrate de ejecutar primero un `SELECT` para confirmar los registros afectados.
-- ¡Primero verifica los datos con SELECT!
SELECT * FROM users WHERE id = 3;
-- Una vez verificado, realiza el UPDATE
-- UPDATE users SET points = points + 50 WHERE id = 3;[Práctica] ¡Ejecuta SQL en tu navegador!
¡Hora de practicar! Copia el siguiente código, guárdalo como `sql-practice.html` y ábrelo en tu navegador.
Esto utiliza una biblioteca de JavaScript (`sql.js`) para crear una base de datos temporal en el navegador. Pega las sentencias SQL que aprendiste en el área de texto de la izquierda y haz clic en “Ejecutar SQL” para ver los resultados en tiempo real a la derecha. ¡Prueba distintas condiciones y observa cómo funciona WHERE con tus propios ojos!
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Entorno de Ejecución SQL (Práctica con WHERE)</title>
<style>
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; display: flex; flex-direction: column; height: 100vh; margin: 0; background-color: #f9f9f9; }
.header { padding: 15px 20px; background-color: #fff; border-bottom: 1px solid #ddd; }
.main-content { display: flex; flex: 1; overflow: hidden; }
.container { flex: 1; display: flex; flex-direction: column; padding: 20px; overflow-y: auto; }
.container:first-child { border-right: 1px solid #ddd; }
h3 { margin-top: 0; color: #333; }
textarea { height: 200px; border: 1px solid #ccc; border-radius: 4px; padding: 10px; font-family: "SF Mono", "Fira Code", "Source Code Pro", monospace; font-size: 14px; margin-top: 10px; resize: vertical; }
button { background-color: #007bff; color: white; border: none; padding: 12px 18px; border-radius: 4px; cursor: pointer; margin-top: 10px; font-size: 16px; transition: background-color 0.2s; }
button:hover { background-color: #0056b3; }
table { border-collapse: collapse; width: 100%; margin-top: 10px; background-color: #fff; }
th, td { border: 1px solid #ddd; padding: 10px; text-align: left; }
th { background-color: #f2f2f2; font-weight: 600; }
#error { color: #d9534f; font-weight: bold; margin-top: 10px; white-space: pre-wrap; }
</style>
<script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>
<div class="header">
<h2 style="margin: 0;">Zona de práctica de cláusula SQL WHERE</h2>
</div>
<div class="main-content">
<div class="container">
<h3>Entrada SQL</h3>
<textarea id="sql-input">-- ¡Modifica este SQL para probarlo!
SELECT * FROM users WHERE pref = 'Tokio';</textarea>
<button onclick="executeSql()">Ejecutar SQL</button>
<div id="error"></div>
</div>
<div class="container">
<h3>Resultado</h3>
<div id="result-table"></div>
</div>
</div>
<script>
let db;
async function initDb() {
try {
const config = { locateFile: filename => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${filename}` };
const SQL = await initSqlJs(config);
db = new SQL.Database();
const initialSql = `
CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(50), age INT, pref VARCHAR(50), points INT);
INSERT INTO users (id, name, age, pref, points) VALUES
(1, 'Taro Tanaka', 25, 'Tokio', 120),
(2, 'Ichiro Suzuki', 32, 'Osaka', 85),
(3, 'Hanako Sato', 28, 'Tokio', 300),
(4, 'Jiro Takahashi', 45, 'Fukuoka', 50),
(5, 'Sakura Ito', 25, 'Hokkaido', null),
(6, 'Saburo Watanabe', 32, 'Tokio', 150),
(7, 'Shiro Yamamoto', 51, 'Osaka', 210);
`;
db.run(initialSql);
executeSql(); // Mostrar inicialmente
} catch (e) {
document.getElementById('error').textContent = "Fallo al inicializar la base de datos: " + e.message;
}
}
function executeSql() {
const sqlInput = document.getElementById('sql-input').value;
const errorEl = document.getElementById('error');
const resultEl = document.getElementById('result-table');
errorEl.textContent = '';
resultEl.innerHTML = '';
try {
const results = db.exec(sqlInput);
if (results.length > 0) {
resultEl.appendChild(createTable(results[0]));
} else {
resultEl.innerHTML = '<p>La consulta fue exitosa, pero no hubo resultados. (ej: instrucciones UPDATE)</p>';
}
} catch (e) {
errorEl.textContent = "Error SQL: " + e.message;
}
}
function createTable(result) {
const table = document.createElement('table');
const thead = document.createElement('thead');
const tbody = document.createElement('tbody');
const headerRow = document.createElement('tr');
result.columns.forEach(col => {
const th = document.createElement('th');
th.textContent = col;
headerRow.appendChild(th);
});
thead.appendChild(headerRow);
result.values.forEach(row => {
const tr = document.createElement('tr');
row.forEach(cell => {
const td = document.createElement('td');
td.textContent = cell === null ? 'NULL' : cell;
tr.appendChild(td);
});
tbody.appendChild(tr);
});
table.appendChild(thead);
table.appendChild(tbody);
return table;
}
initDb();
</script>
</body>
</html>
Resumen y próximos pasos
En este artículo hemos explorado rápidamente desde lo básico hasta la práctica avanzada de la cláusula WHERE en SQL. Esperamos que hayas podido apreciar lo flexible y poderosa que puede ser para la extracción de datos.
Dominar WHERE no es el objetivo final, sino la puerta de entrada a un vasto mundo de SQL. Si deseas seguir aprendiendo, te recomendamos estos próximos pasos:
- Funciones de agregación (`COUNT`, `SUM`, `AVG`, etc.) y `GROUP BY`: Agrupar datos y calcular totales o promedios por grupo.
- Cláusula `JOIN`: Relacionar varias tablas para extraer datos más complejos.
- Subconsultas: Técnicas avanzadas que permiten anidar consultas dentro de otras.
Con estos conocimientos, tus habilidades de manejo de datos mejorarán notablemente y tendrás más oportunidades como desarrollador web. ¡Esperamos sinceramente que este artículo sea tu primer paso hacia esa gran aventura!