Vistas

Solo lectura

Las vistas son de solo lectura; las operaciones de guardar en vistas darán error.

Las siguientes operaciones de lectura pueden soportar vistas:

• db.collection.find()

• db.collection.findOne()

• db.collection.aggregate()

• db.collection.countDocuments()

• db.collection.estimatedDocumentCount()

• db.collection.count()

• db.collection.distinct()

Uso del índice y operaciones de clasificación

• Las vistas usan los índices de la colección subyacente.

• Dado que los índices están en la colección subyacente, no se pueden crear, descartar o reconstruir índices en la vista directamente ni obtener una lista de índices en la vista.

• A partir de MongoDB 4.4, puedes especificar un ordenamiento $natural al ejecutar un comando find en una vista. Las versiones anteriores de MongoDB no admiten el ordenamiento $natural en vistas.

• La pipeline de agregación subyacente de la vista está sujeta al límite de memoria de 100 megabytes para las operaciones de ordenamiento bloqueante y grupo por bloqueo. A partir de MongoDB 4.4, puede emitir un comando find con allowDiskUse: true sobre la vista para permitir que MongoDB utilice archivos temporales para las operaciones de ordenamiento y agrupación bloqueantes.

  Antes de MongoDB 4.4, sólo el comando aggregate aceptaba la opción allowDiskUse.

  Tip

  Para más información sobre los límites de memoria para la operación de ordenamiento bloqueante, consulta Operaciones de ordenamiento.

Restricciones de proyecciones

find() Las operaciones en vistas no admiten los siguientes operadores de proyección:

• $

• $elemMatch

• $slice

• $meta

Nombre inmutable

No puede cambiar el nombre de vistas.

Vista de creación

• Las vistas se calculan a demanda durante las operaciones de lectura y MongoDB ejecuta operaciones de lectura en ellas como parte del pipeline de agregación subyacente. Como tal, las vistas no soportan operaciones tales como:

  • db.collection.mapReduce(),

  • $text operador, ya que la operación $text en la agregación solo es válida para la primera etapa,

  • $geoNear etapa del pipeline.

• Si el pipeline de agregación utilizado para crear la vista suprime el campo _id, los documentos en la vista no tienen el campo _id.

Cuando consultas una vista, el:

• Los query filter, projection, sort, skip, limit y otras operaciones para db.collection.find() se convierten en etapas de pipeline de agregación equivalentes.

• Las etapas del pipeline de agregación convertidas se agregan al final del pipeline de agregación para la vista. Esto no modifica el pipeline subyacente de la vista, que se define cuando se crea la vista.

• El optimizador del pipeline de agregación reorganiza las etapas del pipeline de agregación de la vista para mejorar el rendimiento. Esto no cambia los resultados de la consulta.

Vista en particionado

Las vistas se consideran particionadas si su colección subyacente está particionada. Por lo tanto, no puedes especificar una vista fragmentada para el campo from en las operaciones $lookup y $graphLookup.

Vistas e intercalación

• Puede especificar una intercalación por defecto para una vista en el momento que la crea. Si no se especifica ninguna intercalación, la intercalación por defecto de la vista es la intercalación de comparación binaria "simple". Es decir, la vista no hereda la intercalación por defecto de la colección.

• Las comparaciones de string en la vista utilizan la intercalación por defecto de la vista. Una operación que intente cambiar o sobrescribir la intercalación por defecto de una vista fallará con un error.

• Si crea una vista a partir de otra vista, no puede especificar una intercalación que difiera de la intercalación de la vista de origen.

• Si realiza una agregación que implique varias vistas, como con $lookup o $graphLookup, las vistas deben tener la misma intercalación.

Aislamiento de snapshot

Las vistas no mantienen marcas de tiempo de los cambios en la colección ni admiten el aislamiento de lectura en un punto específico o aislamiento de lectura de instantáneas.

Definición de vista pública

Las operaciones que enumeran colecciones, como db.getCollectionInfos() y db.getCollectionNames(), incluyen vistas en sus salidas.

Utilice db.createView() para crear una vista

Utilice db.createView() para crear una vista que esté limitada a estudiantes de primer año:

db.createView(
   "firstYears",
   "students",
   [ { $match: { year: 1 } } ]
)

En el ejemplo:

• firstYears es el nombre de la nueva vista.

• students es la colección en la que se basa la vista.

• $match es una expresión de agregación que coincide con los estudiantes de primer año en la colección students.

Este ejemplo consulta la vista:

db.firstYears.find({}, { _id: 0 } )

El siguiente resultado solo contiene los documentos con datos sobre estudiantes de primer año. La proyección { _id: 0 } suprime el campo _id en la salida.

