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 UI do Atlas MongoDB, você deve utilizar uma visualização materializada. Para saber mais, consulte Criar uma visualização materializada na interface do usuário do MongoDB Atlas.

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

O primeiro exemplo preenche uma coleta com dados do aluno e cria uma visualização para consultar os dados.

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

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.

Consultar a visualização

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

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 .

Observação

O uso da variável de sistema USER_ROLES em aggregations não é suportado em clusters M0 e Flex.

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

As seções a seguir descrevem os comportamentos de criação de visualização e consultas.

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. A otimização não altera 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