Tutorial SQL: Consultas básicas de selección: SELECT y WHERE

Operadores de comparación

Los operadores de comparación son elementos fundamentales en SQL que nos permiten establecer condiciones para filtrar registros en nuestras consultas. Cuando utilizamos la cláusula WHERE, estos operadores nos ayudan a especificar exactamente qué datos queremos recuperar de una tabla, comparando valores de columnas con otros valores o expresiones.

Operadores básicos de comparación

SQL proporciona un conjunto de operadores que funcionan de manera similar a los que encontramos en matemáticas:

• Igual (=): Compara si dos valores son exactamente iguales.

-- Seleccionar productos con precio exactamente igual a 19.99
SELECT * FROM productos WHERE precio = 19.99;

• Distinto (<> o !=): Compara si dos valores son diferentes.

-- Seleccionar productos que no sean de la categoría 'Electrónica'
SELECT * FROM productos WHERE categoria <> 'Electrónica';
-- Alternativa usando !=
SELECT * FROM productos WHERE categoria != 'Electrónica';

• Mayor que (>): Compara si un valor es mayor que otro.

-- Seleccionar productos con precio mayor a 50
SELECT * FROM productos WHERE precio > 50;

• Menor que (<): Compara si un valor es menor que otro.

-- Seleccionar productos con stock menor a 10
SELECT * FROM productos WHERE stock < 10;

• Mayor o igual que (>=): Compara si un valor es mayor o igual a otro.

-- Seleccionar productos con calificación mayor o igual a 4
SELECT * FROM productos WHERE calificacion >= 4;

• Menor o igual que (<=): Compara si un valor es menor o igual a otro.

-- Seleccionar pedidos realizados antes o durante 2023
SELECT * FROM pedidos WHERE YEAR(fecha_pedido) <= 2023;

Comparaciones con rangos

Para filtrar datos dentro de un rango específico, podemos utilizar combinaciones de operadores o el operador BETWEEN:

• BETWEEN: Comprueba si un valor está dentro de un rango inclusivo.

-- Seleccionar productos con precios entre 10 y 50 (inclusive)
SELECT * FROM productos WHERE precio BETWEEN 10 AND 50;

-- Equivalente a:
SELECT * FROM productos WHERE precio >= 10 AND precio <= 50;

• NOT BETWEEN: Comprueba si un valor está fuera de un rango.

-- Seleccionar productos con precios fuera del rango 10-50
SELECT * FROM productos WHERE precio NOT BETWEEN 10 AND 50;

-- Equivalente a:
SELECT * FROM productos WHERE precio < 10 OR precio > 50;

Comparaciones con listas de valores

Para comparar un valor con múltiples opciones posibles, utilizamos el operador IN:

• IN: Comprueba si un valor coincide con cualquiera de los valores en una lista.

-- Seleccionar productos de categorías específicas
SELECT * FROM productos WHERE categoria IN ('Electrónica', 'Informática', 'Telefonía');

-- Equivalente a:
SELECT * FROM productos 
WHERE categoria = 'Electrónica' 
   OR categoria = 'Informática' 
   OR categoria = 'Telefonía';

• NOT IN: Comprueba si un valor no coincide con ninguno de los valores en una lista.

-- Seleccionar productos que no sean de estas categorías
SELECT * FROM productos WHERE categoria NOT IN ('Ropa', 'Calzado', 'Accesorios');

Comparaciones con patrones de texto

Para comparaciones más complejas con cadenas de texto, SQL proporciona el operador LIKE (que se verá en detalle en otra sección), pero es importante mencionarlo como parte de los operadores de comparación:

-- Seleccionar productos cuyo nombre comience con 'Smart'
SELECT * FROM productos WHERE nombre LIKE 'Smart%';

Comparaciones con valores NULL

Para comparar con valores nulos, SQL proporciona operadores especiales:

• IS NULL: Comprueba si un valor es NULL.

-- Seleccionar clientes sin número de teléfono registrado
SELECT * FROM clientes WHERE telefono IS NULL;

• IS NOT NULL: Comprueba si un valor no es NULL.

-- Seleccionar clientes con email registrado
SELECT * FROM clientes WHERE email IS NOT NULL;

Uso práctico de operadores de comparación

Los operadores de comparación son especialmente útiles cuando necesitamos filtrar datos basados en criterios específicos. Veamos algunos ejemplos prácticos:

• Filtrado por fecha:

-- Pedidos realizados en el último mes
SELECT * FROM pedidos 
WHERE fecha_pedido >= DATE_SUB(CURRENT_DATE(), INTERVAL 1 MONTH);

