Docs Menu
Docs Home
/ /
Update
Docs Home
/
Desarrollo
/
Operaciones CRUD
/
Update
Docs Home
/
Desarrollo
/
Operaciones CRUD
/
Update

Actualizaciones con el pipeline de agregación

Utilice pipelines de agregación para realizar operaciones de actualización. Puede crear y ejecutar estos pipelines en:

  • MongoDB Atlas

  • MongoDB Compass

  • MongoDB Shell

  • Controladores

Las canalizaciones de agregación para actualizaciones admiten estas etapas:

Las canalizaciones de agregación permiten actualizaciones expresivas, como:

  • Actualizaciones condicionales basadas en valores de campo actuales

  • Establecer valores de campo desde otros campos

Nota

Caracteres de dólar en los valores de campo

Cuando utilizas un pipeline de agregación, sanea cualquier cadena que se pase desde la entrada del usuario o se cree dinámicamente a partir del análisis de datos. Si algún valor de campo es un valor literal de string y comienza con un carácter de dólar, el valor debe ser pasado al operador de agregación $literal. El siguiente ejemplo demuestra cómo usar la canalización de agregación $set y el operador $literal para actualizar el documento con un _id de 1 para que tenga un campo cost de $27.

db.inventory.updateOne( { _id: 1 }, [ { $set: { "cost": { $literal: "$27" } } } ] )

Crea una canalización de agregación para actualizar en Atlas

Puedes crear pipelines de agregación para realizar actualizaciones en la interfaz de usuario de MongoDB Atlas. Requiere el rol o Project Data Access Read Only superior.

1

Abra el generador de canalizaciones de agregación

  1. Selecciona la base de datos para la colección.

    El panel principal y Namespaces En el lado izquierdo se enumeran las colecciones de la base de datos.

  2. Seleccione la colección.

    Selecciona la colección en el lado izquierdo o en el panel principal. El panel principal muestra las vistas Find, Indexes y Aggregation.

  3. Selecciona la vista de agregación.

    Cuando abres por primera vez la vista Aggregation, Atlas muestra una canalización de agregación vacía.

2

Crea una canalización de agregación para realizar actualizaciones.

  1. Selecciona una etapa de agregación.

    Selecciona una etapa de agregación del menú desplegable Select en el panel inferior izquierdo.

    El interruptor a la derecha del menú desplegable determina si la etapa está habilitada.

    Para realizar actualizaciones con una agregación, utiliza una de estas fases:

  2. Configurar el escenario

    Completa tu etapa con los valores adecuados. Si el Modo de comentario está habilitado, el generador de pipeline proporciona pautas sintácticas para la etapa seleccionada.

    A medida que se modifica la etapa, Atlas actualiza los documentos de vista previa a la derecha en función de los resultados de la etapa actual.

    Para ejemplos de lo que podría incluir en su etapa de agregación, consulta los ejemplos en esta página.

    Añade etapas según sea necesario. Para obtener más información sobre la creación de canalizaciones de agregación en Atlas, consulta Crear una canalización de agregación.

3

Exporta la canalización de agregación.

  1. Haz clic en Exportar a lenguaje.

    Puedes encontrar este botón en la parte superior del desarrollador de pipeline.

  2. Selecciona el lenguaje de exportación que prefieras.

    En el menú Export Pipeline To, selecciona el idioma deseado.

    El panel My Pipeline a la izquierda muestra el pipeline en la sintaxis de MongoDB Shell. Puedes copiar esto directamente para ejecutar el pipeline en el MongoDB Shell.

    El panel de la derecha muestra tu pipeline en el lenguaje seleccionado. Selecciona tu lenguaje preferido.

  3. Selecciona las opciones, si lo deseas.

    (Opcional): Selecciona la opción Include Import Statements para incluir las instrucciones de importación necesarias para el lenguaje seleccionado.

    (Opcional): Marca la opción Include Driver Syntax para incluir el código específico del controlador para:

    • Inicializa el cliente

    • Especifica la base de datos y la colección

    • Realiza la operación de agregación

  4. Copia el pipeline.

    Haz clic en el botón Copy en la parte superior derecha del pipeline para copiar el pipeline del lenguaje seleccionado en tu portapapeles. Pega el pipeline copiado en tu aplicación.

