/ /

$fill (etapa de agregación)

Definición

$fill

Novedades en la versión 5.3.

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

Puede usar $fill Para rellenar 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 omites partitionBy y partitionByFields, `$fill` usa una partición para toda la colección. partitionBy y partitionByFields son mutuamente excluyentes. Ve un ejemplo.
partitionByFields	Opcional	Especifica un arreglo de campos como clave compuesta para agrupar los documentos. En la `$fill` etapa, cada grupo de documentos se conoce como una partición. Si omites partitionBy y partitionByFields, `$fill` usa una partición para toda la colección. partitionBy y partitionByFields son mutuamente excluyentes. Ver `partitionByFields` Restricciones.
sortBy	Obligatorio si el método se especifica en al menos una 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 que se deben rellenar los valores faltantes. Se pueden 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 mediante interpolación lineal en función de los valores no`null` circundantes en la secuencia. `locf` método de relleno, los valores se completan según el último valor no nulo del campo en la partición. `locf` representa la última observación trasladada. Para obtener más información, consulta: Detalles del comportamiento lineal Ejemplo de relleno lineal Detalles del comportamiento de locf Ejemplo de relleno locf

Comportamiento y restricciones

`partitionByFields` Restricciones

$fill devuelve un error si cualquier nombre de campo en el arreglo partitionByFields:

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

`linear` Comportamiento

El método fill linear llena null y los campos faltantes usando interpolación lineal basándose en los valores circundantes nonull en la secuencia.

Para cada documento donde el campo es null o falta, linearFill llena esos campos en proporción al rango de valores faltantes entre los valores circundantes que no sonnull de acuerdo con el orden de sortBy. Para determinar los valores de los campos que faltan, linearFill usa:
- 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 utilizar el método de relleno linear para completar los valores null, los documentos se convierten en:
{ 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 distintos denull siguen siendo null.
Para utilizar el método de completado linear, también debes utilizar el campo sortBy para ordenar tus datos.
- Al usar el método de llenado linear, $fill devuelve un error si hay valores repetidos en el campo sortBy en una sola partición.

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

`locf` Comportamiento

locf corresponde a la última observación trasladada.

Si un campo que se está llenando contiene tanto null como valores no nulos, locf establece los valores null y los valores faltantes en el último valor no nulo conocido del campo según el orden sortBy.
- 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 completado locf, también debes utilizar el campo sortBy para ordenar tus datos.

Para un ejemplo completo utilizando el método de llenado locf, consulte Completa los Valores Faltantes de campos Basados en el Último Valor Observado.

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

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

La etapa de $fill.
Cuando utiliza la etapa, el campo que especifica en la salida es el mismo campo utilizado como datos de $fill origen.
Los operadores de agregación $linearFill y $locf.
Cuando usa o, puede establecer valores para un campo diferente del campo utilizado como datos de $linearFill $locforigen.

Ejemplos

Los ejemplos de esta sección muestran cómo utilizar para completar valores $fill 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 zapatería mantiene una colección dailySales que contiene un documento que resume las ventas diarias. La zapatería 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 en 0 para los tipos de calzado faltantes en 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 Completa los valores de los campos faltantes.
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 para algunos de los documentos de la colección.

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

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

En el pipeline anterior:

$fill Completa los valores de los campos faltantes.
sortBy: { time: 1 } ordena los documentos por el campo time en orden ascendente, del más antiguo al más reciente.
La salida especifica:
price como el campo para completar los valores faltantes.
{ method: "linear" } como método de relleno. El relleno linear
el método completa los valores de price que faltan utilizando interpolación lineal según los valores circundantes de price 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 para algunos de los documentos de la colección.

Para completar los campos score faltantes y garantizar que no haya vacíos en los datos, utiliza $fill. En el siguiente ejemplo, $fill utiliza el método de llenado locf para completar los valores faltantes de score 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 de score que faltan.
sortBy: { date: 1 } ordena los documentos por el campo date en orden ascendente, del más antiguo al más reciente.
La salida especifica:
score como el campo para completar los valores faltantes.
{ method: "locf" } como método de relleno. 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

Considera el ejemplo anterior con revisiones de restaurantes, pero en lugar de hacer el seguimiento de un solo restaurante, la colección ahora contiene revisiones de múltiples 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 para 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 de score que faltan.
sortBy: { date: 1 } ordena los documentos por el campo date en orden ascendente, del más antiguo al 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 método de relleno. 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:

Utilice para añadir un nuevo campo a cada documento que indique si el campo del $set documento score existía antes de que el $fill operador rellenara los valores. Este nuevo campo se valueExisted llama.
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 score valores se convierten en cadenas y luego en booleanos. La expresión siempre convierte $toBool las cadenas true en. Si los score valores no se convierten en cadenas, score los valores de 0 tendrán valueExisted establecido false en.

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 valores idénticos en diferentes particiones

Cambiado en la versión 8.0.

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

Cree la siguiente colección restaurantReviewsMultiple que contenga los siguientes documentos, que 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 utiliza "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.1, 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, se puede consultar Primeros pasos en la documentación del driver 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 con valores nulos o faltantes de seaSurfaceTemperature al usar la 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

Definición

Sintaxis

Comportamiento y restricciones

partitionByFields Restricciones

linear Comportamiento

Ejemplo

locf Comportamiento

Comparación de operadores de $fill y 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

Nota

Gestión de valores de cero

Interpolar valores idénticos en diferentes particiones

`partitionByFields` Restricciones

`linear` Comportamiento

`locf` Comportamiento

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

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