/ /

$fill (etapa de agregación)

Definición

$fill

Nuevo en la versión 5.3.

Rellena null y los valores de campo faltantes dentro de los documentos.

Puedes usar $fill para completar los puntos de datos faltantes:

En una secuencia basada en valores circundantes.
Con un valor fijo.

Sintaxis

La etapa $fill tiene esta sintaxis:

{
   $fill: {
      partitionBy: <expression>,
      partitionByFields: [ <field 1>, <field 2>, ... , <field n> ],
      sortBy: {
         <sort field 1>: <sort order>,
         <sort field 2>: <sort order>,
         ...,
         <sort field n>: <sort order>
      },
      output: {
         <field 1>: { value: <expression> },
         <field 2>: { method: <string> },
         ...
      }
   }
}

La etapa $fill toma un documento con estos campos:

Campo	Necesidad	Descripción
partitionBy	Opcional	Especifica una expresión para agrupar los documentos. En la etapa `$fill`, un grupo de documentos se conoce como partición. Si omite partitionBy y partitionByFields, `$fill` utiliza una partición para toda la colección. partitionBy y partitionByFields son mutuamente excluyentes. Vea un ejemplo.
partitionByFields	Opcional	Especifica una matriz de campos como clave compuesta para agrupar los documentos. En la etapa `$fill`, cada grupo de documentos se conoce como partición. Si omite partitionBy y partitionByFields, `$fill` utiliza una partición para toda la colección. partitionBy y partitionByFields son mutuamente excluyentes. Consulte las restricciones de `partitionByFields`.
sortBy	Obligatorio si el método se especifica en al menos un campo de salida.<field> De lo contrario, opcional.	Especifica el campo o campos para ordenar los documentos dentro de cada partición. Utiliza la misma sintaxis que la etapa `$sort`.
salida	Requerido	Especifica un objeto que contiene cada campo para el cual se deben completar los valores faltantes. Puede especificar varios campos en el objeto de salida. El nombre del objeto es el nombre del campo que se debe completar. El valor del objeto especifica cómo se llena el campo.
output.<field>	Requerido	Especifica un objeto que indica cómo rellenar los valores ausentes en el campo objetivo. El nombre del objeto debe ser `value` o `method`. Si el nombre es: `value`, el valor debe ser una expresión que indique el valor utilizado para rellenar el campo objetivo. `method`El valor debe ser `linear` o `locf`. Si especificas: `linear` Método de relleno, los valores se rellenan utilizando interpolación lineal basada en los valores no-`null` circundantes en la secuencia. `locf` método de llenado, los valores se rellenan basándose en el último valor no nulo del campo de la partición. `locf` significa última observación trasladada hacia adelante. Para obtener más información, consulta: Detalles del comportamiento lineal Ejemplo de Relleno Lineal Detalles de comportamiento locf Ejemplo de llenado locf

Comportamiento y restricciones

`partitionByFields` Restricciones

$fill devuelve un error si algún nombre de campo en la matriz partitionByFields:

Evalúa a un valor que no es una cadena.
Comienza con $.

`linear` Comportamiento

El método de relleno linear rellena null y los campos faltantes mediante interpolación lineal basada en los valores no null circundantes en la secuencia.

Para cada documento donde el campo sea null o falte, linearFill rellena esos campos en proporción al rango de valores faltantes entre los valores no null circundantes según el orden de ordenación. Para determinar los valores de los campos faltantes, linearFill utiliza:
- La diferencia de los valores nonull circundantes.
- El número de campos null a llenar entre los valores circundantes.
El método linear puede rellenar múltiples valores consecutivos de null si dichos valores están precedidos y seguidos por valores que no seannull, de acuerdo con el orden sortBy.
Ejemplo
Si una colección contiene estos documentos:
{ index: 0, value: 0 }, { index: 1, value: null }, { index: 2, value: null }, { index: 3, value: null }, { index: 4, value: 10 }
Después de usar el método de llenado linear para llenar los valores null, los documentos se vuelven:
{ index: 0, value: 0 }, { index: 1, value: 2.5 }, { index: 2, value: 5 }, { index: 3, value: 7.5 }, { index: 4, value: 10 }
null los valores que no están precedidos ni seguidos por valores que no sonnull permanecen null.
Para utilizar el método de relleno linear, también debe utilizar el campo sortBy para ordenar sus datos.

