Visualizações

Somente leitura

As visualizações são somente leitura; as operações de gravação nas visualizações apresentarão erros.

As seguintes operações de leitura podem ajudar nas visualizações:

• db.collection.find()

• db.collection.findOne()

• db.collection.aggregate()

• db.collection.countDocuments()

• db.collection.estimatedDocumentCount()

• db.collection.count()

• db.collection.distinct()

Uso do Índice e Operações de Classificação

• As visualizações usam os índices da collection subjacente.

• Como os índices estão na collection subjacente, você não pode criar, eliminar ou reconstruir índices diretamente na visualização, nem obter uma lista de índices na visualização.

• A partir do MongoDB 4.4, você pode especificar uma classificação $natural ao executar um comando find em uma visualização. Versões anteriores do MongoDB não suportam classificação $natural nas visualizações.

• O aggregation pipeline subjacente da visualização está sujeito ao limite de memória de 100 megabytes para block sort e operações de grupo bloqueante. A partir do MongoDB 4.4, você pode emitir um comando find com allowDiskUse: true na visualização para permitir que o MongoDB use arquivos temporários para block sort e operações de grupo.

  Antes do MongoDB 4.4, somente o comando aggregate aceitava a opção allowDiskUse .

  Dica

  Veja também:

  Para obter mais informações sobre os limites de memória das operações de block sort, consulte Operações de classificação.

Restrições de projeção

As operações find() nas visualizações não suportam os seguintes operadores de projeção :

• $

• $elemMatch

• $slice

• $meta

Nome imutável

Não é possível renomear visualizações.

Visualizar criação

• As visualizações são computadas sob demanda durante as operações de leitura, e o MongoDB executa operações de leitura em visualizações como parte do pipeline de agregação subjacente. Dessa forma, as visualizações não suportam operações como:

  • db.collection.mapReduce(),

  • operador $text , já que a operação $text em agregação é válida somente para o primeiro estágio,

  • $geoNear estágio do pipeline.

• Se o aggregation pipeline usado para criar a exibição suprimir o campo _id , os documentos na exibição não terão o campo _id .

Quando você query uma visualização:

• As queries filter, projection, sort, skip, limit e outras operações para db.collection.find() são convertidas para os estágiosequivalentes do aggregation pipeline.

• Os estágios do aggregation pipeline convertidos são adicionados ao final do aggregation pipeline para a visualização. Isso não modifica o pipeline subjacente da visualização, que é definido quando você cria a visualização.

• O otimizador de pipeline de agregação remodela os estágios do pipeline de agregação de visualização para melhorar o desempenho. Isso não altera os resultados da query.

Visualização fragmentada

As visualizações serão consideradas fragmentadas se a collection subjacente for fragmentada. Dessa forma, você não pode especificar uma visualização fragmentada para o campo from nas operações $lookup e $graphLookup .

Visualizações e agrupamento

• Você pode especificar um agrupamento padrão para uma visualização no momento da criação. Se nenhum agrupamento for especificado, o agrupamento padrão da visualização será o coletor de comparação binária "simples". Ou seja, a visualização não herda o agrupamento padrão da collection.

• As comparações de strings na visualização usam o agrupamento padrão da visualização. Uma operação que tenta alterar ou substituir a coleta padrão de uma visualização falhará com um erro.

• Se estiver criando um modo de exibição a partir de outro modo de exibição, você não poderá especificar um agrupamento que difere do agrupamento do modo de exibição de origem.

• Se executar uma aggregation que envolve múltiplas visualizações, como com $lookup ou $graphLookup, as visualizações deverão ter o mesmo agrupamento.

Isolamento de snapshot

As visualizações não mantêm registros de data e hora das alterações da coleção e não são compatíveis com o isolamento de leituras pontuais ou de snapshots.

Definição de exibição pública

As operações que listam collection, como db.getCollectionInfos() e db.getCollectionNames(), incluem visualizações em seus resultados.

Use db.createView() para criar uma visualização

Use o db.createView() para criar uma visualização limitada aos alunos do primeiro ano:

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

No exemplo:

• firstYears é o nome da nova visualização.

• students é a collection na qual a visualização se baseia.

• $match é uma expressão de aggregation que corresponde aos alunos do primeiro ano na collection students.

Este exemplo consulta a visualização:

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

O resultado a seguir contém apenas os documentos com dados sobre os alunos do primeiro ano. A projeção do { _id: 0 } suprime o campo _id na saída.

[
  { 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 }
]

Use db.createCollection() para criar uma visualização

O método db.createCollection() permite a você criar uma collection ou uma visualização com opções específicas.

O exemplo a seguir cria uma visualização graduateStudents. O modo de exibição contém apenas documentos selecionados pelo estágio $match. A configuração de agrupamento opcional determina a ordem de classificação.

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

O exemplo a seguir consulta a visualização. O estágio $unset remove o campo _id da saída para maior clareza.

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

Quando a saída é classificada, o estágio $sort usa a ordem de agrupamento para classificar as letras maiúsculas antes das letras minúsculas.

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

Use uma visualização para participar de duas collections

Muitas vezes, é conveniente usar $lookup para criar uma visualização sobre duas collection e, em seguida, executar query na visualização. Os aplicativos podem consultar a visualização sem precisar construir ou manter pipelines complexos.

Crie duas collections de amostra, inventory e 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 }
] )

Crie uma visualização que combine elementos de cada collection:

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" }
] )

No exemplo:

• db.createView() cria a visualização sales .

• A visualização sales é baseada na collection orders .

• O estágio $lookup usa o campo prodId na collection orders para "unir" documentos na collection inventory que tenham campos prodId correspondentes.

• Os documentos correspondentes são adicionados como uma array no campo inventoryDocs.

• O estágio $project seleciona um subconjunto dos campos disponíveis.

• O estágio $unwind converte o campo price de uma array para um valor escalar.

Os documentos na visualização sales são:

{ 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 o valor total vendido de cada produto, consulte a visualização:

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

A saída é:

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