Join us at MongoDB.local London on 7 May to unlock new possibilities for your data. Use WEB50 to save 50%.
Register now >
Docs Menu
Docs Home
/ /
Etapas de la pipeline de agregación
Docs Home
/ /
Operadores
/
Etapas de la pipeline de agregación
Docs Home
/
Manual de base de datos
/
Referencia
/
Operadores
/
Etapas de la pipeline de agregación

$addFields (etapa de agregación)

Definición

$addFields

Agrega nuevos campos a los documentos. $addFields produce documentos que contienen todos los campos existentes de los documentos de entrada y los campos recién añadidos.

La etapa $addFields es equivalente a un $project etapa que especifica explícitamente todos los campos existentes en los documentos de entrada y añade los nuevos campos.

Nota

También puedes usar la etapa $set, que es un alias de $addFields.

Compatibilidad

Puedes usar $addFields para implementaciones alojadas en los siguientes entornos:

  • MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

  • MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB

  • MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

$addFields tiene la siguiente forma:

{ $addFields: { <newField>: <expression>, ... } }

Especifica el nombre de cada campo a agregar y establece su valor en una expresión de agregación. Para obtener más información sobre expresiones, consulta Expresiones.

Importante

Si el nombre del nuevo campo es el mismo que el de un campo existente (incluido _id), $addFields sobrescribirá el valor existente de ese campo con el valor de la expresión especificada.

Comportamiento

$addFields agrega nuevos campos a documentos existentes. Puedes incluir una o más etapas $addFields en una operación de agregación.

Para añadir uno o varios campos a los documentos incrustados (incluidos los documentos en arrays), utiliza la notación de puntos. See ejemplo.

Para agregar un elemento a un campo de arreglo existente con $addFields, úsalo con $concatArrays. Consulta el ejemplo.

Ejemplos

Uso de dos etapas de $addFields

Una colección llamada scores contiene los siguientes documentos:

db.scores.insertMany( [
   {
      _id: 1,
      student: "Maya",
      homework: [ 10, 5, 10 ],
      quiz: [ 10, 8 ],
      extraCredit: 0
   },
   {
      _id: 2,
      student: "Ryan",
      homework: [ 5, 6, 5 ],
      quiz: [ 8, 8 ],
      extraCredit: 8
   }
] )

La siguiente operación utiliza dos $addFields etapas para incluir tres nuevos campos en los documentos de salida:

db.scores.aggregate( [
   {
   $addFields: {
      totalHomework: { $sum: "$homework" } ,
      totalQuiz: { $sum: "$quiz" }
   }
   },
   {
   $addFields: { totalScore:
      { $add: [ "$totalHomework", "$totalQuiz", "$extraCredit" ] } }
   }
] )

La operación devuelve los siguientes documentos:

[
   {
      _id: 1,
      student: "Maya",
      homework: [ 10, 5, 10 ],
      quiz: [ 10, 8 ],
      extraCredit: 0,
      totalHomework: 25,
      totalQuiz: 18,
      totalScore: 43
   },
   {
      _id: 2,
      student: "Ryan",
      homework: [ 5, 6, 5 ],
      quiz: [ 8, 8 ],
      extraCredit: 8,
      totalHomework: 16,
      totalQuiz: 16,
      totalScore: 40
   }
]

Agregar campos a un documento incrustado

Utilice la notación de puntos para agregar nuevos campos a los documentos incrustados.

Por ejemplo, cree una colección llamada vehicles con los siguientes documentos:

db.vehicles.insertMany( [
      { _id: 1, type: "car", specs: { doors: 4, wheels: 4 } },
      { _id: 2, type: "motorcycle", specs: { doors: 0, wheels: 2 } },
      { _id: 3, type: "jet ski" }
] )

La siguiente operación de agregación agrega un nuevo campo fuel_type al documento incrustado specs.

db.vehicles.aggregate( [
   { $addFields: { "specs.fuel_type": "unleaded" } }
] )

La operación devuelve los siguientes resultados:

[
   { _id: 1, type: "car",
      specs: { doors: 4, wheels: 4, fuel_type: "unleaded" } },
   { _id: 2, type: "motorcycle",
      specs: { doors: 0, wheels: 2, fuel_type: "unleaded" } },
   { _id: 3, type: "jet ski",
      specs: { fuel_type: "unleaded" } }
]

Sobrescribir un campo existente

Al especificar un nombre de campo existente en una operación de $addFields, se reemplaza el campo original.

Una colección llamada animals contiene el siguiente documento:

db.animals.insertOne(
   { _id: 1, dogs: 10, cats: 15 }
)

La siguiente operación $addFields especifica el campo cats.

db.animals.aggregate( [
{
   $addFields: { cats: 20 }
}
] )

La operación devuelve el siguiente documento:

[ { _id: 1, dogs: 10, cats: 20 } ]

Es posible reemplazar un campo por otro. En el siguiente ejemplo, el campo item sustituye al campo _id.

Una colección llamada fruit contiene los siguientes documentos:

db.fruit.insertMany( [
   { _id: 1, item: "tangerine", type: "citrus" },
   { _id: 2, item: "lemon", type: "citrus" },
   { _id: 3, item: "grapefruit", type: "citrus" }
] )

La siguiente operación de agregación utiliza $addFields para reemplazar el campo _id de cada documento con el valor del campo item y reemplaza el campo item con un valor estático.

db.fruit.aggregate( [
{
   $addFields: {
      _id : "$item",
      item: "fruit"
   }
}
] )

La operación devuelve lo siguiente:

[
   { _id: "tangerine", item: "fruit", type: "citrus" },
   { _id: "lemon", item: "fruit", type: "citrus" },
   { _id: "grapefruit", item: "fruit", type: "citrus" }
]

Agrega el elemento a un arreglo

Cree una colección de muestra scores con lo siguiente:

db.scores.insertMany( [
   { _id: 1, student: "Maya", homework: [ 10, 5, 10 ], quiz: [ 10, 8 ], extraCredit: 0 },
   { _id: 2, student: "Ryan", homework: [ 5, 6, 5 ], quiz: [ 8, 8 ], extraCredit: 8 }
] )

Puedes usar $addFields con una expresión $concatArrays para agregar un elemento a un campo de arreglo existente. Por ejemplo, la siguiente operación usa $addFields para reemplazar el campo homework con un nuevo arreglo cuyos elementos son el arreglo actual homework concatenado con otro arreglo que contiene una nueva puntuación [ 7 ].

db.scores.aggregate( [
   { $match: { _id: 1 } },
   { $addFields: { homework: { $concatArrays: [ "$homework", [ 7 ] ] } } }
] )

La operación devuelve lo siguiente:

[ { _id: 1, student: "Maya", homework: [ 10, 5, 10, 7 ], quiz: [ 10, 8 ], extraCredit: 0 } ]

Remover campos

Puedes usar $addFields con la variable $$REMOVE para remover campos del documento.

Por ejemplo, cree una colección labReadings:

db.labReadings.insertMany( [
   {
      date: ISODate("2024-10-09"),
      temperature: 80
   },
   {
      date: null,
      temperature: 83
   },
   {
      date: ISODate("2024-12-09"),
      temperature: 85
   }
] )

Para remover el campo date de los documentos labReadings, utiliza $addFields con la variable $$REMOVE:

db.labReadings.aggregate( [
   {
      $addFields: { date: "$$REMOVE" }
   }
] )

Salida:

[
   { _id: ObjectId('671285306fd2c3b24f2e7eaa'), temperature: 80 },
   { _id: ObjectId('671285306fd2c3b24f2e7eab'), temperature: 83 },
   { _id: ObjectId('671285306fd2c3b24f2e7eac'), temperature: 85 }
]

También puede utilizar $$REMOVE para remover campos condicionalmente. Por ejemplo, la siguiente agregación remueve el campo date de los documentos donde date es null:

db.labReadings.aggregate( [
   {
      $addFields:
         {
            date: {
               $ifNull: [ "$date", "$$REMOVE" ]
            }
         }
   }
] )

Salida:

[
   {
      _id: ObjectId('671285306fd2c3b24f2e7eaa'),
      date: ISODate('2024-10-09T00:00:00.000Z'),
      temperature: 80
   },
   { _id: ObjectId('671285306fd2c3b24f2e7eab'), temperature: 83 },
   {
      _id: ObjectId('671285306fd2c3b24f2e7eac'),
      date: ISODate('2024-12-09T00:00:00.000Z'),
      temperature: 85
   }
]

Los ejemplos de Node.js en esta página utilizan la base de datos sample_mflix 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 $addFields a una canalización de agregación, utilice el Operador $addFields en un objeto de canalización.

El siguiente ejemplo crea una etapa de pipeline que agrega un campo totalReviews a cada documento de película, que contiene el número total de revisiones de la película. A continuación, el ejemplo ejecuta el pipeline de agregación:

const pipeline = [
  {
    $addFields: {
      totalReviews: {
        $add: ["$imdb.votes", "$tomatoes.viewer.numReviews"]
      }
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Tip

Comparación con $project

Puedes usar la plataforma $addFields o $project para remover campos de documentos. El mejor enfoque depende de su pipeline y de cuánto del documento original desea conservar.

Para un ejemplo usando $$REMOVE en una etapa de $project, vea Excluir campos condicionalmente.

Obtén más información

Para obtener más información sobre las etapas relacionadas del pipeline, consulte las guías $project y $set.

Volver

Etapas de la pipeline de agregación

Next

$bucket

En esta página