-- Pedidos realizados en 2023
SELECT * FROM pedidos 
WHERE fecha_pedido BETWEEN '2023-01-01' AND '2023-12-31';

• Filtrado por valores numéricos:

-- Productos con descuento (precio de venta menor al precio original)
SELECT * FROM productos 
WHERE precio_venta < precio_original;

-- Productos con alto margen de beneficio (más del 50%)
SELECT * FROM productos 
WHERE (precio_venta - costo) / costo > 0.5;

• Combinación de múltiples condiciones:

-- Productos caros (>100) con poco stock (<5)
SELECT * FROM productos 
WHERE precio > 100 AND stock < 5;

-- Clientes VIP (gastaron más de 1000) o nuevos (registrados este año)
SELECT * FROM clientes 
WHERE total_compras > 1000 
   OR fecha_registro >= '2023-01-01';

Consideraciones importantes

• Los operadores de comparación son sensibles al tipo de dato. Comparar tipos incompatibles puede generar errores o resultados inesperados.
• En MySQL y PostgreSQL, las comparaciones de cadenas de texto son sensibles a mayúsculas y minúsculas por defecto, aunque esto puede configurarse.
• Al comparar fechas, asegúrate de usar el formato correcto según la configuración de tu base de datos.
• Las comparaciones con NULL siempre devuelven NULL (ni verdadero ni falso), por eso necesitamos operadores especiales como IS NULL e IS NOT NULL.

Los operadores de comparación son la base para construir condiciones de filtrado efectivas en SQL. Dominarlos te permitirá extraer exactamente la información que necesitas de tus bases de datos, mejorando la precisión y eficiencia de tus consultas.

Operadores lógicos

Los operadores lógicos en SQL nos permiten combinar múltiples condiciones en una cláusula WHERE, creando filtros más complejos y precisos para nuestras consultas. Estos operadores actúan como conectores entre diferentes expresiones de comparación, permitiéndonos definir exactamente qué registros queremos recuperar de nuestras tablas.

Operadores lógicos principales

SQL proporciona tres operadores lógicos fundamentales que funcionan de manera similar a los operadores booleanos en otros lenguajes de programación:

• AND: Devuelve verdadero solo cuando ambas condiciones que conecta son verdaderas.

-- Seleccionar productos que sean caros Y tengan poco stock
SELECT * FROM productos WHERE precio > 100 AND stock < 10;

• OR: Devuelve verdadero cuando al menos una de las condiciones que conecta es verdadera.

-- Seleccionar productos en oferta O que sean nuevos
SELECT * FROM productos WHERE en_oferta = TRUE OR fecha_alta >= '2023-01-01';

• NOT: Invierte el resultado de una condición, convirtiendo verdadero en falso y viceversa.

-- Seleccionar productos que NO sean de la categoría 'Accesorios'
SELECT * FROM productos WHERE NOT categoria = 'Accesorios';
-- Equivalente a:
SELECT * FROM productos WHERE categoria <> 'Accesorios';

Combinando operadores lógicos

Podemos combinar múltiples operadores lógicos para crear condiciones más complejas:

-- Productos caros que estén en oferta O productos nuevos con buen stock
SELECT * FROM productos 
WHERE (precio > 100 AND en_oferta = TRUE) 
   OR (fecha_alta >= '2023-01-01' AND stock > 20);

Precedencia de operadores

Al igual que en matemáticas, SQL sigue reglas de precedencia cuando evalúa expresiones con múltiples operadores:

1. Los paréntesis () tienen la mayor precedencia
2. Luego se evalúa el operador NOT
3. Después el operador AND
4. Finalmente el operador OR

Es recomendable usar paréntesis para agrupar condiciones y hacer que nuestras consultas sean más claras y evitar ambigüedades:

-- Sin paréntesis (puede ser confuso)
SELECT * FROM productos 
WHERE categoria = 'Electrónica' AND precio < 50 OR stock > 100;

-- Con paréntesis (más claro)
SELECT * FROM productos 
WHERE categoria = 'Electrónica' AND (precio < 50 OR stock > 100);

En el primer ejemplo, debido a la precedencia de operadores, SQL primero evaluará categoria = 'Electrónica' AND precio < 50 y luego combinará ese resultado con stock > 100 usando OR. El segundo ejemplo clarifica que queremos productos de electrónica que tengan precio bajo O alto stock.

Operador XOR (exclusivo)

