$merge (etapa de agregación)

Vista materializada on-demand: creación inicial

Si la colección de salida no existe, $merge crea la colección.

Puedes usar las $group $merge etapas y para crear una movieRatingSummary colección que resuma las películas aclamadas por la crítica por año de lanzamiento y clasificación de contenido:

db.movies.aggregate( [
   { $match: { metacritic: 100, rated: { $ne: null },
     year: { $lte: 1972 } } },
   { $group: { _id: { year: "$year", rated: "$rated" },
     count: { $sum: 1 } } },
   { $merge : { into: "movieRatingSummary", on: "_id",
     whenMatched: "replace", whenNotMatched: "insert" } }
] )

El proceso utiliza las siguientes etapas:

• $match etapa para filtrar películas aclamadas por la crítica estrenadas a través de 1972 con una calificación de contenido

• $group etapa para agrupar las películas por year y rated

• $merge etapa para escribir la salida de la $group etapa anterior movieRatingSummary en la colección de la sample_mflix base de datos

Para ver los documentos en la nueva colección movieRatingSummary:

db.movieRatingSummary.find().sort(
   { _id: 1 } )

[
  { _id: { year: 1939, rated: 'PASSED' }, count: 1 },
  { _id: { year: 1962, rated: 'PG' }, count: 1 },
  { _id: { year: 1963, rated: 'PG' }, count: 1 },
  { _id: { year: 1970, rated: 'R' }, count: 1 },
  { _id: { year: 1972, rated: 'R' }, count: 1 }
]

Vista materializada on-demand: actualizar/reemplazar datos

Para actualizar la colección movieRatingSummary del ejemplo anterior e incluir películas aclamadas por la crítica desde 1963 en adelante, esta canalización de agregación utiliza las siguientes etapas:

• $match etapa para encontrar todas las películas metacritic: 100 con, una clasificación de contenido y un año de lanzamiento mayor o igual 1963 a.

• $group etapa para agrupar las películas por year ratedy.

• $merge para escribir el conjunto de resultados en la movieRatingSummary colección, reemplazando los documentos con el mismo _id valor. Para los documentos que no tienen coincidencias en la colección, $merge inserta los nuevos documentos.

db.movies.aggregate( [
   { $match: { metacritic: 100, rated: { $ne: null },
     year: { $gte: 1963 } } },
   { $group: { _id: { year: "$year", rated: "$rated" },
     count: { $sum: 1 } } },
   { $merge : { into: "movieRatingSummary", on: "_id",
     whenMatched: "replace", whenNotMatched: "insert" } }
] )

Una vez finalizada la agregación, vea los documentos en la colección movieRatingSummary:

db.movieRatingSummary.find().sort(
   { _id: 1 } )

[
  { _id: { year: 1939, rated: 'PASSED' }, count: 1 },
  { _id: { year: 1962, rated: 'PG' }, count: 1 },
  { _id: { year: 1963, rated: 'PG' }, count: 1 },
  { _id: { year: 1970, rated: 'R' }, count: 1 },
  { _id: { year: 1972, rated: 'R' }, count: 1 },
  { _id: { year: 1982, rated: 'R' }, count: 1 },
  { _id: { year: 2014, rated: 'R' }, count: 1 }
]

Solo insertar datos nuevos

Para garantizar que $merge no sobrescriba los datos existentes en la colección, establezca whenMatched en keepExisting o fail.

Una colección movieArchive en la base de datos sample_mflix contiene registros históricos de películas aclamadas por la crítica por año de estreno.

La colección movieArchive tiene un índice único en el campo year. Como máximo, debe existir un registro por año de lanzamiento:

db.movieArchive.createIndex(
   { year: 1 }, { unique: true } )

Este proceso de agregación actualiza la colección movieArchive con datos de la colección movies para incluir películas aclamadas por la crítica desde 1963 en adelante. El proceso utiliza las siguientes etapas:

• $match etapa para encontrar todas las películas metacritic: 100 con, una clasificación de contenido year >= 1963 y.

• $group etapa para agrupar los títulos de las películas year por.

• $project etapa para suprimir el _id campo y promover year a un campo de nivel superior. Cuando los documentos se pasan $merge a, $merge genera automáticamente un nuevo _id campo para los documentos.

