Make the MongoDB docs better! We value your opinion. Share your feedback for a chance to win $100.
Click here >
Menu Docs
Página inicial do Docs
/ /
Visualizações
Página inicial do Docs
/
Desenvolvimento
/
reconhecimento de data center e collection
/
Visualizações
Página inicial do Docs
/
Desenvolvimento
/
reconhecimento de data center e collection
/
Visualizações

Criar e consultar uma visualização

Para criar uma visualização, use um dos seguintes métodos:

Para criar uma visualização na interface do usuário do MongoDB Atlas , use o Construtor de aggregation pipeline. Para saber mais,consulte atlas-ui-views.

Importante

Os nomes de visualização são incluídos na saída da lista de collections

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

A definição da visualização é pública; ou seja, as operações db.getCollectionInfos() e explain na exibição incluirão o pipeline que define a visualização. Dessa forma, evite se referir diretamente a campos e valores confidenciais nas definições de visualização.

db.createCollection() Sintaxe

db.createCollection(
  "<viewName>",
  {
    "viewOn" : "<source>",
    "pipeline" : [<pipeline>],
    "collation" : { <collation> }
  }
)

db.createView() Sintaxe

db.createView(
  "<viewName>",
  "<source>",
  [<pipeline>],
  {
    "collation" : { <collation> }
  }
)

Restrições

  • Você deve criar visualizações no mesmo banco de dados que a collection de origem.

  • Uma definição de visualização pipeline não pode incluir o estágio $out ou $merge. Essa restrição também se aplica a pipelines incorporados, como pipelines usados em estágios $lookup ou $facet.

  • Você não pode renomear uma visualização depois que ela for criada.

Operações não suportadas

Algumas operações não estão disponíveis com visualizações:

Para mais informações, consulte Operações suportadas para visualizações.

Exemplos

Preencher a collection

Crie uma collection students para usar neste exemplo:

db.students.insertMany( [
   { sID: 22001, name: "Alex", year: 1, score: 4.0 },
   { sID: 21001, name: "bernie", year: 2, score: 3.7 },
   { sID: 20010, name: "Chris", year: 3, score: 2.5 },
   { sID: 22021, name: "Drew", year: 1, score: 3.2 },
   { sID: 17301, name: "harley", year: 6, score: 3.1 },
   { sID: 21022, name: "Farmer", year: 1, score: 2.2 },
   { sID: 20020, name: "george", year: 3, score: 2.8 },
   { sID: 18020, name: "Harley", year: 5, score: 2.8 },
] )

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

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.

Consultar a visualização

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

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

Observação

Restrições de projeção

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

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: { year: { $gt: 4 } } } ],
      collation: { locale: "en", caseFirst: "upper" }
   }
)

Observação

Comportamento do 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.

Consultar a visualização

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

Recuperar informações médicas para roles concedidos ao usuário atual

A partir do MongoDB 7.0, você pode usar a nova variável de sistemaUSER_ROLES para retornar funções de usuário .

O exemplo nesta seção mostra usuários com acesso limitado a campos em uma collection contendo informações médicas. O exemplo usa uma visualização que lê as roles de usuário atuais da variável USER_ROLES do sistema e oculta os campos com base nas roles.

O exemplo cria estes usuários:

  • James com uma função Billing que pode acessar um campo creditCard.

  • Michelle com uma função Provider que pode acessar um campo diagnosisCode.

Execute as seguintes etapas para criar as funções, os usuários, a coleta e a visualização:

1

Criar as funções

Executar:

db.createRole( { role: "Billing", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )
db.createRole( { role: "Provider", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )
2

Criar os usuários

Crie usuários nomeados James e Michelle com os papéis exigidos. Substitua o banco de dados test pelo nome do banco de dados.

db.createUser( {
   user: "James",
   pwd: "js008",
   roles: [
      { role: "Billing", db: "test" }
   ]
} )
db.createUser( {
   user: "Michelle",
   pwd: "me009",
   roles: [
      { role: "Provider", db: "test" }
   ]
} )
3

Criar a coleção

Executar:

db.medical.insertMany( [
   {
      _id: 0,
      patientName: "Jack Jones",
      diagnosisCode: "CAS 17",
      creditCard: "1234-5678-9012-3456"
   },
   {
      _id: 1,
      patientName: "Mary Smith",
      diagnosisCode: "ACH 01",
      creditCard: "6541-7534-9637-3456"
   }
] )
4

Crie a visualização

Para usar uma variável do sistema, adicione $$ ao início do nome da variável. Especifique a variável de sistema USER_ROLES como $$USER_ROLES.

A visualização lê as roles de usuário atuais da variável do sistema USER_ROLES e oculta campos com base nas roles.

Executar:

db.createView(
   "medicalView", "medical",
   [ {
      $set: {
         "diagnosisCode": {
            $cond: {
               if: { $in: [
                  "Provider", "$$USER_ROLES.role"
               ] },
               then: "$diagnosisCode",
               else: "$$REMOVE"
            }
      }
   },
   }, {
      $set: {
         "creditCard": {
            $cond: {
               if: { $in: [
                  "Billing", "$$USER_ROLES.role"
               ] },
               then: "$creditCard",
               else: "$$REMOVE"
            }
         }
      }
   } ]
)

O exemplo de visualização:

  • inclui o campo diagnosisCode para um usuário com a função Provider.

  • inclui o campo creditCard para um usuário com a função Billing.

  • usa os estágios de pipeline $set e $$REMOVE para ocultar campos com base no fato de o usuário que consulta a visualização ter a função correspondente retornada em $$USER_ROLES.role.

Execute as etapas a seguir para recuperar as informações acessíveis a James:

1

Faça login como James

Executar:

db.auth( "James", "js008" )
2

Recuperar os documentos

Executar:

db.medicalView.find()
3

Examine os documentos

James tem a função Billing e vê os seguintes documentos, que incluem o campo creditCard, mas não o campo diagnosisCode:

[
   {
      _id: 0, patientName: 'Jack Jones',
      creditCard: '1234-5678-9012-3456'
   },
   {
      _id: 1, patientName: 'Mary Smith',
      creditCard: '6541-7534-9637-3456'
   }
]

Execute as etapas a seguir para recuperar as informações acessíveis a Michelle:

1

Faça login como Michelle

Executar:

db.auth( "Michelle", "me009" )
2

Recuperar os documentos

Executar:

db.medicalView.find()
3

Examine os documentos

Michelle tem a função Provider e vê os seguintes documentos, que incluem o campo diagnosisCode, mas não o campo creditCard:

[
   { _id: 0, patientName: 'Jack Jones',
      diagnosisCode: 'CAS 17' },
   { _id: 1, patientName: 'Mary Smith',
      diagnosisCode: 'ACH 01' }
]

Recuperar documentos orçamentários para roles concedidos ao usuário atual

A partir do MongoDB 7.0, você pode usar a nova variável de sistemaUSER_ROLES para retornar funções de usuário .

O cenário nesta section mostra users com várias roles que têm acesso limitado a documents em uma coleção que contém information sobre budget.

O cenário mostra um possível uso de USER_ROLES. A coleção budget contém documentos com um campo denominado allowedRoles. Como você verá no cenário a seguir, você pode escrever queries que comparam as funções de usuário encontradas no campo allowedRoles com as funções retornadas pela variável de sistema USER_ROLES.

Observação

Para outro cenário de exemplo USER_ROLES, consulte Recuperar informações médicas para funções concedidas ao usuário atual. Esse exemplo não armazena as funções de usuário nos campos do documento, como é feito no exemplo a seguir.

Para o cenário de orçamento nesta seção, execute as seguintes etapas para criar as roles, os usuários e a collection budget:

1

Criar as funções

Executar:

db.createRole( { role: "Marketing", roles: [], privileges: [] } )
db.createRole( { role: "Sales", roles: [], privileges: [] } )
db.createRole( { role: "Development", roles: [], privileges: [] } )
db.createRole( { role: "Operations", roles: [], privileges: [] } )
2

Criar os usuários

Crie usuários nomeados John e Jane com os papéis exigidos. Substitua o banco de dados test pelo nome do banco de dados.

db.createUser( {
   user: "John",
   pwd: "jn008",
   roles: [
      { role: "Marketing", db: "test" },
      { role: "Development", db: "test" },
      { role: "Operations", db: "test" },
      { role: "read", db: "test" }
   ]
} )
db.createUser( {
   user: "Jane",
   pwd: "je009",
   roles: [
      { role: "Sales", db: "test" },
      { role: "Operations", db: "test" },
      { role: "read", db: "test" }
   ]
} )
3

Criar a coleção

Executar:

db.budget.insertMany( [
   {
      _id: 0,
      allowedRoles: [ "Marketing" ],
      comment: "For marketing team",
      yearlyBudget: 15000
   },
   {
      _id: 1,
      allowedRoles: [ "Sales" ],
      comment: "For sales team",
      yearlyBudget: 17000,
      salesEventsBudget: 1000
   },
   {
      _id: 2,
      allowedRoles: [ "Operations" ],
      comment: "For operations team",
      yearlyBudget: 19000,
      cloudBudget: 12000
   },
   {
      _id: 3,
      allowedRoles: [ "Development" ],
      comment: "For development team",
      yearlyBudget: 27000
   }
] )

Execute as etapas a seguir para criar uma exibição e recuperar os documentos acessíveis para John:

1

Crie a visualização

Para usar uma variável do sistema, adicione $$ ao início do nome da variável. Especifique a variável de sistema USER_ROLES como $$USER_ROLES.

Executar:

db.createView(
   "budgetView", "budget",
   [ {
      $match: {
         $expr: {
            $not: {
               $eq: [ { $setIntersection: [ "$allowedRoles", "$$USER_ROLES.role" ] }, [] ]
            }
         }
      }
   } ]
)

Se você não conseguir criar a visualização, certifique-se de fazer login como usuário com o privilégio de criar uma visualização.

O exemplo anterior retorna os documentos da coleção budget que correspondem a pelo menos uma das funções que o usuário que executa o exemplo tem. Para fazer isso, o exemplo usa $setIntersection para retornar documentos em que a interseção entre o budget campo de documento allowedRoles e o conjunto de funções de usuários de $$USER_ROLES não está vazia.

2

Faça login como João

Executar:

db.auth( "John", "jn008" )
3

Recuperar os documentos

Executar:

db.budgetView.find()
4

Examine os documentos

John tem as funções Marketing, Operations e Development e vê estes documentos:

[
   {
      _id: 0,
      allowedRoles: [ 'Marketing' ],
      comment: 'For marketing team',
      yearlyBudget: 15000
   },
   {
      _id: 2,
      allowedRoles: [ 'Operations' ],
      comment: 'For operations team',
      yearlyBudget: 19000,
      cloudBudget: 12000
   },
   {
      _id: 3,
      allowedRoles: [ 'Development' ],
      comment: 'For development team',
      yearlyBudget: 27000
   }
]

Execute as seguintes etapas para recuperar os documentos acessíveis a Jane:

1

Faça login como Jane

Executar:

db.auth( "Jane", "je009" )
2

Recuperar os documentos

Executar:

db.budgetView.find()
3

Examine os documentos

Jane tem as funções Sales e Operations e vê estes documentos:

[
   {
      _id: 1,
      allowedRoles: [ 'Sales' ],
      comment: 'For sales team',
      yearlyBudget: 17000,
      salesEventsBudget: 1000
   },
   {
      _id: 2,
      allowedRoles: [ 'Operations' ],
      comment: 'For operations team',
      yearlyBudget: 19000,
      cloudBudget: 12000
   }
]

Observação

Em um cluster fragmentado, uma query pode ser executada em um fragmento por outro nó de servidor em nome do usuário. Nestas queries, o USER_ROLES ainda é preenchido com as funções do usuário.

Funções com o mesmo nome em vários bancos de dados

Vários bancos de dados podem ter roles com o mesmo nome. Se você criar uma visualização e fizer referência a um role específico na visualização, deverá especificar o campo de nome do banco de dados db e o campo role, ou especificar o campo _id que contém o nome do banco de dados e o role.

O exemplo a seguir retorna as funções atribuídas a Jane, que tem roles com nomes diferentes. O exemplo retorna o nome do banco de dados _id, role e db:

1

Faça login como Jane

Executar:

db.auth( "Jane", "je009" )
2

Recuperar os documentos

Executar:

db.budget.findOne( {}, { myRoles: "$$USER_ROLES" } )
3

Examine os documentos

Saída de exemplo, que mostra o nome do banco de dados _id, role e db na array myRoles:

{
   _id: 0,
   myRoles: [
      { _id: 'test.Operations', role: 'Operations', db: 'test' },
      { _id: 'test.Sales', role: 'Sales', db: 'test' },
      { _id: 'test.read', role: 'read', db: 'test' }
   ]
}

Comportamento

Otimizações de agregação

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.

  • O MongoDB acrescenta a query do cliente ao pipeline subjacente e retorna os resultados desse pipeline combinado para o cliente. O MongoDB pode aplicar otimizações de pipeline de agregação ao pipeline combinado.

  • O otimizador de pipeline de agregação remodela os estágios do pipeline de agregação de visualização para melhorar o desempenho sem alterar os resultados da consulta.

Bloqueio de recursos

db.createView() obtém um bloqueio exclusivo na coleção ou visualização especificada durante a operação. Todas as operações subsequentes na coleção devem aguardar até quedb.createView() libere o bloqueio. db.createView() normalmente mantém esse bloqueio por um curto período.

Criar uma visualização exige a obtenção de uma trava exclusiva adicional na collection system.views no banco de dados. Essa trava bloqueia a criação ou modificação de visualizações no banco de dados até que o comando seja concluído.

Voltar

Visualizações

Próximo

Juntar coleções

Nesta página