Algunos sistemas de bases de datos como MySQL también soportan el operador XOR (OR exclusivo), que devuelve verdadero solo cuando una de las condiciones es verdadera, pero no ambas:

-- En MySQL: productos que están en oferta O son nuevos, pero no ambos
SELECT * FROM productos 
WHERE en_oferta = TRUE XOR fecha_alta >= '2023-01-01';

En PostgreSQL y otros sistemas que no tienen el operador XOR nativo, podemos simularlo:

-- Simulando XOR en PostgreSQL
SELECT * FROM productos 
WHERE (en_oferta = TRUE OR fecha_alta >= '2023-01-01')
  AND NOT (en_oferta = TRUE AND fecha_alta >= '2023-01-01');

Casos prácticos de uso

Los operadores lógicos son especialmente útiles para filtrar datos basados en criterios complejos:

• Filtrado por múltiples criterios:

-- Clientes premium (alto gasto) de ciertas regiones
SELECT * FROM clientes 
WHERE total_compras > 5000 
  AND region IN ('Madrid', 'Barcelona', 'Valencia');

• Condiciones alternativas:

-- Productos que requieren atención: poco stock O mucho tiempo sin ventas
SELECT * FROM productos 
WHERE stock < 5 OR (ultima_venta < '2023-01-01' AND stock > 20);

• Exclusión de grupos específicos:

-- Todos los empleados excepto los de prácticas y tiempo parcial
SELECT * FROM empleados 
WHERE NOT (tipo = 'Prácticas' OR jornada = 'Parcial');

• Rangos complejos:

-- Productos con precio medio (ni muy baratos ni muy caros)
SELECT * FROM productos 
WHERE NOT (precio < 10 OR precio > 100);
-- Equivalente a:
SELECT * FROM productos 
WHERE precio >= 10 AND precio <= 100;

Optimización de consultas con operadores lógicos

Al usar operadores lógicos, es importante considerar cómo afectan al rendimiento de nuestras consultas:

• Ordenar condiciones por selectividad: Colocar primero las condiciones más restrictivas cuando usamos AND puede mejorar el rendimiento, ya que SQL puede descartar filas más rápidamente.

-- Mejor rendimiento si hay pocos productos con precio > 1000
SELECT * FROM productos 
WHERE precio > 1000 AND categoria = 'Electrónica';

• Usar IN en lugar de múltiples OR: Para comparar una columna con varios valores posibles, IN suele ser más eficiente que encadenar condiciones con OR.

-- Menos eficiente
SELECT * FROM productos 
WHERE categoria = 'Electrónica' OR categoria = 'Informática' OR categoria = 'Telefonía';

-- Más eficiente
SELECT * FROM productos 
WHERE categoria IN ('Electrónica', 'Informática', 'Telefonía');

• Evitar negaciones cuando sea posible: Las condiciones positivas suelen ser más eficientes que las negativas, especialmente si hay índices.

-- Menos eficiente
SELECT * FROM productos 
WHERE NOT categoria <> 'Electrónica';

-- Más eficiente
SELECT * FROM productos 
WHERE categoria = 'Electrónica';

Operadores lógicos con valores NULL

Es importante entender cómo interactúan los operadores lógicos con valores NULL:

• AND: Si una condición es falsa y la otra es NULL, el resultado es falso.
• OR: Si una condición es verdadera y la otra es NULL, el resultado es verdadero.
• NOT NULL: Siempre devuelve NULL, no verdadero ni falso.

-- Productos sin categoría asignada o con precio desconocido
SELECT * FROM productos 
WHERE categoria IS NULL OR precio IS NULL;

-- Productos con todos los datos completos
SELECT * FROM productos 
WHERE categoria IS NOT NULL AND precio IS NOT NULL AND stock IS NOT NULL;

Operador CASE con lógica condicional

Aunque no es estrictamente un operador lógico, el operador CASE nos permite implementar lógica condicional en nuestras consultas:

-- Clasificar productos según su precio
SELECT 
    nombre,
    precio,
    CASE 
        WHEN precio < 20 THEN 'Económico'
        WHEN precio BETWEEN 20 AND 100 THEN 'Precio medio'
        WHEN precio > 100 THEN 'Premium'
        ELSE 'Sin clasificar'
    END AS categoria_precio
FROM productos;

Los operadores lógicos son herramientas fundamentales para crear consultas SQL precisas y flexibles. Dominar su uso te permitirá filtrar datos con exactitud, combinando múltiples criterios para obtener exactamente la información que necesitas de tus bases de datos.