Ejemplos

Los siguientes ejemplos demuestran cómo utilizar las etapas de la canalización de agregación $set, $replaceRoot y $addFields para realizar actualizaciones.

updateOne con $set

Crear la colección students:

db.students.insertMany( [
   { _id: 1, test1: 95, test2: 92, test3: 90, modified: new Date("01/05/2020") },
   { _id: 2, test1: 98, test2: 100, test3: 102, modified: new Date("01/05/2020") },
   { _id: 3, test1: 95, test2: 110, modified: new Date("01/04/2020") }
] )

Para verificar, consulta la colección:

db.students.find()

La siguiente operación de db.collection.updateOne() utiliza una canalización de agregación para actualizar el documento con _id: 3:

db.students.updateOne( { _id: 3 }, [ { $set: { "test3": 98, modified: "$$NOW"} } ] )

La canalización consta de una etapa que añade $set el test3 campo (y establece su valor 98 en) al documento y establece el modified campo con la fecha y hora actuales. La operación utiliza la variable de agregación NOW para la fecha y hora actuales. Para acceder a la variable, se debe añadir el prefijo y $$ encerrarla entre comillas.

Para verificar, consulta la colección:

db.students.find().pretty()

updateMany con $replaceRoot y $set

Crear la colección students2:

db.students2.insertMany( [
   { "_id" : 1, quiz1: 8, test2: 100, quiz2: 9, modified: new Date("01/05/2020") },
   { "_id" : 2, quiz2: 5, test1: 80, test2: 89, modified: new Date("01/05/2020") },
] )

Para verificar, consulta la colección:

db.students2.find()

La siguiente db.collection.updateMany() operación utiliza un pipeline de agregación para estandarizar los campos de los documentos (es decir, los documentos de la colección deben tener los mismos campos) y actualiza el campo modified:

db.students2.updateMany( {},
  [
    { $replaceRoot: { newRoot:
       { $mergeObjects: [ { quiz1: 0, quiz2: 0, test1: 0, test2: 0 }, "$$ROOT" ] }
    } },
    { $set: { modified: "$$NOW"}  }
  ]
)

Esta tubería consta de:

  • una $replaceRoot etapa con una $mergeObjects expresión para establecer valores por defecto para los campos quiz1, quiz2, test1 y test2. La variable de agregación ROOT se refiere al documento actual que está siendo modificado. Para acceder a la variable, coloca el prefijo $$ y enciérralo entre comillas. Los campos actuales del documento sobrescribirán los valores por defecto.

  • una etapa $set para actualizar el campo modified a la fecha y hora actuales. La operación utiliza la variable de agregación NOW para la fecha y hora actuales. Para acceder a la variable, coloca el prefijo $$ y enciérralo entre comillas.

Para verificar, consulta la colección:

db.students2.find()

updateMany con $set

Crear la colección students3:

db.students3.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "tests" : [ 94, 88, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 3, "tests" : [ 70, 75, 82 ], "modified" : ISODate("2019-01-01T00:00:00Z") }
] );

Para verificar, consulta la colección:

db.students3.find()

La siguiente operación db.collection.updateMany() utiliza una canalización de agregación para actualizar los documentos con el promedio de calificaciones calculado y la calificación en letra.

