En MariaDB, JSON_ARRAYAGG() es una función integrada que devuelve una matriz JSON que contiene un elemento para cada valor en un conjunto determinado de valores JSON o SQL.
La función actúa sobre una columna o una expresión que se evalúa como un solo valor. Le permite agregar un conjunto de resultados como una sola matriz JSON. Cada fila del conjunto de resultados termina como un solo elemento en la matriz.
Sintaxis
La sintaxis es así:
JSON_ARRAYAGG([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[LIMIT {[offset,] row_count | row_count OFFSET offset}])Ejemplo
Supongamos que consultamos una tabla:
SELECT PetName
FROM Pets;Y obtenga el siguiente conjunto de resultados:
+---------+ | PetName | +---------+ | Fluffy | | Fetch | | Scratch | | Wag | | Tweet | | Fluffy | | Bark | | Meow | +---------+
El resultado es una columna y cada fila contiene un nombre de mascota diferente.
Digamos que queremos que todas las mascotas se enumeren en una matriz JSON (para que cada nombre de mascota sea su propio elemento de matriz).
Podemos usar el JSON_ARRAYAGG() función para hacer precisamente eso:
SELECT JSON_ARRAYAGG(PetName)
FROM Pets;Resultado:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName) | +-------------------------------------------------------------------+ | ["Fluffy","Fetch","Scratch","Wag","Tweet","Fluffy","Bark","Meow"] | +-------------------------------------------------------------------+
Todo lo que hicimos fue pasar el nombre de la columna a JSON_ARRAYAGG() función.
Resultados distintos
Podemos agregar el DISTINCT cláusula para eliminar valores duplicados de la matriz:
SELECT JSON_ARRAYAGG(DISTINCT PetName)
FROM Pets;Resultado:
+----------------------------------------------------------+ | JSON_ARRAYAGG(DISTINCT PetName) | +----------------------------------------------------------+ | ["Bark","Fetch","Fluffy","Meow","Scratch","Tweet","Wag"] | +----------------------------------------------------------+
Fíjate que Fluffy solo se incluyó una vez aquí, mientras que Fluffy se incluyó dos veces en el ejemplo anterior (porque hay dos mascotas llamadas Fluffy ).
Ordenar los resultados
Podemos usar el ORDER BY cláusula para especificar un orden para los elementos de la matriz:
SELECT JSON_ARRAYAGG(PetName ORDER BY PetName DESC)
FROM Pets;Resultado:
+-------------------------------------------------------------------+ | JSON_ARRAYAGG(PetName ORDER BY PetName DESC) | +-------------------------------------------------------------------+ | ["Wag","Tweet","Scratch","Meow","Fluffy","Fluffy","Fetch","Bark"] | +-------------------------------------------------------------------+
Limitar los resultados
Podemos usar el LIMIT cláusula para especificar un orden para los elementos de la matriz:
SELECT JSON_ARRAYAGG(PetName LIMIT 3)
FROM Pets;Resultado:
+--------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3) | +--------------------------------+ | ["Fluffy","Fetch","Scratch"] | +--------------------------------+
También podemos usar un desplazamiento para el LIMIT cláusula:
SELECT JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2)
FROM Pets;Resultado:
+-----------------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 3 OFFSET 2) | +-----------------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------------+
Alternativamente, podemos omitir el LIMIT y OFFSET palabras clave y cambie los números (y sepárelos con una coma) para lograr el mismo resultado:
SELECT JSON_ARRAYAGG(PetName LIMIT 2, 3)
FROM Pets;Resultado:
+-----------------------------------+ | JSON_ARRAYAGG(PetName LIMIT 2, 3) | +-----------------------------------+ | ["Scratch","Wag","Tweet"] | +-----------------------------------+
Resultados agrupados
Podemos usar el SQL GROUP BY cláusula para producir matrices basadas en una agrupación de otra columna.
Supongamos que agregamos una columna a nuestra consulta original:
SELECT
PetTypeId,
PetName
FROM Pets;Resultado:
+-----------+---------+ | PetTypeId | PetName | +-----------+---------+ | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-----------+---------+
Ahora tenemos un PetTypeId columna así como el PetName columna. Esto hace coincidir un tipo de mascota con cada nombre.
Aquí hay un ejemplo del uso de GROUP BY cláusula para agrupar nuestros resultados por el PetTypeId columna mientras usa JSON_ARRAYAGG() función:
SELECT
PetTypeId,
JSON_ARRAYAGG(PetName)
FROM Pets
GROUP BY PetTypeId;Resultado:
+-----------+---------------------------------+ | PetTypeId | JSON_ARRAYAGG(PetName) | +-----------+---------------------------------+ | 1 | ["Tweet"] | | 2 | ["Fluffy","Scratch","Meow"] | | 3 | ["Fetch","Wag","Fluffy","Bark"] | +-----------+---------------------------------+
Esto nos permitió crear una matriz separada para cada tipo de mascota.
La siguiente consulta usa un INNER JOIN en otra tabla para devolver el tipo de mascota real, no solo la ID.
SELECT
pt.PetType,
p.PetName
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;Resultado:
+---------+---------+ | PetType | PetName | +---------+---------+ | Bird | Tweet | | Cat | Scratch | | Cat | Fluffy | | Cat | Meow | | Dog | Wag | | Dog | Fetch | | Dog | Bark | | Dog | Fluffy | +---------+---------+
Podemos ver que cada tipo de mascota aparece en la primera columna y el nombre de la mascota aparece en la segunda columna.
Ahora usemos el JSON_ARRAYAGG() función:
SELECT
pt.PetType,
JSON_ARRAYAGG(p.PetName)
FROM Pets p
INNER JOIN PetTypes pt
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;Resultado:
+---------+--------------------------+ | PetType | JSON_ARRAYAGG(p.PetName) | +---------+--------------------------+ | Bird | Tweet | | Cat | Scratch,Fluffy,Meow | | Dog | Wag,Fetch,Bark,Fluffy | +---------+--------------------------+