NULL y LIKE

En SQL, el manejo de valores nulos y la búsqueda de patrones en texto son capacidades fundamentales para crear consultas efectivas. Estos dos conceptos, aunque diferentes, son esenciales cuando necesitamos filtrar datos con la cláusula WHERE de manera más sofisticada.

Trabajando con valores NULL

En bases de datos, NULL representa la ausencia de un valor o un valor desconocido. No es lo mismo que cero, una cadena vacía o falso; es literalmente la ausencia de datos. Esta característica especial requiere operadores específicos para su manejo.

Identificando valores NULL

Para comprobar si un campo contiene un valor NULL, debemos usar los operadores IS NULL o IS NOT NULL, ya que los operadores de comparación estándar no funcionan con NULL:

-- Encontrar clientes sin número de teléfono
SELECT * FROM clientes WHERE telefono IS NULL;

-- Encontrar productos con precio definido
SELECT * FROM productos WHERE precio IS NOT NULL;

Es importante entender que no podemos usar el operador de igualdad (=) con NULL:

-- Incorrecto: no devolverá resultados
SELECT * FROM clientes WHERE telefono = NULL;

-- Correcto
SELECT * FROM clientes WHERE telefono IS NULL;

Comportamiento de NULL en expresiones

Cualquier operación aritmética o de comparación que involucre NULL dará como resultado NULL:

-- Esta consulta no devolverá filas aunque precio sea NULL
SELECT * FROM productos WHERE precio > 100 OR precio <= 100;

-- Para incluir productos con precio NULL, debemos ser explícitos
SELECT * FROM productos WHERE precio > 100 OR precio <= 100 OR precio IS NULL;

Funciones para manejar NULL

Tanto MySQL como PostgreSQL ofrecen funciones para proporcionar valores alternativos cuando encontramos NULL:

• COALESCE: Devuelve el primer argumento no nulo de una lista.

-- Mostrar 'Sin especificar' cuando la descripción es NULL
SELECT 
    nombre, 
    COALESCE(descripcion, 'Sin especificar') AS descripcion
FROM productos;

• IFNULL (MySQL) o NULLIF (PostgreSQL): Funciones específicas para manejar valores nulos.

-- En MySQL: usar 0 cuando el descuento es NULL
SELECT 
    nombre, 
    precio, 
    IFNULL(descuento, 0) AS descuento_aplicable
FROM productos;

-- En PostgreSQL: convertir valores específicos a NULL
SELECT 
    nombre,
    NULLIF(stock, 0) AS stock_disponible  -- Convierte 0 a NULL
FROM productos;

NULL en condiciones WHERE

El comportamiento de NULL con operadores lógicos puede ser sorprendente:

-- Productos sin categoría o con precio desconocido
SELECT * FROM productos WHERE categoria IS NULL OR precio IS NULL;

-- Productos con todos los datos completos (sin valores NULL)
SELECT * FROM productos WHERE 
    nombre IS NOT NULL AND 
    precio IS NOT NULL AND 
    stock IS NOT NULL;

El operador LIKE para búsquedas de patrones

El operador LIKE nos permite realizar búsquedas de texto basadas en patrones, lo que es extremadamente útil cuando necesitamos encontrar registros que coincidan parcialmente con ciertos criterios textuales.

Caracteres comodín

LIKE utiliza dos caracteres comodín principales:

• % (porcentaje): Representa cualquier secuencia de cero o más caracteres.
• _ (guion bajo): Representa exactamente un carácter.

Ejemplos básicos de LIKE

-- Productos que comienzan con "Smart"
SELECT * FROM productos WHERE nombre LIKE 'Smart%';

-- Productos que terminan con "phone"
SELECT * FROM productos WHERE nombre LIKE '%phone';

-- Productos que contienen la palabra "digital"
SELECT * FROM productos WHERE descripcion LIKE '%digital%';

-- Productos con exactamente 5 caracteres en su código
SELECT * FROM productos WHERE codigo LIKE '_____';

-- Códigos que comienzan con A, seguidos de un dígito y cualquier carácter
SELECT * FROM productos WHERE codigo LIKE 'A__%';

Sensibilidad a mayúsculas y minúsculas

Por defecto, en MySQL las búsquedas con LIKE no distinguen entre mayúsculas y minúsculas, mientras que en PostgreSQL sí lo hacen:

-- En MySQL: ambas consultas devuelven los mismos resultados
SELECT * FROM productos WHERE nombre LIKE '%laptop%';
SELECT * FROM productos WHERE nombre LIKE '%LAPTOP%';