Para ver un ejemplo completo utilizando el método de llenado linear, consulta Completa los valores de los campos faltantes con interpolación lineal.

`sortBy` Restricciones

Cuando utiliza el método de relleno linear:

Puedes especificar exactamente un campo en sortBy. $fill devuelve un error si especificas varios campos.
$fill devuelve un error si hay valores repetidos en el campo sortBy en una sola partición.

Starting in MongoDB 8.0.20, $fill can interpolate when different partitions contain identical sortBy values. To learn more, see Interpolate Identical Values in Different Partitions.

`locf` Comportamiento

locf corresponde a la última observación trasladada.

Si un campo que se está rellenando contiene tanto null como valores no nulos, locf establece los valores null y los valores faltantes al último valor no nulo conocido del campo según el orden de ordenación.
- Si el campo contiene solo null o valores faltantes en una partición, locf establece el valor del campo en null para esa partición.
- null y los campos faltantes que aparecen antes de los valores no nulos en el orden de clasificación permanecen null.
Para utilizar el método de relleno locf, también debe utilizar el campo sortBy para ordenar sus datos.

Para ver un ejemplo completo del método de relleno locf, consulte Rellenar valores de campo faltantes según el último valor observado.

Comparación de `$fill` y operadores de agregación

Para completar null y los valores de campos faltantes dentro de un documento puedes usar:

La etapa $fill.

Cuando se utiliza la etapa $fill, el campo que se especifica en la salida es el mismo campo que se utiliza como datos de origen.
Los operadores de agregación $linearFill y $locf.

Cuando $linearFill o $locf, pueden establecerse valores para un campo diferente del que se utiliza como datos fuente.

Ejemplos

Los ejemplos de esta sección muestran cómo usar $fill para rellenar valores faltantes:

Con un valor constante
Con interpolación lineal
Según el último valor observado
Para particiones distintas.
Con la interpolación lineal para valores idénticos en diferentes particiones

Completar valores de campos faltantes con un valor constante

Una tienda de calzado mantiene una colección dailySales que contiene un documento que resume las ventas diarias. La tienda de zapatos vende estos tipos de zapatos:

boots
sandals
sneakers

Cree la siguiente colección dailySales:

db.dailySales.insertMany( [
   {
      "date": ISODate("2022-02-02"),
      "bootsSold": 10,
      "sandalsSold": 20,
      "sneakersSold": 12
   },
   {
      "date": ISODate("2022-02-03"),
      "bootsSold": 7,
      "sneakersSold": 18
   },
   {
      "date": ISODate("2022-02-04"),
      "sneakersSold": 5
   }
] )

No todos los documentos en la colección dailySales contienen cada tipo de zapato. Si falta un tipo de zapato, significa que no se vendieron zapatos de ese tipo en la fecha correspondiente.

El siguiente ejemplo utiliza $fill para establecer las cantidades vendidas a 0 para los tipos de zapatos faltantes para las ventas de cada día:

db.dailySales.aggregate( [
   {
      $fill:
         {
            output:
               {
                  "bootsSold": { value: 0 },
                  "sandalsSold": { value: 0 },
                  "sneakersSold": { value: 0 }
               }
         }
   }
] )

En el pipeline anterior:

$fill rellena los valores para los campos que faltan.
La salida especifica:
Los nombres de los campos a completar.
El valor para establecer en los campos completados. En este ejemplo, el
la salida especifica un valor constante de 0.

Ejemplo de salida:

[
   {
   _id: ObjectId("6202df9f394d47411658b51e"),
   date: ISODate("2022-02-02T00:00:00.000Z"),
   bootsSold: 10,
   sandalsSold: 20,
   sneakersSold: 12
   },
   {
   _id: ObjectId("6202df9f394d47411658b51f"),
   date: ISODate("2022-02-03T00:00:00.000Z"),
   bootsSold: 7,
   sneakersSold: 18,
   sandalsSold: 0
   },
   {
   _id: ObjectId("6202df9f394d47411658b520"),
   date: ISODate("2022-02-04T00:00:00.000Z"),
   sneakersSold: 5,
   bootsSold: 0,
   sandalsSold: 0
   }
]

Rellenar valores de campos faltantes con interpolación lineal

Cree una colección stock que contenga los siguientes documentos, que rastrean el precio de las acciones de una sola empresa en intervalos de una hora:

db.stock.insertMany( [
   {
      time: ISODate("2021-03-08T09:00:00.000Z"),
      price: 500
   },
   {
      time: ISODate("2021-03-08T10:00:00.000Z"),
   },
   {
      time: ISODate("2021-03-08T11:00:00.000Z"),
      price: 515
   },
   {
      time: ISODate("2021-03-08T12:00:00.000Z")
   },
   {
      time: ISODate("2021-03-08T13:00:00.000Z")
   },
   {
      time: ISODate("2021-03-08T14:00:00.000Z"),
      price: 485
   }
] )

Falta el campo price en algunos de los documentos de la colección.

Para rellenar los valores price faltantes mediante interpolación lineal, utilice $fill con el método de relleno linear:

db.stock.aggregate( [
   {
      $fill:
         {
            sortBy: { time: 1 },
            output:
               {
                  "price": { method: "linear" }
               }
         }
   }
] )

En el pipeline anterior:

$fill rellena los valores para los campos que faltan.
sortBy: { time: 1 } ordena los documentos por el campo time en orden ascendente, de más antiguo a más reciente.
La salida especifica:
price como el campo para completar los valores faltantes.
{ method: "linear" } como el método de llenado. El relleno linear
El método rellena los valores price faltantes mediante interpolación lineal basada en los valores price circundantes en la secuencia.

Ejemplo de salida:

[
   {
      _id: ObjectId("620ad41c394d47411658b5e9"),
      time: ISODate("2021-03-08T09:00:00.000Z"),
      price: 500
   },
   {
      _id: ObjectId("620ad41c394d47411658b5ea"),
      time: ISODate("2021-03-08T10:00:00.000Z"),
      price: 507.5
   },
   {
      _id: ObjectId("620ad41c394d47411658b5eb"),
      time: ISODate("2021-03-08T11:00:00.000Z"),
      price: 515
   },
   {
      _id: ObjectId("620ad41c394d47411658b5ec"),
      time: ISODate("2021-03-08T12:00:00.000Z"),
      price: 505
   },
   {
      _id: ObjectId("620ad41c394d47411658b5ed"),
      time: ISODate("2021-03-08T13:00:00.000Z"),
      price: 495
   },
   {
      _id: ObjectId("620ad41c394d47411658b5ee"),
      time: ISODate("2021-03-08T14:00:00.000Z"),
      price: 485
   }
]

Rellenar valores de campo faltantes según el último valor observado.

Cree una colección restaurantReviews que contenga los siguientes documentos, que almacenan puntuaciones de reseñas de un solo restaurante a lo largo del tiempo:

db.restaurantReviews.insertMany( [
   {
      date: ISODate("2021-03-08"),
      score: 90
   },
   {
      date: ISODate("2021-03-09"),
      score: 92
   },
   {
      date: ISODate("2021-03-10")
   },
   {
      date: ISODate("2021-03-11")
   },
   {
      date: ISODate("2021-03-12"),
      score: 85
   },
   {
      date: ISODate("2021-03-13")
   }
] )

Falta el campo score en algunos de los documentos de la colección.

Para rellenar los campos score que faltan y asegurar que no haya huecos en los datos, utilice $fill. En el siguiente ejemplo, $fill utiliza el método de relleno locf para rellenar los valores score que faltan con el score anterior en la secuencia:

db.restaurantReviews.aggregate( [
   {
      $fill:
         {
            sortBy: { date: 1 },
            output:
               {
                  "score": { method: "locf" }
               }
         }
   }
] )

En el pipeline anterior:

$fill completa los valores score que faltan.
sortBy: { date: 1 } ordena los documentos por el campo date en orden ascendente, de más antiguo a más reciente.
La salida especifica:
score como el campo para completar los valores faltantes.
{ method: "locf" } como el método de llenado. El relleno locf
el método rellena los valores perdidos de score con el último score observado en la secuencia.

Ejemplo de salida:

[
   {
   _id: ObjectId("62040bc9394d47411658b553"),
   date: ISODate("2021-03-08T00:00:00.000Z"),
   score: 90
   },
   {
   _id: ObjectId("62040bc9394d47411658b554"),
   date: ISODate("2021-03-09T00:00:00.000Z"),
   score: 92
   },
   {
   _id: ObjectId("62040bc9394d47411658b555"),
   date: ISODate("2021-03-10T00:00:00.000Z"),
   score: 92
   },
   {
   _id: ObjectId("62040bc9394d47411658b556"),
   date: ISODate("2021-03-11T00:00:00.000Z"),
   score: 92
   },
   {
   _id: ObjectId("62040bc9394d47411658b557"),
   date: ISODate("2021-03-12T00:00:00.000Z"),
   score: 85
   },
   {
   _id: ObjectId("62040bc9394d47411658b558"),
   date: ISODate("2021-03-13T00:00:00.000Z"),
   score: 85
   }
]

Rellene datos para particiones distintas

Consideremos el ejemplo anterior con reseñas de restaurantes, pero en lugar de hacer un seguimiento de un solo restaurante, la colección ahora contiene reseñas de varios restaurantes.

Cree una colección llamada restaurantReviewsMultiple y llene la colección con estos documentos:

db.restaurantReviewsMultiple.insertMany( [
   {
      date: ISODate("2021-03-08"),
      restaurant: "Joe's Pizza",
      score: 90
   },
   {
      date: ISODate("2021-03-08"),
      restaurant: "Sally's Deli",
      score: 75
   },
   {
      date: ISODate("2021-03-09"),
      restaurant: "Joe's Pizza",
      score: 92
   },
   {
      date: ISODate("2021-03-09"),
      restaurant: "Sally's Deli"
   },
   {
      date: ISODate("2021-03-10"),
      restaurant: "Joe's Pizza"
   },
   {
      date: ISODate("2021-03-10"),
      restaurant: "Sally's Deli",
      score: 68
   },
   {
      date: ISODate("2021-03-11"),
      restaurant: "Joe's Pizza",
      score: 93
   },
   {
      date: ISODate("2021-03-11"),
      restaurant: "Sally's Deli"
   }
] )

Falta el campo score en algunos de los documentos de la colección.

db.restaurantReviewsMultiple.aggregate( [
   {
      $fill:
         {
            sortBy: { date: 1 },
            partitionBy: { "restaurant": "$restaurant" },
            output:
               {
                  "score": { method: "locf" }
               }
         }
   }
] )

En el pipeline anterior:

$fill completa los valores score que faltan.
sortBy: { date: 1 } ordena los documentos por el campo date en orden ascendente, de más antiguo a más reciente.
partitionBy: { "restaurant": "$restaurant" } divide los datos por restaurant. Hay dos restaurantes: Joe's Pizza y Sally's Deli.
La salida especifica:
score como el campo para completar los valores faltantes.
{ method: "locf" } como el método de llenado. El relleno locf
el método rellena los valores perdidos de score con el último score observado en la secuencia.

Ejemplo de salida:

