MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

MongoDB $ setDifference


No MongoDB, o $setDifference O operador de pipeline de agregação aceita dois conjuntos e executa um complemento relativo do segundo conjunto em relação ao primeiro. Ele retorna um array contendo os elementos que existem apenas no primeiro conjunto.

$setDifference aceita dois argumentos, os quais podem ser qualquer expressão válida, desde que cada um seja resolvido para uma matriz. $setDifference 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 $setDifference 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: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

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

Matrizes aninhadas


O $setDifference 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 $setDifference a esses dois documentos:
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 6, 7 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

Resultado:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "resultado" :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "resultado" :[ 1, 2 ] }

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 $setDifference a esses documentos:
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 8, 9 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

Resultado:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "resultado" :[ ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "resultado" :[ [ 1, 2, 3 ] ] }

No primeiro documento, a corresponde a b exatamente, e assim o resultado é uma matriz vazia.

No segundo documento, o array aninhado em a é diferente do array aninhado em b , e assim toda a matriz aninhada de a é devolvido.

Campos ausentes


Aplicando $setDifference para um campo inexistente resulta em null .

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 $setDifference para o a e b Campos:
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

Resultado:
{ "a" :[ 1, 2, 3 ], "resultado" :null }{ "b" :[ 1, 2, 3 ], "resultado" :null }{ "resultado" :null } 

Tipo de dados incorreto


Ambos os operandos de $setDifference devem ser matrizes. Se não estiverem, um erro será lançado.

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 $setDifference a esses documentos:
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

Resultado:
exceção não capturada:Erro:o comando falhou:{ "ok":0, "errmsg":"ambos os operandos de $setDifference devem ser arrays. O segundo argumento é do tipo:double", "code":17049, "codeName" :"Location17049"}:falha na agregação :[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell /assert.js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection .js:1058:12@(shell):1:1

Valores duplicados


O $setDifference O operador filtra duplicatas em seu resultado para gerar uma matriz que contém apenas entradas exclusivas. Além disso, a ordem dos elementos na matriz de saída não é especificada.

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 $setDifference operador para eles:
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 

Resultado:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "resultado" :[ ] }{ "a" :[ 1, 1 , 2, 2, 3, 3 ], "b" :[ 1, 2 ], "resultado" :[ 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ], "resultado" :[ 1, 2, 3 ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "resultado" :[ ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "resultado" :[ 3 ] }{ "a" :[ 2, 3 , 1, 2, 3, 1 ], "b" :[ ], "resultado" :[ 2, 3, 1 ] }