-- En PostgreSQL: para búsquedas insensibles a mayúsculas/minúsculas
SELECT * FROM productos WHERE nombre ILIKE '%laptop%';
-- O alternativamente:
SELECT * FROM productos WHERE LOWER(nombre) LIKE '%laptop%';

Escapando caracteres especiales

Si necesitamos buscar los propios caracteres comodín (% o _), debemos escaparlos:

-- Buscar productos con porcentaje en el nombre (ej: "Descuento 20%")
SELECT * FROM productos WHERE nombre LIKE '%\%%' ESCAPE '\';

-- Buscar productos con guion bajo en el nombre (ej: "modelo_nuevo")
SELECT * FROM productos WHERE nombre LIKE '%\_%' ESCAPE '\';

Negación con NOT LIKE

Podemos negar la condición LIKE para encontrar registros que no coincidan con el patrón:

-- Productos que NO contienen la palabra "básico"
SELECT * FROM productos WHERE nombre NOT LIKE '%básico%';

Casos prácticos de uso

• Búsqueda de correos electrónicos de un dominio específico:

-- Clientes con correo de Gmail
SELECT * FROM clientes WHERE email LIKE '%@gmail.com';

• Búsqueda de números de teléfono con formato específico:

-- Teléfonos que comienzan con prefijo +34
SELECT * FROM clientes WHERE telefono LIKE '+34%';

• Filtrado por año en campos de fecha:

-- Pedidos de 2023 (usando formato de fecha como cadena)
SELECT * FROM pedidos WHERE fecha_pedido::TEXT LIKE '2023-%';

• Búsqueda de palabras completas:

-- Productos que contienen la palabra "pro" como palabra completa
SELECT * FROM productos WHERE 
    nombre LIKE '% pro %' OR 
    nombre LIKE 'pro %' OR 
    nombre LIKE '% pro' OR 
    nombre = 'pro';

Combinando NULL y LIKE

Podemos combinar el manejo de NULL con búsquedas LIKE para crear filtros más sofisticados:

-- Productos sin descripción o con descripción que menciona "básico"
SELECT * FROM productos 
WHERE descripcion IS NULL OR descripcion LIKE '%básico%';

-- Clientes sin email o con email de dominios específicos
SELECT * FROM clientes 
WHERE email IS NULL OR email LIKE '%@gmail.com' OR email LIKE '%@hotmail.com';

Alternativas a LIKE para búsquedas más avanzadas

Aunque LIKE es útil para búsquedas simples de patrones, tiene limitaciones en términos de rendimiento y capacidades. Para búsquedas más complejas o eficientes, tanto MySQL como PostgreSQL ofrecen alternativas:

• Expresiones regulares:

-- En MySQL: usando REGEXP
SELECT * FROM productos WHERE nombre REGEXP '^[A-Z][0-9]{3}';

-- En PostgreSQL: usando ~
SELECT * FROM productos WHERE nombre ~ '^[A-Z][0-9]{3}';

• Búsqueda de texto completo:

-- En MySQL:
SELECT * FROM articulos 
WHERE MATCH(titulo, contenido) AGAINST('inteligencia artificial');

-- En PostgreSQL:
SELECT * FROM articulos 
WHERE to_tsvector('spanish', contenido) @@ to_tsquery('spanish', 'inteligencia & artificial');

Consideraciones de rendimiento

• Las consultas con LIKE '%algo%' (con comodín al inicio) no pueden utilizar índices eficientemente, lo que puede afectar el rendimiento en tablas grandes.
• Las comparaciones con IS NULL también pueden ser lentas si no están optimizadas con índices adecuados.
• Para mejorar el rendimiento en búsquedas de texto frecuentes, considera:
• Crear índices específicos para las columnas utilizadas en búsquedas LIKE
• Utilizar índices de texto completo para búsquedas más complejas
• Implementar tablas de búsqueda separadas para grandes volúmenes de datos

-- Crear un índice para mejorar búsquedas por nombre
CREATE INDEX idx_productos_nombre ON productos(nombre);

-- En PostgreSQL, índice específico para patrones que comienzan con un valor
CREATE INDEX idx_productos_nombre_pattern ON productos(nombre text_pattern_ops);

Dominar el manejo de valores NULL y el operador LIKE te permitirá crear consultas SQL más flexibles y potentes, capaces de filtrar datos con precisión incluso cuando la información está incompleta o necesitas encontrar coincidencias parciales en texto.