4 Agregación Pipeline¶

Introducción¶

La agregación pipeline o tuberías de agregación se basa en someter una colección a un conjunto de operaciones o etapas, estas etapas irán convirtiendo y transformando el conjunto de documentos pertenecientes a la colección, hasta obtener un conjunto de documentos con el resultado deseado.

Se le llama tubería ya que cada etapa irá modificando, moldeando y calculando la estructura de los documentos para pasarlos a la etapa que le sigue.

Funciones de agregado¶

Al igual que en otra base de datos, MongoDB dispone de funciones matemáticas y de cadenas para utilizaras en las consultas.

Funciones Aritméticas¶

Funciones de Cadenas¶

Funciones de Grupo¶

Funciones de Fecha¶

Uso de estas funciones¶

Estas funciones se utilizan en las operaciones de agregación, o consultas de agregación, que lo que hacen es procesar los registros y obtener nuevos resultados, calculados o transformados.

La agregación opera con grupos de valores de múltiples documentos y se puede realizar una variedad de operaciones sobre los datos agrupados para devolver un solo resultado. El objetivo es presentar datos calculados, formateados y/o filtrados de manera diferente a como se encuentra en los documentos.

MongoDB ofrece tres formas de realizar la agregación: la agregación pipeline, la función de map-reduce y la agregación de propósito único.

Etapas Pipeline¶

Las etapas son las siguientes:

La multiplicidad se refiere a cuántos documentos obtenemos como resultado después de aplicar la etapa. De esta forma 1:1 se aplica a un documento y se obtiene otro, n:1 se aplica a n documentos y se obtiene 1, y 1:n se aplica a un documentos y se obtienen n.

Formato pipeline¶

El formato de pipe line es la siguiente:

db.collection.aggregate([
    {
     $etapa1: {
      //...
     }
    }, {
     $etapa2: {
      //...
     }
    },
])

Por ejemplo:

Tenemos la colección articulos, cada registro está formado por los campos: código, denominación, pvp, categoría, uv, y stock.

Vamos a obtener los articulos de los artículos y la categoría convertida a mayúsculas. Se utiliza la etapa $project pues cambiamos el aspecto del documento.

db.articulos.aggregate([
    {
     $project:
     {
      denominacion: {$toUpper: "$denominacion"}
      cetegoria: {$toUpper: "$categoria"}
     }
    }
])

Si dicha salida se desea añadir a la base de datos, se le añade la etapa out:

db.articulos.aggregate([
    {
     $project:
     {
      denominacion: {$toUpper: "$denominacion"}
      cetegoria: {$toUpper: "$categoria"}
     }
    },
    { $out: "salidanueva"}
])

Vamos a obtener la denominación en mayúsculas, el importe de las ventas que serán las uv * pvp, y el stock actual que será stock - uv.

Las etapas a usar en este caso son: project, multiply, substract.

db.articulos.aggregate([
    {
    $project: {
     articulo: {$toUpper: "$denominacion"},
     importe: { $multiply: ["$pvp", "$uv"]},
     stockactual: {$subtract: ["$stock", "$uv"]}
    }
    }
])

Condiciones de agregación¶

Podemos añadir las siguientes condiciones a las consultas de agregación

Ejemplo: A la consulta anterior, vamos a preguntar si el stock actual es negativo, asignaremos a un campo nuevo llamado reponer true si es menor que 0 y false si no lo es:

db.articulos.aggregate([
    {
    $project: {
     articulo: {$toUpper: "$denominacion"},
     importe: { $multiply: ["$pvp", "$uv"]},
     stockactual: {$subtract: ["$stock", "$uv"]},
     reponer: {
      $cond: [
             {$lte: [{$substract: ["stock", "uv"]}, 0]}, true, false
         ] 
     }
    }}
])

En la siguiente consulta, obtenemos por cada categoría el número de artículos, el total unidades vendidas de artículos, y el total importe, la suma de los pvp*unidades. Se utiliza la etapa $group, cuando se usa esta etapa se debe añadir el identificador de objeto _id, en este caso como agrupamos por categoría lo indicamos en el _id. Para contar artículos se utiliza la función $sum

db.articulos.aggregate([
    {
    $group:{
     _id: "$categoria",
     contador: {$sum: 1},
     sumaunidades: {$sum: "$uv"},
     totalimporte: {$sum: {$multiply: ["$pvp", "$uv"]}}
    }
    }
])

En la siguiente consulta obtenemos el número de documentos de la categoría Deportes, el total de unidades vendidas de sus artículos, el total del importe y la media de unidades vendidas. Se utilizan las etapas $match para seleccionar la categoría, y luego $group para obtener resultados agrupados

db.articulos.aggregate([
    {$match: {categoria: "Deportes"}},
    {$group: {
     _id: "Deportes",
     contador: {$sum: 1},
     sumaunidades: { $sum: "$uv"},
     media: { $avg: "$uv"},
     totalimporte: { $sum: { $multiply: ["$pvp", "$uv"]}}
    }}
])

