/ /

Expressões

Página inicial do Docs

Desenvolvimento

Linguagem de query

Expressões

Página inicial do Docs

Desenvolvimento

Linguagem de query

Expressões

$setIntersection (operador de expressão )

Definição

$setIntersection

Obtém dois ou mais arrays e retorna uma array que contém os elementos que aparecem em cada array de entrada.

$setIntersection tem a seguinte sintaxe:

{ $setIntersection: [ <expression1>, <expression2>, ... ] }

Os argumentos podem ser qualquer expressão válida, desde que cada um deles resolva para uma array. Para mais informações sobre expressões, consulte Expressões.

Comportamento

$setIntersection performs set operation on arrays, treating arrays as sets. If an array contains duplicate entries, $setIntersection ignores the duplicate entries. $setIntersection ignores the order of the elements.

$setIntersection filtra duplicatas em seu resultado para gerar uma matriz que contém apenas entradas exclusivas. A ordem dos elementos na matriz de saída não é especificada.

If no intersections are found (i.e. the input arrays contain no common elements), $setIntersection returns an empty array.

If a set contains a nested array element, $setIntersection does not descend into the nested array but evaluates the array at top-level.

Exemplo

Resultado

Notas

{ $setIntersection: [
  [ "a", "c" ],
  [ "a", "b" ]
] }

[ "a" ]

O único elemento comum entre as duas arrays é "a".

{ $setIntersection: [
  [ "a", "c" ],
  [ "a", "b", "c" ]
] }

[ "a", "c" ]

"a" e "c" são elementos comuns entre as duas arrays.

{ $setIntersection: [
  [ "a", "b", "a" ],
  [ "b", "a" ]
] }

[ "b", "a" ]

"b" e "a" são elementos comuns entre as duas arrays.

{ $setIntersection: [
  [ "a", "b" ],
  [ [ "a", "b" ] ]
] }

[ ]

Não há elementos comuns entre as duas arrays. Os elementos de string "a" e "b" não são iguais à array [ "a", "b" ].

{ $setIntersection: [
  [ ],
  [ "a", "b" ]
] }

[ ]

Não há elementos comuns entre as duas arrays porque a primeira array está vazia.

{ $setIntersection: [
  [ "a", "a" ],
  [ "a", "b" ]
] }

[ "a" ]

O único elemento comum é "a" e aparece uma vez no resultado porque apenas elementos únicos são considerados.

Exemplos

Esta seção contém exemplos que mostram o uso do $setIntersection com collections.

Exemplo de array de elementos

Considere uma coleção flowers com os seguintes documentos:

db.flowers.insertMany( [
   { "_id" : 1, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "rose", "orchid" ] },
   { "_id" : 2, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "orchid", "rose", "orchid" ] },
   { "_id" : 3, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "rose", "orchid", "jasmine" ] },
   { "_id" : 4, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "jasmine", "rose" ] },
   { "_id" : 5, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ ] },
   { "_id" : 6, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ [ "rose" ], [ "orchid" ] ] },
   { "_id" : 7, "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ [ "rose", "orchid" ] ] },
   { "_id" : 8, "flowerFieldA" : [ ], "flowerFieldB" : [ ] },
   { "_id" : 9, "flowerFieldA" : [ ], "flowerFieldB" : [ "rose" ] }
] )

The following operation uses the $setIntersection operator to return an array of elements common to both the flowerFieldA array and the flowerFieldB array:

db.flowers.aggregate(
   [
     { $project: { flowerFieldA: 1, flowerFieldB: 1, commonToBoth: { $setIntersection: [ "$flowerFieldA", "$flowerFieldB" ] }, _id: 0 } }
   ]
)

A operação retorna os seguintes resultados:

{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "rose", "orchid" ], "commonToBoth" : [ "orchid", "rose" ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "orchid", "rose", "orchid" ], "commonToBoth" : [ "orchid", "rose" ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "rose", "orchid", "jasmine" ], "commonToBoth" : [ "orchid", "rose" ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ "jasmine", "rose" ], "commonToBoth" : [ "rose" ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ ], "commonToBoth" : [ ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ [ "rose" ], [ "orchid" ] ], "commonToBoth" : [ ] }
{ "flowerFieldA" : [ "rose", "orchid" ], "flowerFieldB" : [ [ "rose", "orchid" ] ], "commonToBoth" : [ ] }
{ "flowerFieldA" : [ ], "flowerFieldB" : [ ], "commonToBoth" : [ ] }
{ "flowerFieldA" : [ ], "flowerFieldB" : [ "rose" ], "commonToBoth" : [ ] }

Recuperar Documentos para Funções Concedidas 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:

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: [] } )

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

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 seguintes etapas para recuperar os documentos acessíveis a John:

Faça login como João

Executar:

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

Recuperar os documentos

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.budget.aggregate( [ {
   $match: {
      $expr: {
         $not: {
            $eq: [ { $setIntersection: [ "$allowedRoles", "$$USER_ROLES.role" ] }, [] ]
         }
      }
   }
} ] )

The previous example returns the documents from the budget collection that match at least one of the roles that the user who runs the example has. To do that, the example uses $setIntersection to return documents where the intersection between the budget document allowedRoles field and the set of user roles from $$USER_ROLES is not empty.

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:

Faça login como Jane

Executar:

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

Recuperar os documentos

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.budget.aggregate( [ {
   $match: {
      $expr: {
         $not: {
            $eq: [ { $setIntersection: [ "$allowedRoles", "$$USER_ROLES.role" ] }, [] ]
         }
      }
   }
} ] )

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.

Voltar

$setField

$setIsSubset