[
{
   _id: ObjectId("620559f4394d47411658b58f"),
   date: ISODate("2021-03-08T00:00:00.000Z"),
   restaurant: "Joe's Pizza",
   score: 90
},
{
   _id: ObjectId("620559f4394d47411658b591"),
   date: ISODate("2021-03-09T00:00:00.000Z"),
   restaurant: "Joe's Pizza",
   score: 92
},
{
   _id: ObjectId("620559f4394d47411658b593"),
   date: ISODate("2021-03-10T00:00:00.000Z"),
   restaurant: "Joe's Pizza",
   score: 92
},
{
   _id: ObjectId("620559f4394d47411658b595"),
   date: ISODate("2021-03-11T00:00:00.000Z"),
   restaurant: "Joe's Pizza",
   score: 93
},
{
   _id: ObjectId("620559f4394d47411658b590"),
   date: ISODate("2021-03-08T00:00:00.000Z"),
   restaurant: "Sally's Deli",
   score: 75
},
{
   _id: ObjectId("620559f4394d47411658b592"),
   date: ISODate("2021-03-09T00:00:00.000Z"),
   restaurant: "Sally's Deli",
   score: 75
},
{
   _id: ObjectId("620559f4394d47411658b594"),
   date: ISODate("2021-03-10T00:00:00.000Z"),
   restaurant: "Sally's Deli",
   score: 68
},
{
   _id: ObjectId("620559f4394d47411658b596"),
   date: ISODate("2021-03-11T00:00:00.000Z"),
   restaurant: "Sally's Deli",
   score: 68
}
]

Indica si un campo se rellenó utilizando `$fill`

Cuando se completan valores faltantes, la salida no indica si un valor fue completado con el operador $fill o si el valor existía originalmente en el documento. Para distinguir entre valores completados y preexistentes, puedes usar una etapa $set antes de $fill y establecer un nuevo campo en función de si el valor existe.

Por ejemplo, cree una colección restaurantReviews que contenga los siguientes documentos, que almacenan las puntuaciones de revisión de un restaurante a lo largo del tiempo:

db.restaurantReviews.insertMany( [
   {
      date: ISODate("2021-03-08"),
      score: 90
   },
   {
      date: ISODate("2021-03-09"),
      score: 92
   },
   {
      date: ISODate("2021-03-10")
   },
   {
      date: ISODate("2021-03-11")
   },
   {
      date: ISODate("2021-03-12"),
      score: 85
   },
   {
      date: ISODate("2021-03-13")
   }
] )

El campo score falta en algunos de los documentos de la colección. Puede rellenar los valores faltantes de score utilizando el operador $fill.

Crear una pipeline para realizar las siguientes acciones:

Usa $set para añadir un nuevo campo a cada documento que indique si el campo score del documento existe antes de que el operador $fill llene los valores. Este nuevo campo se llama valueExisted.
Rellenar los valores faltantes de score con el último score observado en la secuencia. El método fill locf representa "última observación cargada".

La pipeline se asemeja al siguiente código:

db.restaurantReviews.aggregate( [
   {
      $set: {
         "valueExisted": {
            "$ifNull": [
               { "$toBool": { "$toString": "$score" } },
               false
            ]
         }
      }
   },
   {
      $fill: {
         sortBy: { date: 1 },
         output:
            {
               "score": { method: "locf" }
            }
      }
   }
] )

Nota

Gestión de valores de cero

En la expresión $ifNull, los valores score se convierten en strings y luego en booleanos. La expresión $toBool siempre convierte las cadenas a true. Si los valores score no se convierten en cadenas, los valores score de 0 tendrán valueExisted configurado a false.

Salida:

[
   {
      _id: ObjectId("63595116b1fac2ee2e957f15"),
      date: ISODate("2021-03-08T00:00:00.000Z"),
      score: 90,
      valueExisted: true
   },
   {
      _id: ObjectId("63595116b1fac2ee2e957f16"),
      date: ISODate("2021-03-09T00:00:00.000Z"),
      score: 92,
      valueExisted: true
   },
   {
      _id: ObjectId("63595116b1fac2ee2e957f17"),
      date: ISODate("2021-03-10T00:00:00.000Z"),
      valueExisted: false,
      score: 92
   },
   {
      _id: ObjectId("63595116b1fac2ee2e957f18"),
      date: ISODate("2021-03-11T00:00:00.000Z"),
      valueExisted: false,
      score: 92
   },
   {
      _id: ObjectId("63595116b1fac2ee2e957f19"),
      date: ISODate("2021-03-12T00:00:00.000Z"),
      score: 85,
      valueExisted: true
   },
   {
      _id: ObjectId("63595116b1fac2ee2e957f1a"),
      date: ISODate("2021-03-13T00:00:00.000Z"),
      valueExisted: false,
      score: 85
   }
]