db.students3.updateMany(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] }, modified: "$$NOW" } },
     { $set: { grade: { $switch: {
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ]
)

Esta tubería consta de:

  • una $set etapa para calcular el valor promedio truncado de los elementos del arreglo tests y para actualizar el campo modified a la fecha y hora actual. Para calcular el promedio truncado, la etapa utiliza las expresiones $avg y $trunc. La operación utiliza la variable de agregación NOW para la fecha y hora actuales. Para acceder a la variable, coloca el prefijo $$ y enciérralo entre comillas.

  • una $set etapa para agregar el campo grade basado en el average usando la expresión $switch.

Para verificar, consulta la colección:

db.students3.find()

updateOne con $set

Crear la colección students4:

db.students4.insertMany( [
  { "_id" : 1, "quizzes" : [ 4, 6, 7 ] },
  { "_id" : 2, "quizzes" : [ 5 ] },
  { "_id" : 3, "quizzes" : [ 10, 10, 10 ] }
] )

Para verificar, consulta la colección:

db.students4.find()

La siguiente operación db.collection.updateOne() utiliza una canalización de agregación para añadir puntuaciones de cuestionarios al documento con _id: 2:

db.students4.updateOne( { _id: 2 },
  [ { $set: { quizzes: { $concatArrays: [ "$quizzes", [ 8, 6 ]  ] } } } ]
)

Para verificar, consulta la colección:

db.students4.find()

updateMany con $addFields

Crea la colección temperatures usando temperaturas en Celsius:

db.temperatures.insertMany( [
  { "_id" : 1, "date" : ISODate("2019-06-23"), "tempsC" : [ 4, 12, 17 ] },
  { "_id" : 2, "date" : ISODate("2019-07-07"), "tempsC" : [ 14, 24, 11 ] },
  { "_id" : 3, "date" : ISODate("2019-10-30"), "tempsC" : [ 18, 6, 8 ] }
] )

Para verificar, consulta la colección:

db.temperatures.find()

La siguiente db.collection.updateMany() operación utiliza una canalización de agregación para actualizar los documentos con las temperaturas correspondientes en Fahrenheit:

db.temperatures.updateMany( { },
  [
    { $addFields: { "tempsF": {
          $map: {
             input: "$tempsC",
             as: "celsius",
             in: { $add: [ { $multiply: ["$$celsius", 9/5 ] }, 32 ] }
          }
    } } }
  ]
)

La canalización consta de una $addFields etapa para agregar un nuevo campo de matriz tempsF que contiene las temperaturas en grados Fahrenheit. Para convertir cada temperatura en grados Celsius de la tempsC matriz a grados Fahrenheit, la etapa utiliza la $map expresión con las $add $multiply expresiones y.

Para verificar, consulta la colección:

db.temperatures.find()

Actualiza con variables let

Nuevo en la versión 5.0.

Para definir variables a las que puedas acceder en otras partes del comando, utiliza la opción let.

Nota

Para filtrar los resultados usando una variable, debes acceder a la variable dentro del operador $expr.

Cree una colección cakeFlavors:

db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

El siguiente comando updateOne utiliza variables configuradas con la opción let:

  • La variable targetFlavor está configurada en cherry. Esta variable se utiliza en la expresión $eq para especificar el filtro de coincidencia.

  • La variable newFlavor está configurada en orange. Esta variable se utiliza en el operador $set para especificar el valor flavor actualizado del documento coincidente.

db.cakeFlavors.updateOne(
   {
      $expr: { $eq: [ "$flavor", "$$targetFlavor" ] }
   },
   [
      {
         $set: { flavor: "$$newFlavor" }
      }
   ],
   {
      let: { targetFlavor: "cherry", newFlavor: "orange" }
   }
)

Después de ejecutar la operación de actualización anterior, la colección cakeFlavors contiene los siguientes documentos:

[
   { _id: 1, flavor: 'chocolate' },
   { _id: 2, flavor: 'strawberry' },
   { _id: 3, flavor: 'orange' }
]

Ejemplos adicionales

Consulte las siguientes páginas para ver más ejemplos:

Volver

Update

Next

Métodos

En esta página