MongoDB $setEquals

No MongoDB, o $setEquals operador de pipeline de agregação compara duas ou mais matrizes e retorna true se eles tiverem os mesmos elementos distintos e false por outro lado.

$setEquals aceita dois ou mais argumentos, todos os quais podem ser qualquer expressão válida desde que cada um seja resolvido para uma matriz. $setEquals trata os arrays como conjuntos.

Exemplo

Suponha que tenhamos uma coleção chamada data com os seguintes 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 o $setEquals operador contra o a e b campos nesses documentos.

Exemplo:

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 ], "resultado" :verdadeiro }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "resultado" :falso }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "resultado" :falso }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "resultado" :falso }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "resultado " :falso }

Matrizes aninhadas

O $setEquals operador não desce em nenhuma matriz aninhada. Ele avalia apenas arrays de nível superior.

Suponha que nossa coleção também contenha os seguintes documentos:

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

E aplicamos $setEquals a esses dois 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 ] ], "resultado" :false }{ "a" :[ 1, 2, 3 ], " b" :[ [ 1, 2 ], 3 ], "resultado" :false }

No primeiro documento, o b O campo continha um array que continha apenas um elemento – outro array. Nesse caso, a matriz externa foi avaliada e não continha os mesmos valores que estavam na matriz em a .

No entanto, se o a field contivesse uma matriz aninhada, poderia ter sido uma história diferente.

Suponha que temos os seguintes documentos:

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

E aplicamos $setEquals a esses 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 ] ], "resultado" :verdadeiro }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "resultado" :false }

No primeiro documento, a corresponde a b exatamente, e então o resultado é true .

No segundo documento, o array aninhado em a é diferente do array aninhado em b , e assim obtemos false .

Campos ausentes

Aplicando $setEquals para um campo inexistente resulta em erro.

Considere os seguintes documentos:

{ "_id" :10, "a" :[ 1, 2, 3 ] }{ "_id" :11, "b" :[ 1, 2, 3 ] }{ "_id" :12 } 
 O primeiro documento não tem um b campo, o segundo documento não tem um a campo, e o terceiro documento também não. 
 
 Veja o que acontece quando aplicamos $setEquals para o a e 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" :"Todos os operandos de $setEquals devem ser arrays. Um argumento é do tipo:missing", "code" :17044, "codeName" :"Location17044 "} :falha na agregação :example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert. js:639:17example@sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(shell):1:1
 
 Conforme a mensagem informa, todos os operandos devem ser arrays. Um argumento/campo ausente não é uma matriz. 
 Tipo de dados incorreto
 
 Como visto no exemplo anterior, todos os operandos de $setEquals devem ser matrizes. Se o campo ao qual eles se referem estiver ausente, um erro será gerado. O mesmo erro ocorre quando o operando não está faltando, mas é simplesmente do tipo errado. 
 
 Suponha que nossa coleção contenha os seguintes documentos:
 { "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
 
 E aplicamos $setEquals a esses 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" :"Todos os operandos de $setEquals devem ser arrays. Um argumento é do tipo:double", "code" :17044, "codeName" :"Location17044 "} :falha na agregação :example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert. js:639:17example@sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(shell):1:1
 Valores duplicados
 
 O $setEquals operador ignora entradas duplicadas. Também ignora a ordem dos elementos. 
 
 Suponha que temos os seguintes 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" :[ ] }
 
 Em seguida, aplicamos o $setEquals operador para eles:
 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 ], "resultado" :verdadeiro }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "resultado" :false }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ] , "resultado" :falso }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "resultado" :verdadeiro }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "resultado" :false }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b " :[ ], "resultado" :false }
 Mais de dois argumentos
 
 Como mencionado, $setEquals aceita dois ou mais argumentos. Em todos os casos, os argumentos devem ter os mesmos valores distintos para retornar true . Caso contrário, o resultado será false . 
 
 Suponha que temos os seguintes documentos:
 { "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }
 
 Esses documentos têm um campo extra – um c campo. 
 
 Agora vamos aplicar $setEquals para esses três 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 ], "resultado" :verdadeiro }{ "a" :[ 1, 2 ] , "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "resultado" :false }