• $merge escribir el conjunto de resultados en movieArchive.

  La $merge etapa compara los documentos en el year campo y falla cuando encuentra coincidencia. Es decir, si ya existe un documento para ese año de lanzamiento, se $merge produce un error en la etapa.

db.movies.aggregate( [
   { $match: { metacritic: 100, rated: { $ne: null },
     year: { $gte: 1963 } } },
   { $group: { _id: "$year",
     titles: { $push: "$title" } } },
   { $project: { _id: 0, year: "$_id", titles: 1 } },
   { $merge : { into: "movieArchive", on: "year",
     whenMatched: "fail" } }
] )

Si la movieArchive colección ya contiene un documento para cualquier año en el rango 1963–,2014 la agregación falla debido a un error de clave duplicada. Sin embargo, el proceso no revierte ningún documento que haya insertado antes del error.

Si especifica keepExisting para el documento coincidente, la agregación no afecta a dicho documento y no se produce un error de clave duplicada. Del mismo modo, si especifica replace, la operación no falla; sin embargo, reemplaza el documento existente.

Combinar resultados de múltiples colecciones

Por defecto, si un documento en los resultados de la agregación coincide con un documento en la colección, la $merge etapa fusiona los documentos.

Puedes usar $merge para combinar los resultados de la colección movies y la colección comments para crear una nueva colección yearlyStats.

Para crear la colección yearlyStats, ejecute la siguiente canalización:

db.movies.aggregate( [
   { $match: { metacritic: 100, rated: { $ne: null },
     year: { $gte: 1970, $lte: 1972 } } },
   { $group: { _id: "$year", movieCount: { $sum: 1 } } },
   { $merge : { into: "yearlyStats", on: "_id",
     whenMatched: "merge", whenNotMatched: "insert" } }
])

Primera etapa:

La $match etapa filtra las películas aclamadas por la crítica ()metacritic: 100 con una clasificación de contenido, estrenadas 1970 entre 1972 y.

Segunda fase:

La etapa agrupa $group por year y cuenta las películas en un nuevo movieCount campo.

Tercera etapa:

La $merge etapa escribe los documentos yearlyStats en la colección de la misma base de datos. Si encuentra un documento existente en la colección que coincide con el _id campo, fusiona los documentos coincidentes. De lo contrario, inserta el documento. Para la creación inicial, no se encuentran documentos coincidentes.

Para ver los documentos en la colección, ejecute la siguiente operación:

db.yearlyStats.find().sort( { _id: 1 } )

[
  { _id: 1970, movieCount: 1 },
  { _id: 1972, movieCount: 1 }
]

De manera similar, ejecute la siguiente canalización de agregación en la colección comments para fusionar los recuentos de comentarios en la colección yearlyStats.

db.comments.aggregate( [
   { $match: { date: { $gte: new Date("1970-01-01"),
     $lt: new Date("1973-01-01") } } },
   { $group: { _id: { $year: "$date" },
     commentCount: { $sum: 1 } } },
   { $merge : { into: "yearlyStats", on: "_id",
     whenMatched: "merge", whenNotMatched: "insert" } }
])

Primera etapa:

La $match etapa filtra los comentarios publicados entre 1970 y.1972

Segunda fase:

La etapa agrupa por año extraído del $group comentario date y cuenta los comentarios en un nuevo commentCount campo.

Tercera etapa:

La $merge etapa escribe los documentos yearlyStats en la colección de la misma base de datos. Si encuentra un documento existente en la colección que coincide con el _id campo (el año), fusiona los documentos coincidentes. De lo contrario, inserta el documento.

Para ver los documentos en la colección yearlyStats después de que los datos se hayan fusionado, ejecute la siguiente operación:

db.yearlyStats.find().sort( { _id: 1 } )

[
  { _id: 1970, movieCount: 1, commentCount: 889 },
  { _id: 1971, commentCount: 825 },
  { _id: 1972, movieCount: 1, commentCount: 863 }
]

Usar el pipeline para personalizar la fusión

El $merge puede usar una canalización de actualización personalizada cuando los documentos coinciden. La canalización whenMatched puede tener las siguientes etapas:

• $addFields y su alias $set

• $project y su alias $unset

• $replaceRoot y su alias $replaceWith

Una colección monthlyCommentTotals realiza un seguimiento del recuento acumulado de comentarios para cada mes.

Cada día llegan nuevos comentarios a la colección sample_mflix.comments. El siguiente proceso de agregación actualiza el total mensual con el recuento de comentarios de ese día:

db.comments.aggregate([
   { $match: { date: { $gte: new Date("1970-01-15"),
     $lt: new Date("1970-01-16") } } },
   { $group: { _id: { $dateToString: { format: "%Y-%m",
     date: "$date" } }, count: { $sum: 1 } } },
   { $merge: {
         into: "monthlyCommentTotals",
         on: "_id",
         whenMatched: [
            { $addFields: {
               count: { $add: [ "$count", "$$new.count" ] }
            } }
         ],
         whenNotMatched: "insert"
   } }
])

Primera etapa:

La etapa encuentra todos los comentarios publicados el y el de $match enero.151970

Segunda fase:

La $group etapa agrupa los comentarios coincidentes por año-mes y los cuenta.

Tercera etapa:

La $merge etapa escribe los documentos monthlyCommentTotals en la colección. Si la etapa encuentra un documento existente en la colección que coincide con el _id campo, la etapa utiliza una canalización para agregar el del día count al total mensual existente.

• Esta canalización no puede acceder directamente a los campos del documento de resultados. Para acceder al campo count en el documento de resultados, la canalización utiliza la variable $$new; es decir, $$new.count.

• Esta canalización puede acceder directamente al campo count en el documento existente en la colección; es decir, $count.

El documento resultante sustituye al documento existente.

Para ver los documentos en la colección monthlyCommentTotals después de la operación de fusión, ejecute la siguiente operación:

db.monthlyCommentTotals.find()

[ { _id: '1970-01', count: 71 } ]

Usa variables para personalizar la fusión

Puedes usar variables en el $merge campo whenMatched de la etapa. Las variables deben definirse antes de poder usarse.

Defina variables en uno o en ambos de los siguientes:

• $merge escenario dejar

• El comandoaggregate let (a partir de MongoDB 5.0)

Para usar variables en whenMatched:

Se debe especificar el prefijo del signo de dólar doble ($$) junto con el nombre de la variable en el formato $$<variable_name>. Por ejemplo, $$year. Si la variable está configurada como un documento, también se puede incluir un campo de documento en el formulario $$<variable_name>.<field>. Por ejemplo, $$year.month.

Las pestañas a continuación demuestran el comportamiento cuando las variables se definen en la etapa de fusión, el comando de agregación, o en ambos.

db.movies.aggregate( [
   { $match: { title: "The Godfather" } },
   { $limit: 1 },
   { $project: { title: 1 } },
   { $merge: { into: "movieDetails", whenNotMatched: "insert" } }
] )
db.runCommand( {
   aggregate: db.movieDetails.getName(),
   pipeline: [ {
      $merge: {
         into: db.movieDetails.getName(),
         let : { year: "2023" },
         whenMatched: [ {
            $addFields: { "addedYear": "$$year" }
         } ]
      }
   } ],
   cursor: {}
} )
db.movieDetails.find()

[ { _id: ..., title: 'The Godfather', addedYear: '2023' } ]

db.movies.aggregate( [
   { $match: { title: "The Godfather" } },
   { $limit: 1 },
   { $project: { title: 1 } },
   { $merge: { into: "movieDetails", whenNotMatched: "insert" } }
] )
db.runCommand( {
   aggregate: db.movieDetails.getName(),
   pipeline: [ {
      $merge: {
         into: db.movieDetails.getName(),
         whenMatched: [ {
            $addFields: { "addedYear": "$$year" }
         } ]
      }
   } ],
   cursor: {},
   let : { year: "2023" }
} )
db.movieDetails.find()

[ { _id: ..., title: 'The Godfather', addedYear: '2023' } ]

db.movies.aggregate( [
   { $match: { title: "The Godfather" } },
   { $limit: 1 },
   { $project: { title: 1 } },
   { $merge: { into: "movieDetails", whenNotMatched: "insert" } }
] )
db.runCommand( {
   aggregate: db.movieDetails.getName(),
   pipeline: [ {
      $merge: {
         into: db.movieDetails.getName(),
         let : { year: "2023" },
         whenMatched: [ {
            $addFields: { "addedYear": "$$year" }
         } ]
      }
   } ],
   cursor: {},
   let : { year: "2019" }
} )
db.movieDetails.find()

[ { _id: ..., title: 'The Godfather', addedYear: '2023' } ]