0Pricing
SQL Academy · Lección

UNNEST y agregación

Convierta arrays en filas y viceversa

UNNEST y agregación es una lección gratuita de SQL Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de SQL Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué es UNNEST?

PostgreSQL permite almacenar arrays dentro de una sola columna. Sin embargo, a veces necesita trabajar con cada elemento individualmente; ahí es donde entra en juego UNNEST.

UNNEST es una función que devuelve conjuntos y que expande un array en un conjunto de filas, una por cada elemento. Piense en ella como lo contrario de una agregación: en lugar de combinar muchas filas en una sola, descompone un valor en muchas filas.

Ejemplo básico de UNNEST

El uso más sencillo de UNNEST consiste en pasarle directamente un literal de array. Cada elemento se convierte en su propia fila en el conjunto de resultados.

Aquí expandimos un array simple de enteros en filas individuales:

SELECT UNNEST(ARRAY[10, 20, 30, 40]) AS value;

UNNEST con arrays de texto

UNNEST funciona con cualquier tipo de array, incluido el texto. Es útil cuando tiene una columna que almacena etiquetas, categorías o datos similares a los separados por comas, codificados como un array de PostgreSQL.

SELECT UNNEST(ARRAY['apple', 'banana', 'cherry']) AS fruit;

UNNEST a partir de una columna de tabla

La verdadera potencia de UNNEST se aprecia al utilizarlo sobre una columna de una tabla real. Cada fila de la tabla puede tener un array de distinta longitud, y UNNEST expandirá todos ellos en filas individuales.

En este ejemplo, una tabla products tiene una columna de tipo array de texto llamada tags:

CREATE TABLE products (
  id   SERIAL PRIMARY KEY,
  name TEXT,
  tags TEXT[]
);

INSERT INTO products (name, tags) VALUES
  ('Laptop',  ARRAY['electronics', 'computing', 'portable']),
  ('Shirt',   ARRAY['clothing', 'casual']),
  ('Blender', ARRAY['kitchen', 'electronics']);

SELECT name, UNNEST(tags) AS tag
FROM products;

Contar apariciones de etiquetas

Una vez que convierte una columna de tipo array en filas con UNNEST, puede tratar los resultados como cualquier otra fila y aplicar funciones de agregación. Aquí contamos cuántos productos están asociados a cada etiqueta.

El patrón es: usar UNNEST en una subconsulta o CTE y, después, aplicar GROUP BY al valor expandido:

SELECT tag, COUNT(*) AS product_count
FROM (
  SELECT UNNEST(tags) AS tag
  FROM products
) AS expanded
GROUP BY tag
ORDER BY product_count DESC;

UNNEST con ordinalidad

A veces importa la posición de un elemento dentro del array. PostgreSQL proporciona WITH ORDINALITY para asociar un número de fila a cada elemento expandido, de modo que pueda conocer su índice original en el array (comenzando en 1).

SELECT val, pos
FROM UNNEST(ARRAY['first', 'second', 'third']) WITH ORDINALITY AS t(val, pos);

Usar ordinalidad en una tabla

WITH ORDINALITY resulta especialmente útil cuando almacena listas ordenadas en un array. Por ejemplo, una tabla de listas de reproducción en la que importa el orden de las pistas:

CREATE TABLE playlists (
  id     SERIAL PRIMARY KEY,
  title  TEXT,
  tracks TEXT[]
);

INSERT INTO playlists (title, tracks) VALUES
  ('Morning Mix', ARRAY['Song A', 'Song B', 'Song C']);

SELECT p.title, track, position
FROM playlists p,
     UNNEST(p.tracks) WITH ORDINALITY AS t(track, position)
ORDER BY p.id, position;

Filtrar después de UNNEST

Como UNNEST convierte los elementos de un array en filas, puede filtrarlos con una cláusula WHERE normal. Esto le permite buscar todas las filas cuyo array contenga un valor específico sin usar el operador de inclusión de arrays.

SELECT DISTINCT name
FROM products,
     UNNEST(tags) AS tag
WHERE tag = 'electronics';

Volver a agregar en un array

El equivalente inverso de UNNEST es ARRAY_AGG. Después de expandir las filas y transformarlas o filtrarlas, puede recopilar de nuevo los resultados en un array. Este patrón de ida y vuelta —expandir, procesar y volver a agregar— es una expresión habitual de PostgreSQL.

SELECT ARRAY_AGG(tag ORDER BY tag) AS sorted_tags
FROM (
  SELECT UNNEST(ARRAY['cherry', 'apple', 'banana']) AS tag
) AS t;

Desduplicar elementos de un array

Un uso práctico del recorrido de ida y vuelta entre UNNEST y la agregación es eliminar elementos duplicados de un array. Aplique UNNEST al array, use DISTINCT y vuelva a recopilar los elementos con ARRAY_AGG:

SELECT ARRAY_AGG(DISTINCT tag ORDER BY tag) AS unique_tags
FROM UNNEST(ARRAY['sql', 'database', 'sql', 'postgresql', 'database']) AS tag;

Combinar varias columnas de arrays

Puede aplicar UNNEST a varios arrays en paralelo dentro de la cláusula FROM. PostgreSQL empareja los elementos según su posición. Si los arrays tienen longitudes diferentes, el más corto produce valores NULL para las posiciones adicionales del array más largo.

SELECT key, value
FROM UNNEST(
  ARRAY['name',    'city',      'role'],
  ARRAY['Alice',   'Istanbul',  'DBA']
) AS t(key, value);

Comprobación de conocimientos

Compruebe cuánto ha entendido sobre UNNEST y la agregación de arrays en PostgreSQL.

Repaso de la lección

En esta lección aprendió a convertir arrays en filas y volver a convertirlos en arrays mediante las funciones integradas de PostgreSQL:

  • UNNEST — expande un array en una fila por elemento; funciona tanto con literales como con columnas de tablas.
  • WITH ORDINALITY — añade un índice de posición a cada elemento obtenido mediante UNNEST para que pueda conocer su orden original en el array.
  • Filtrado — después de aplicar UNNEST puede usar WHERE igual que con cualquier fila normal.
  • ARRAY_AGG — es la operación inversa de UNNEST: vuelve a recopilar las filas en un array, opcionalmente con ORDER BY o DISTINCT.
  • UNNEST en paralelo — varios arrays de la cláusula FROM se expanden uno junto a otro y se emparejan según su posición.

Dominar este patrón de aplicar UNNEST, procesar y volver a agregar los datos le permite trabajar con arrays aprovechando toda la expresividad de SQL.

Preguntas frecuentes

¿La lección «UNNEST y agregación» es gratis?

Sí — el texto completo de «UNNEST y agregación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de SQL Academy, actualiza a CoddyKit PRO. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué aprenderé en «UNNEST y agregación»?

Convierta arrays en filas y viceversa Practicas SQL Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar SQL Academy?

No se requiere experiencia previa. SQL Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «UNNEST y agregación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de SQL Academy?

Sí. Cada lección de SQL Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos básicos de las columnas de arrays
  2. Búsqueda dentro de arrays
  3. UNNEST y agregación
  4. Arrays frente a tablas normalizadas
← Volver a SQL Academy