Tutorial SQL: Filtrado de valores únicos con DISTINCT

Eliminación de duplicados

Cuando trabajamos con bases de datos, es común encontrarnos con resultados que contienen valores repetidos. SQL nos proporciona una herramienta específica para eliminar estas duplicidades: la cláusula DISTINCT. Esta cláusula nos permite obtener únicamente los valores únicos de las columnas seleccionadas en una consulta.

La sintaxis básica de DISTINCT es sencilla pero poderosa:

SELECT DISTINCT columna1, columna2, ...
FROM tabla
WHERE condición;

Cuando utilizamos DISTINCT, SQL examina todas las filas del resultado y elimina las duplicadas, mostrando solo una ocurrencia de cada combinación de valores. Esto resulta especialmente útil cuando necesitamos conocer los diferentes valores que existen en una columna sin que aparezcan repetidos.

Uso básico de DISTINCT

Veamos un ejemplo práctico. Supongamos que tenemos una tabla empleados con información sobre los trabajadores de una empresa:

SELECT * FROM empleados;

Si queremos conocer los diferentes departamentos que existen en la empresa, sin repeticiones, utilizaríamos:

SELECT DISTINCT departamento
FROM empleados;

El resultado sería:

Como podemos observar, aunque "Ventas" aparece tres veces en la tabla original, con DISTINCT solo aparece una vez en el resultado.

Casos de uso comunes

La eliminación de duplicados resulta fundamental en varios escenarios:

• Análisis exploratorio: Para conocer rápidamente los diferentes valores que existen en una columna.

-- Obtener las diferentes ciudades donde hay empleados
SELECT DISTINCT ciudad FROM empleados;

• Verificación de datos: Para comprobar si existen valores no esperados o errores.

-- Verificar los posibles estados de un pedido
SELECT DISTINCT estado FROM pedidos;

• Reportes y estadísticas: Para generar informes con valores únicos.

-- Obtener los diferentes países de los clientes
SELECT DISTINCT pais FROM clientes;

DISTINCT con NULL

Un aspecto importante a tener en cuenta es que DISTINCT trata los valores NULL como iguales entre sí. Esto significa que si una columna contiene varios valores NULL, solo se mostrará uno en el resultado.

-- Tabla con valores NULL
CREATE TABLE ejemplo (valor INT);
INSERT INTO ejemplo VALUES (1), (2), (NULL), (3), (NULL), (2);

-- Consulta con DISTINCT
SELECT DISTINCT valor FROM ejemplo;

Resultado:

Optimización y rendimiento

Aunque DISTINCT es una herramienta muy útil, es importante considerar su impacto en el rendimiento. Al utilizar DISTINCT, el motor de base de datos debe realizar operaciones adicionales para eliminar duplicados, lo que puede afectar al rendimiento en tablas grandes.

Algunas consideraciones:

• Utiliza DISTINCT solo cuando sea realmente necesario.
• Si solo necesitas verificar la existencia de valores únicos, considera usar EXISTS o GROUP BY como alternativas que pueden ser más eficientes en ciertos casos.
• En MySQL y PostgreSQL, DISTINCT puede beneficiarse de índices en las columnas involucradas, mejorando así su rendimiento.

-- Alternativa usando GROUP BY (puede ser más eficiente en algunos casos)
SELECT departamento
FROM empleados
GROUP BY departamento;

Diferencias entre MySQL y PostgreSQL

Aunque la sintaxis básica de DISTINCT es similar en MySQL y PostgreSQL, existen algunas diferencias sutiles:

• PostgreSQL ofrece la cláusula DISTINCT ON (que veremos en otra sección) que permite un control más preciso sobre qué filas se consideran duplicadas.
• MySQL tiende a optimizar automáticamente consultas con DISTINCT en ciertas situaciones, especialmente cuando se combina con ORDER BY.

En ambos sistemas, es recomendable crear índices en las columnas que se utilizan frecuentemente con DISTINCT para mejorar el rendimiento.

Ejemplo práctico

Veamos un ejemplo más completo. Supongamos que tenemos una tabla ventas con información sobre transacciones:

CREATE TABLE ventas (
    id INT PRIMARY KEY,
    producto_id INT,
    cliente_id INT,
    vendedor_id INT,
    fecha DATE,
    monto DECIMAL(10,2)
);

Si queremos obtener una lista de los diferentes vendedores que han realizado ventas en el último mes:

SELECT DISTINCT vendedor_id
FROM ventas
WHERE fecha >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH);

En PostgreSQL, la misma consulta sería:

SELECT DISTINCT vendedor_id
FROM ventas
WHERE fecha >= CURRENT_DATE - INTERVAL '1 month';