Interpolar los Mismos Valores en Diferentes Particiones

Cambiado en la versión 8.0.20.

A partir de MongoDB 8.0.20, $fill puede usar el método linear para interpolar si hay valores idénticos en diferentes particiones.

Cree la siguiente colección de restaurantReviewsMultiple que contiene los siguientes documentos, los cuales almacenan puntuaciones de reseñas de restaurantes en fechas idénticas:

db.restaurantReviewsMultiple.insertMany( [
   {
      date: ISODate("2021-03-08"),
      restaurant: "Steve's Pizza",
      score: 90
   },
   {
      date: ISODate("2021-03-08"),
      restaurant: "Sally's Deli",
      score: 75
   }
] )

El siguiente ejemplo de agregación usa "linear" para interpolar las fechas idénticas en las diferentes particiones:

db.restaurantReviewsMultiple.aggregate( [
   {
      $fill: {
         sortBy: { date: 1 },
         partitionBy: { "restaurant": "$restaurant" },
         output: { "score": { method: "linear" } }
      }
   }
] )

A partir de MongoDB 8.0.20, el ejemplo devuelve la siguiente salida:

[
   {
      _id: ObjectId("620559f4394d47411658b590"),
      date: ISODate("2021-03-08T00:00:00.000Z"),
      restaurant: "Sally's Deli",
      score: 75
   },
   {
      _id: ObjectId("620559f4394d47411658b58f"),
      date: ISODate("2021-03-08T00:00:00.000Z"),
      restaurant: "Steve's Pizza",
      score: 90
   }
]

Los ejemplos de Node.js en esta página utilizan la colección sample_weatherdata.data de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulte Primeros pasos en la documentación del controlador de MongoDB Node.js.

Para utilizar el controlador de MongoDB Node.js para agregar una etapa de $fill a una canalización de agregación, utilice el Operador $fill en un objeto de canalización.

El siguiente ejemplo crea una pipeline que rellena valores nulos o faltantes. El pipeline incluye las siguientes etapas:

La etapa $group agrupa los documentos de entrada según su campo ts y calcula el promedio de seaSurfaceTemperature.value para cada grupo.
La etapa $fill ordena los datos agrupados por el campo _id en orden ascendente y rellena los valores seaSurfaceTemperature nulos o faltantes mediante interpolación lineal.

const pipeline = [
  {
    $group: {
      _id: "$ts",
      seaSurfaceTemperature: { $avg: "$seaSurfaceTemperature.value" },
    }
  },
  {
    $fill: {
      sortBy: { _id: 1 },  
      output: { seaSurfaceTemperature: { method: "linear" } }
    }
  }
]; 
const cursor = collection.aggregate(pipeline);
return cursor;

Volver

$facet

$geoNear

$fill (etapa de agregación)

Definición

Sintaxis

Comportamiento y restricciones

partitionByFields Restricciones

linear Comportamiento

sortBy Restricciones

locf Comportamiento

Comparación de $fill y operadores de agregación

Ejemplos

Completar valores de campos faltantes con un valor constante

Rellenar valores de campos faltantes con interpolación lineal

Rellenar valores de campo faltantes según el último valor observado.

Rellene datos para particiones distintas

Indica si un campo se rellenó utilizando $fill

Interpolar los Mismos Valores en Diferentes Particiones

`partitionByFields` Restricciones

`linear` Comportamiento

`sortBy` Restricciones

`locf` Comportamiento

Comparación de `$fill` y operadores de agregación

Indica si un campo se rellenó utilizando `$fill`