/ /

$setIntersection (agregación)

Definición

$setIntersection

Toma dos o más arreglos y retorna un arreglo que contiene los elementos que aparecen en cada arreglo de entrada.

$setIntersection tiene la siguiente sintaxis:

{ $setIntersection: [ <array1>, <array2>, ... ] }

Los argumentos pueden ser cualquier válido. expresión, siempre que cada una de ellas se resuelva en una matriz. Para más información sobre expresiones, consulte Expresiones.

Comportamiento

$setIntersection realiza operaciones de conjunto en matrices, tratándolas como conjuntos. Si una matriz contiene entradas duplicadas, $setIntersection las ignora. $setIntersection ignora el orden de los elementos.

$setIntersection filtra los duplicados en su resultado para producir un arreglo que contenga solo entradas únicas. El orden de los elementos en el arreglo de salida no está especificado.

Si no se encuentran intersecciones (es decir, las matrices de entrada no contienen elementos comunes), devuelve una matriz$setIntersection vacía.

Si un conjunto contiene un elemento de arreglo anidado, $setIntersection no desciende al arreglo anidado, sino que evalúa el arreglo en el nivel superior.

Ejemplo

Resultado

notas

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

[ "a" ]

El único elemento común entre las dos matrices es "a".

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

[ "a", "c" ]

"a" y "c" son elementos comunes entre las dos matrices.

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

[ "b", "a" ]

"b" y "a" son elementos comunes entre las dos matrices.

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

[ ]

No hay elementos comunes entre las dos matrices. Los elementos de cadena "a" y "b" no son iguales a los de la matriz [ "a", "b" ].

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

[ ]

No hay elementos comunes entre las dos matrices porque la primera matriz está vacía.

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

[ "a" ]

El único elemento común es "a" y aparece una vez en el resultado porque solo se consideran elementos únicos.

Ejemplos

Esta sección contiene ejemplos que muestran el uso de $setIntersection con colecciones.

Ejemplo de matriz de elementos

Considere una colección flowers con los siguientes 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" ] }
] )

La siguiente operación utiliza el operador para devolver una matriz de elementos comunes tanto a $setIntersection la flowerFieldA matriz como a la flowerFieldB matriz:

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

La operación devuelve los siguientes 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" : [ ] }

Recupera documentos para los roles otorgados al usuario actual

A partir de MongoDB 7.0, puedes usar la nueva variable de sistema USER_ROLES para devolver los roles de usuario.

En esta sección aparecen usuarios con varios roles que tienen acceso limitado a documentos en una colección que contiene información presupuestaria.

El escenario muestra un posible uso de USER_ROLES. La colección budget contiene documentos con un campo llamado allowedRoles. Como verás en el siguiente caso, puedes guardar queries que comparen los roles de usuario encontrados en el campo allowedRoles con los roles devueltos por la variable de sistema USER_ROLES.

Nota

Para ver otro ejemplo de USER_ROLES, consulta Recuperación de la información médica para los roles otorgados al usuario actual. Ese ejemplo no almacena los roles de usuario en los campos del documento, tal como se hace en el ejemplo siguiente.

Para el escenario presupuestario de esta sección, realiza los siguientes pasos para crear los roles, usuarios y la colección de budget:

Crea los roles

Ejecuta:

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

Crea los usuarios

Crea usuarios llamados John y Jane con los roles requeridos. Reemplaza la base de datos test con el nombre de su base de datos.

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

Crear la colección

Ejecuta:

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

Realiza los siguientes pasos para recuperar los documentos accesibles a John

Inicia sesión como John

Ejecuta:

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

Recupera los documentos

Para usar una variable del sistema, agrega $$ al inicio del nombre de la variable. Especifica la variable del sistema USER_ROLES como $$USER_ROLES.

Ejecuta:

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

El ejemplo anterior devuelve los documentos de la budget colección que coinciden con al menos uno de los roles del usuario que ejecuta el ejemplo. Para ello, el ejemplo utiliza para devolver $setIntersection los documentos donde la intersección entre el budget campo del documento allowedRoles y el conjunto de roles de usuario de $$USER_ROLES no está vacía.

Examina los documentos

John tiene los roles Marketing, Operations y Development, y ve estos 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
   }
]

Realiza los siguientes pasos para recuperar los documentos accesibles a Jane

Inicia sesión como Jane

Ejecuta:

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

Recupera los documentos

Para usar una variable del sistema, agrega $$ al inicio del nombre de la variable. Especifica la variable del sistema USER_ROLES como $$USER_ROLES.

Ejecuta:

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

Examina los documentos

Jane tiene los roles Sales y Operations y ve estos 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
   }
]

Nota

En un clúster, una query se puede ejecutar en un fragmento por otro nodo de servidor en nombre del usuario. En esas queries, USER_ROLES todavía se completan con los roles del usuario.

Volver

$setField

$setIsSubset