Obtenemos, ahora el precio más caro:

db.articulos.aggreate([
    {$group: {
     _id: null,
     maximo: { $max: "$pvp"}
    }}
])

¿Y sí, queremos obtener el artículo con el precio más caro?

En primer lugar, debemos obtener los datos pvp y denominación, de todos los articulos ordedanos descendentemente por el precio y denominación. ($sort)

Después, el resultado obtenido se agrupa para luego coger el primero con la función $first

db.articulos.aggregate([
    { $sort: { pvp: -1, denominacion: -1}}
    {
     $group:{
      _id:null,
      mascaro: {$first: "$denominacion"}
      precio: {$first: "$pvp"}
     }
    }
])

Ahora, queremos obtener la suma del importe de los artículos cuya denominación empieza por M o P.

Primero, debemos obtener el primer carácter de todos los artículos utilizando la función $substr:

{
 $project: {
  primercarac: { $substr: ["$denominacion", 0, 1]},
  impor: { $multiply: ["$pvp", "$uv"]}
 }
}

Después seleccionamos, de los datos obtenidos, lo que tienen en primercarac P o M:

{$match: {"primercarac": {$in: ["M", "P"]}}}

Finalmente, se agrupa el resultado y se suma los importes:

{
 $group:{
  _id: 1,
  totalimporte: { $sum: "$impor"}
 }
}

La consulta completa sería:

db.articulos.aggregate([
    {
  $project: {
   primercarac: { $substr: ["$denominacion", 0, 1]},
   impor: { $multiply: ["$pvp", "$uv"]}
  }
 },
    {$match: {"primercarac": {$in: ["M", "P"]}}},
    {
        $group:{
            _id: 1,
   totalimporte: { $sum: "$impor"}
  }
 }
])

En la siguiente consulta, obtenemos por cada categoría el artículo con el precio más caro. Para ello primero ordenamos descendentemente por pcategoría, pvp y denominación, utilizando la etapa $sort. Y el resultado obtenido se agrupa con $group para luego obtener el primero de cada categoría con la función $first

db.articulos.aggregate([
    {$sort: {categoria: -1, pvp: -1, denominacion: -1}},
    {
     $group:{
      _id: "$categoria",
      mascaro: { $first: "$denominacion"},
      precio: {$first: "$pvp"}
     }
    }
])

Utilización de Arrays, Campos compuestos y agregados¶

Las siguientes funciones sirve trabajar con arrays:

Vamos a usar ahora la colección Trabajadores. Vamos a insertar un nuevo trabajador

db.trabajadores.insert(
    {
  nombre: {nom: "Alicia", ape1: "Ramos", ape2: "Martín"},
     direccion: {poblacion: "Madrid", calle: {"Avda Toledo 10", }},
     salario: 1200,
     oficios: ["Profesora", "Analista"],
     primas: [20,30,40],
     edad: 50
    }
)

Como podemos observar un empleado, tiene dos campos compuestos, nombre y dirección, y además dos listas: oficios y primas.

Vamos a consultar la población, el nombre descompuesto en nombre, ape1 y ape2, el primer oficio, el segundo y el último. En caso de no tenerlas no devuelve nada. Además lo vamos a ordenar de forma ascendente

db.trabajadores.find({direccion.poblacion: "Toledo"})

db.trabajadores.aggregate([
    {$sort: {direccion.poblacion: 1}},
    {$project: 
     {
      poblacion: "$direccion.poblacion",
      nombre: "$nombre.nom",
      ape1: "$nombre.ape1",
      ape2: "$nombre.ape2",
      oficio1: {$arrayElementAt: ["$oficios", 0]},
      oficio2: {$arrayElementAt: ["$oficios", 1]},
      oficio3: {$arrayElementAt: ["$oficios", -1]}
     }
    }
])

Ahora, obtenemos los elementos que tienen los arrays de los trabajadores, y los arrays concatenados. Se utiliza la función $ifNull para comprobar que los arrays existan en los trabajadores, y evitar errores de salida. Se pregunta si es null, si lo es devuelve el array vacio.

db.trabajadores.aggregate([
    {
    $project:
     {
      nombre: "$nombre.nom",
      numerooficios: {$size: {"$ifNull": ["$oficios", []]}},
      numeroprimas: { $size: { "$ifNull": ["$primas", []]}},
      oficiosconcatenados: {$concatArrays: ["$oficios", "$primas"]}
     }
    }
])

Por último, devolvemos el número de trabajadores y la media de edad de los trabajadores que han tenido el oficio de Analista

db.trabajadores.aggregate([
    {$match: {oficios: "Analista"}},
    {$group: {
     _id: "analista",
     contador: { $sum:1 },
     media: {$avg: "$edad"}
    }}
])