Este tipo de consulta es muy útil para análisis de actividad comercial, permitiéndonos identificar rápidamente qué vendedores han estado activos recientemente.

DISTINCT multicolumna

Mientras que el uso básico de DISTINCT nos permite eliminar filas duplicadas basándonos en una sola columna, SQL también nos ofrece la posibilidad de trabajar con múltiples columnas simultáneamente. Esta funcionalidad resulta especialmente útil cuando necesitamos identificar combinaciones únicas de valores en varias columnas.

La sintaxis para utilizar DISTINCT con múltiples columnas es muy similar a la versión básica:

SELECT DISTINCT columna1, columna2, columna3, ...
FROM tabla
WHERE condición;

Cuando aplicamos DISTINCT a varias columnas, SQL considera como duplicada una fila solo cuando todos los valores de las columnas especificadas coinciden con otra fila. Esto significa que el conjunto completo de valores debe ser idéntico para que se considere un duplicado.

Funcionamiento del DISTINCT multicolumna

Para entender mejor cómo funciona, consideremos la siguiente tabla pedidos:

CREATE TABLE pedidos (
    id INT PRIMARY KEY,
    cliente_id INT,
    producto_id INT,
    categoria VARCHAR(50),
    cantidad INT,
    fecha DATE
);

Con algunos datos de ejemplo:

Si queremos conocer las combinaciones únicas de cliente_id y producto_id, utilizaríamos:

SELECT DISTINCT cliente_id, producto_id
FROM pedidos;

El resultado sería:

Observa que aunque el cliente 101 aparece tres veces en la tabla original, en el resultado solo aparece dos veces porque ha comprado dos productos diferentes (201 y 408). La combinación cliente_id=101 y producto_id=201 aparece una sola vez en el resultado, aunque exista en múltiples filas de la tabla original.

Casos de uso prácticos

El DISTINCT multicolumna resulta valioso en numerosos escenarios de análisis de datos:

• Análisis de comportamiento de clientes:

-- Obtener combinaciones únicas de cliente y categoría de producto
SELECT DISTINCT cliente_id, categoria
FROM pedidos
ORDER BY cliente_id;

• Identificación de patrones de compra:

-- Combinaciones únicas de producto y mes de compra
SELECT DISTINCT producto_id, EXTRACT(MONTH FROM fecha) AS mes
FROM pedidos
WHERE EXTRACT(YEAR FROM fecha) = 2023;

• Auditoría de datos:

-- Verificar combinaciones únicas de usuario y permiso en un sistema
SELECT DISTINCT usuario_id, permiso_id
FROM permisos_usuarios;

Combinación con otras cláusulas

El DISTINCT multicolumna puede combinarse con otras cláusulas SQL para análisis más complejos:

-- Obtener combinaciones únicas de cliente y producto para pedidos grandes
SELECT DISTINCT cliente_id, producto_id
FROM pedidos
WHERE cantidad > 2
ORDER BY cliente_id;

También podemos utilizar funciones en las columnas seleccionadas:

-- Combinaciones únicas de categoría y mes de compra
SELECT DISTINCT categoria, DATE_FORMAT(fecha, '%Y-%m') AS mes
FROM pedidos
WHERE fecha >= '2023-01-01';

En PostgreSQL, la misma consulta sería:

-- Combinaciones únicas de categoría y mes de compra en PostgreSQL
SELECT DISTINCT categoria, TO_CHAR(fecha, 'YYYY-MM') AS mes
FROM pedidos
WHERE fecha >= '2023-01-01';

Consideraciones de rendimiento

Al utilizar DISTINCT con múltiples columnas, es importante tener en cuenta algunas consideraciones de rendimiento:

• El impacto en el rendimiento aumenta con el número de columnas incluidas en la cláusula DISTINCT.
• Las columnas con muchos valores únicos pueden hacer que la operación sea más costosa.
• Los índices compuestos que incluyen las columnas utilizadas en el DISTINCT pueden mejorar significativamente el rendimiento.

-- Crear un índice compuesto para mejorar consultas DISTINCT frecuentes
CREATE INDEX idx_cliente_producto ON pedidos(cliente_id, producto_id);

Diferencia entre DISTINCT y GROUP BY

Aunque tanto DISTINCT como GROUP BY pueden utilizarse para eliminar duplicados, existen diferencias importantes:

-- Usando DISTINCT
SELECT DISTINCT cliente_id, producto_id
FROM pedidos;

-- Usando GROUP BY
SELECT cliente_id, producto_id
FROM pedidos
GROUP BY cliente_id, producto_id;

Ambas consultas producen resultados similares, pero:

• DISTINCT está optimizado específicamente para eliminar duplicados.
• GROUP BY está diseñado para agrupar filas para funciones de agregación (aunque también elimina duplicados).
• En consultas complejas o con grandes volúmenes de datos, puede haber diferencias de rendimiento entre ambos enfoques.

Ejemplo práctico: análisis de ventas

Imaginemos que queremos analizar las diferentes combinaciones de vendedor y región de ventas en una empresa:

CREATE TABLE ventas (
    id INT PRIMARY KEY,
    vendedor_id INT,
    region VARCHAR(50),
    producto VARCHAR(100),
    monto DECIMAL(10,2),
    fecha DATE
);

Para identificar en qué regiones ha vendido cada vendedor:

SELECT DISTINCT vendedor_id, region
FROM ventas
ORDER BY vendedor_id, region;

Este análisis nos permitiría identificar rápidamente la cobertura territorial de cada vendedor, lo que podría ser útil para la planificación de territorios comerciales o para identificar oportunidades de expansión.

Limitaciones y consideraciones

Al trabajar con DISTINCT multicolumna, es importante tener en cuenta:

• Los valores NULL en cualquiera de las columnas se consideran iguales entre sí.
• El orden de las columnas en la cláusula DISTINCT no afecta a qué filas se consideran duplicadas, pero puede afectar al orden de presentación de los resultados.
• En tablas muy grandes, considerar alternativas como consultas con GROUP BY o subconsultas que puedan ser más eficientes según el caso específico.

DISTINCT y otras cláusulas

La cláusula DISTINCT no opera de forma aislada en SQL, sino que puede combinarse eficazmente con otras cláusulas para crear consultas más potentes y específicas. Entender cómo interactúa DISTINCT con otras partes de una consulta SQL nos permite aprovechar al máximo esta funcionalidad para resolver problemas complejos de análisis de datos.

Combinación con WHERE

Una de las combinaciones más comunes es usar DISTINCT junto con la cláusula WHERE para filtrar registros antes de eliminar duplicados:

SELECT DISTINCT columna1, columna2
FROM tabla
WHERE condición;

El orden de ejecución es importante: primero se aplica el filtro WHERE y luego se eliminan los duplicados con DISTINCT. Esto puede mejorar significativamente el rendimiento, ya que reduce la cantidad de datos que deben procesarse para eliminar duplicados.

Ejemplo práctico con una tabla de productos:

-- Obtener categorías únicas de productos activos
SELECT DISTINCT categoria
FROM productos
WHERE estado = 'activo';

DISTINCT con ORDER BY

Cuando combinamos DISTINCT con ORDER BY, podemos obtener valores únicos ordenados según nuestras necesidades:

SELECT DISTINCT ciudad
FROM clientes
WHERE pais = 'España'
ORDER BY ciudad ASC;

Es importante notar que en SQL estándar, las columnas utilizadas en ORDER BY deben aparecer en la lista de selección cuando se usa DISTINCT. Sin embargo, MySQL es más flexible y permite ordenar por columnas que no están en la lista de selección.

PostgreSQL, por su parte, sigue el estándar SQL más estrictamente:

-- Esto funciona en MySQL pero podría no funcionar en PostgreSQL
SELECT DISTINCT ciudad
FROM clientes
ORDER BY codigo_postal;

DISTINCT con LIMIT

La combinación de DISTINCT con LIMIT nos permite obtener un número específico de valores únicos:

-- Obtener las primeras 5 categorías únicas de productos
SELECT DISTINCT categoria
FROM productos
ORDER BY categoria
LIMIT 5;

Esta combinación resulta útil para análisis exploratorios rápidos o para crear interfaces de usuario que muestren un conjunto limitado de opciones únicas.

DISTINCT con funciones de agregación

Aunque DISTINCT no se puede aplicar directamente a funciones de agregación como SUM o AVG, sí puede utilizarse dentro de estas funciones:

-- Contar cuántos departamentos diferentes hay
SELECT COUNT(DISTINCT departamento) AS total_departamentos
FROM empleados;

Esta consulta cuenta el número de valores únicos en la columna departamento, en lugar de contar todas las filas.

Comparemos con una consulta sin DISTINCT:

-- Contar todas las filas
SELECT COUNT(departamento) AS total_registros
FROM empleados;

La diferencia puede ser significativa en tablas con muchos valores duplicados.

DISTINCT con subconsultas

DISTINCT también puede utilizarse en subconsultas para filtrar resultados basados en valores únicos:

-- Clientes que han comprado al menos un producto de la categoría 'Electrónica'
SELECT nombre, email
FROM clientes
WHERE id IN (
    SELECT DISTINCT cliente_id
    FROM pedidos
    WHERE categoria = 'Electrónica'
);

