MongoDB $setEquals

En MongoDB, el $setEquals el operador de canalización de agregación compara dos o más matrices y devuelve true si tienen los mismos elementos distintos y false de lo contrario.

$setEquals acepta dos o más argumentos, todos los cuales pueden ser cualquier expresión válida siempre que cada uno se resuelva en una matriz. $setEquals trata las matrices como conjuntos.

Ejemplo

Supongamos que tenemos una colección llamada data con los siguientes documentos:

{ "_id" : 1, "a" : [ 1, 2, 3 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 2, "a" : [ 1, 2, 3 ], "b" : [ 1, 2 ] }
{ "_id" : 3, "a" : [ 1, 2 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 4, "a" : [ 1, 2, 3 ], "b" : [ 3, 4, 5 ] }
{ "_id" : 5, "a" : [ 1, 2, 3 ], "b" : [ 4, 5, 6 ] }

Podemos aplicar el $setEquals operador contra el a y b campos en esos documentos.

Ejemplo:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

{ "a" : [ 1, 2, 3 ], "b" : [ 1, 2, 3 ], "result" : true }
{ "a" : [ 1, 2, 3 ], "b" : [ 1, 2 ], "result" : false }
{ "a" : [ 1, 2 ], "b" : [ 1, 2, 3 ], "result" : false }
{ "a" : [ 1, 2, 3 ], "b" : [ 3, 4, 5 ], "result" : false }
{ "a" : [ 1, 2, 3 ], "b" : [ 4, 5, 6 ], "result" : false }

Matrices anidadas

El $setEquals El operador no desciende a ninguna matriz anidada. Solo evalúa matrices de nivel superior.

Supongamos que nuestra colección también contiene los siguientes documentos:

{ "_id" : 6, "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2, 3 ] ] }
{ "_id" : 7, "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2 ], 3 ] }

Y aplicamos $setEquals a esos dos documentos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 6, 7 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

{ "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2, 3 ] ], "result" : false }
{ "a" : [ 1, 2, 3 ], "b" : [ [ 1, 2 ], 3 ], "result" : false }

En el primer documento, el b El campo contenía una matriz que contenía solo un elemento:otra matriz. En este caso, se evaluó la matriz externa y se encontró que no contenía los mismos valores que estaban en la matriz en a .

Sin embargo, si el a campo hubiera contenido una matriz anidada, podría haber sido una historia diferente.

Supongamos que tenemos los siguientes documentos:

{ "_id" : 8, "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2, 3 ] ] }
{ "_id" : 9, "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2 ], 3 ] }

Y aplicamos $setEquals a esos documentos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 8, 9 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

{ "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2, 3 ] ], "result" : true }
{ "a" : [ [ 1, 2, 3 ] ], "b" : [ [ 1, 2 ], 3 ], "result" : false }

En el primer documento, a coincide con b exactamente, por lo que el resultado es true .

En el segundo documento, la matriz anidada en a es diferente a la matriz anidada en b , por lo que obtenemos false .

Campos faltantes

Aplicando $setEquals a un campo inexistente da como resultado un error.

Considere los siguientes documentos:

{ "_id" : 10, "a" : [ 1, 2, 3 ] }
{ "_id" : 11, "b" : [ 1, 2, 3 ] }
{ "_id" : 12 }

El primer documento no tiene una b campo, el segundo documento no tiene un a y el tercer documento no tiene ninguno.

Esto es lo que sucede cuando aplicamos $setEquals al a y b campos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "All operands of $setEquals must be arrays. One argument is of type: missing",
	"code" : 17044,
	"codeName" : "Location17044"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

Como indica el mensaje, todos los operandos deben ser matrices. Un campo/argumento faltante no es una matriz.

Tipo de datos incorrecto

Como se vio en el ejemplo anterior, todos los operandos de $setEquals deben ser matrices. Si falta el campo al que se refieren, se genera un error. El mismo error ocurre cuando no falta el operando, sino que simplemente es del tipo incorrecto.

Supongamos que nuestra colección contiene los siguientes documentos:

{ "_id" : 13, "a" : [ 1, 2, 3 ], "b" : 3 }
{ "_id" : 14, "a" : 3, "b" : [ 1, 2, 3 ] }
{ "_id" : 15, "a" : 2, "b" : 3 }

Y aplicamos $setEquals a esos documentos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "All operands of $setEquals must be arrays. One argument is of type: double",
	"code" : 17044,
	"codeName" : "Location17044"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

Valores duplicados

El $setEquals El operador ignora las entradas duplicadas. También ignora el orden de los elementos.

Supongamos que tenemos los siguientes documentos:

{ "_id" : 16, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2, 3 ] }
{ "_id" : 17, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2 ] }
{ "_id" : 18, "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ ] }
{ "_id" : 19, "a" : [ 3, 2, 1, 2, 3, 1 ], "b" : [ 2, 3, 1 ] }
{ "_id" : 20, "a" : [ 1, 3, 2, 2, 3, 1 ], "b" : [ 2, 1 ] }
{ "_id" : 21, "a" : [ 2, 3, 1, 2, 3, 1 ], "b" : [ ] }

Luego aplicamos el $setEquals operador para ellos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
)

Resultado:

{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2, 3 ], "result" : true }
{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ 1, 2 ], "result" : false }
{ "a" : [ 1, 1, 2, 2, 3, 3 ], "b" : [ ], "result" : false }
{ "a" : [ 3, 2, 1, 2, 3, 1 ], "b" : [ 2, 3, 1 ], "result" : true }
{ "a" : [ 1, 3, 2, 2, 3, 1 ], "b" : [ 2, 1 ], "result" : false }
{ "a" : [ 2, 3, 1, 2, 3, 1 ], "b" : [ ], "result" : false }

Más de dos argumentos

Como se mencionó, $setEquals acepta dos o más argumentos. En todos los casos, los argumentos deben tener los mismos valores distintos para devolver true . De lo contrario, el resultado será false .

Supongamos que tenemos los siguientes documentos:

{ "_id" : 22, "a" : [ 1, 2 ], "b" : [ 1, 2 ], "c" : [ 1, 2 ] }
{ "_id" : 23, "a" : [ 1, 2 ], "b" : [ 1, 2 ], "c" : [ 1, 2, 3 ] }

Estos documentos tienen un campo adicional:una c campo.

Ahora apliquemos $setEquals a esos tres campos:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 22, 23 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            c: 1,
            result: { $setEquals: [ "$a", "$b", "$c" ] }
          }
     }
   ]
)

Resultado:

{ "a" : [ 1, 2 ], "b" : [ 1, 2 ], "c" : [ 1, 2 ], "result" : true }
{ "a" : [ 1, 2 ], "b" : [ 1, 2 ], "c" : [ 1, 2, 3 ], "result" : false }