[
  { sID: 22001, name: 'Alex', year: 1, score: 4 },
  { sID: 22021, name: 'Drew', year: 1, score: 3.2 },
  { sID: 21022, name: 'Farmer', year: 1, score: 2.2 }
]

Utilice db.createCollection() para crear una vista

El método db.createCollection() le permite crear una colección o una vista con opciones específicas.

El siguiente ejemplo crea una vista graduateStudents. La vista solo contiene documentos seleccionados por la etapa $match. La configuración opcional de intercalación determina el orden en la clasificación.

db.createCollection(
   "graduateStudents",
   {
      viewOn: "students",
      pipeline: [ { $match: { $expr: { $gt: [ "$year", 4 ] } } } ],
      collation: { locale: "en", caseFirst: "upper" }
   }
)

El siguiente ejemplo consulta la vista. La etapa $unset elimina el campo _id de la salida para mayor claridad.

db.graduateStudents.aggregate(
   [
      { $sort: { name: 1 } },
      { $unset: [ "_id" ] }
   ]
)

Cuando se ordena la salida, la etapa $sort utiliza el orden de intercalación para clasificar las letras mayúsculas antes que las minúsculas.

[
  { sID: 18020, name: 'Harley', year: 5, score: 2.8 },
  { sID: 17301, name: 'harley', year: 6, score: 3.1 }
]

Utiliza una vista para unir dos colecciones

A menudo es conveniente usar $lookup para crear una vista sobre dos colecciones y luego ejecutar consultas contra la vista. Las aplicaciones pueden query la vista sin tener que construir ni mantener pipelines complejas.

Crea dos colecciones de muestra, inventory y orders:

db.inventory.insertMany( [
   { prodId: 100, price: 20, quantity: 125 },
   { prodId: 101, price: 10, quantity: 234 },
   { prodId: 102, price: 15, quantity: 432 },
   { prodId: 103, price: 17, quantity: 320 }
] )
db.orders.insertMany( [
   { orderID: 201, custid: 301, prodId: 100, numPurchased: 20 },
   { orderID: 202, custid: 302, prodId: 101, numPurchased: 10 },
   { orderID: 203, custid: 303, prodId: 102, numPurchased: 5 },
   { orderID: 204, custid: 303, prodId: 103, numPurchased: 15 },
   { orderID: 205, custid: 303, prodId: 103, numPurchased: 20 },
   { orderID: 206, custid: 302, prodId: 102, numPurchased: 1 },
   { orderID: 207, custid: 302, prodId: 101, numPurchased: 5 },
   { orderID: 208, custid: 301, prodId: 100, numPurchased: 10 },
   { orderID: 209, custid: 303, prodId: 103, numPurchased: 30 }
] )

Cree una vista que combine elementos de cada colección:

db.createView( "sales", "orders", [
   {
      $lookup:
         {
            from: "inventory",
            localField: "prodId",
            foreignField: "prodId",
            as: "inventoryDocs"
         }
   },
   {
      $project:
         {
           _id: 0,
           prodId: 1,
           orderId: 1,
           numPurchased: 1,
           price: "$inventoryDocs.price"
         }
   },
      { $unwind: "$price" }
] )

En el ejemplo:

• db.createView() crea la vista sales.

• La vista sales se basa en la colección orders.

• La etapa $lookup utiliza el campo prodId en la colección orders para "unir" documentos en la colección inventory que tienen campos prodId que coinciden.

• Los documentos que coinciden se agregan como un arreglo en el campo inventoryDocs.

• La $project etapa selecciona un subconjunto de los campos disponibles.

• La etapa $unwind convierte el campo price de un arreglo a un valor escalar.

Los documentos en la vista sales son:

{ prodId: 100, numPurchased: 20, price: 20 },
{ prodId: 101, numPurchased: 10, price: 10 },
{ prodId: 102, numPurchased: 5, price: 15 },
{ prodId: 103, numPurchased: 15, price: 17 },
{ prodId: 103, numPurchased: 20, price: 17 },
{ prodId: 102, numPurchased: 1, price: 15 },
{ prodId: 101, numPurchased: 5, price: 10 },
{ prodId: 100, numPurchased: 10, price: 20 },
{ prodId: 103, numPurchased: 30, price: 17 }

Para encontrar la cantidad total vendida de cada producto, consulta la vista:

db.sales.aggregate( [
   {
      $group:
         {
            _id: "$prodId",
            amountSold: { $sum: { $multiply: [ "$price", "$numPurchased" ] } }
         }
   }
] )

La salida es:

[
  { _id: 100, amountSold: 600 },
  { _id: 103, amountSold: 1105 },
  { _id: 101, amountSold: 150 },
  { _id: 102, amountSold: 90 }
]