Esta consulta primero identifica los IDs únicos de clientes que han comprado productos electrónicos, y luego obtiene los detalles de esos clientes.

DISTINCT ON en PostgreSQL

PostgreSQL ofrece una extensión única llamada DISTINCT ON que permite seleccionar la primera fila de cada grupo de filas duplicadas:

-- Obtener el pedido más reciente de cada cliente
SELECT DISTINCT ON (cliente_id) cliente_id, id_pedido, fecha
FROM pedidos
ORDER BY cliente_id, fecha DESC;

Esta consulta devuelve una fila por cada cliente_id, específicamente la que tiene la fecha más reciente debido al ordenamiento. Esta funcionalidad no está disponible en MySQL, donde tendríamos que usar otras técnicas como subconsultas o GROUP BY con funciones de agregación.

Combinación con CASE

Podemos combinar DISTINCT con expresiones CASE para análisis más sofisticados:

-- Obtener combinaciones únicas de región y tamaño de empresa
SELECT DISTINCT region, 
    CASE 
        WHEN num_empleados < 10 THEN 'Pequeña'
        WHEN num_empleados < 100 THEN 'Mediana'
        ELSE 'Grande'
    END AS tamaño_empresa
FROM empresas
ORDER BY region, tamaño_empresa;

Esta consulta nos da una visión única de la distribución de tamaños de empresa por región.

DISTINCT con UNION, INTERSECT y EXCEPT

Las operaciones de conjuntos en SQL (UNION, INTERSECT, EXCEPT) eliminan duplicados por defecto, por lo que usar DISTINCT con ellas suele ser redundante:

-- UNION ya elimina duplicados por defecto
SELECT ciudad FROM clientes
UNION
SELECT ciudad FROM proveedores;

-- Para mantener duplicados, se usa UNION ALL
SELECT ciudad FROM clientes
UNION ALL
SELECT ciudad FROM proveedores;

Sin embargo, podríamos necesitar DISTINCT dentro de cada consulta individual:

SELECT DISTINCT ciudad FROM clientes
UNION
SELECT DISTINCT ciudad FROM proveedores;

Consideraciones de rendimiento

Al combinar DISTINCT con otras cláusulas, debemos considerar el impacto en el rendimiento:

• El orden de las cláusulas afecta a cómo se ejecuta la consulta internamente.
• Aplicar filtros (WHERE) antes de DISTINCT puede mejorar significativamente el rendimiento.
• Los índices adecuados son cruciales para consultas eficientes con DISTINCT.

-- Índice que puede mejorar consultas con DISTINCT y WHERE
CREATE INDEX idx_categoria_estado ON productos(categoria, estado);

Ejemplo práctico: análisis de ventas

Veamos un ejemplo completo que combina varias cláusulas con DISTINCT:

-- Obtener las 10 categorías de productos más vendidas en 2023
SELECT DISTINCT categoria
FROM ventas
WHERE EXTRACT(YEAR FROM fecha) = 2023
  AND estado = 'completado'
ORDER BY (
    SELECT SUM(cantidad)
    FROM ventas v2
    WHERE v2.categoria = ventas.categoria
      AND EXTRACT(YEAR FROM v2.fecha) = 2023
      AND v2.estado = 'completado'
) DESC
LIMIT 10;

En MySQL, podríamos escribirlo así:

-- Versión MySQL
SELECT DISTINCT categoria
FROM ventas
WHERE YEAR(fecha) = 2023
  AND estado = 'completado'
ORDER BY (
    SELECT SUM(cantidad)
    FROM ventas v2
    WHERE v2.categoria = ventas.categoria
      AND YEAR(v2.fecha) = 2023
      AND v2.estado = 'completado'
) DESC
LIMIT 10;

Esta consulta combina DISTINCT, WHERE, subconsultas, ORDER BY y LIMIT para obtener un análisis de ventas sofisticado.

Diferencias entre MySQL y PostgreSQL

Al trabajar con DISTINCT y otras cláusulas, es importante tener en cuenta algunas diferencias entre MySQL y PostgreSQL:

• PostgreSQL ofrece DISTINCT ON, que no está disponible en MySQL.
• MySQL es más flexible con ORDER BY cuando se usa con DISTINCT.
• PostgreSQL tiende a seguir más estrictamente el estándar SQL.
• Las funciones de fecha y hora tienen sintaxis diferentes (EXTRACT vs YEAR, MONTH, etc.).

Estas diferencias deben tenerse en cuenta al desarrollar consultas que deban funcionar en ambos sistemas de gestión de bases de datos.