/ /

Update

arrays

Página inicial do Docs

$pull (operador de atualização)

Definição

$pull: O operador remove de uma array existente todas as instâncias de um valor ou valores que correspondem a uma condição $pull especificada.

Compatibilidade

Você pode utilizar o $pull para implantações hospedadas nos seguintes ambientes:

MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB
MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

O operador tem o seguinte $pull formato:

{ $pull: { <field1>: <value|condition>, <field2>: <value|condition>, ... } }

Para especificar um <field> em um documento incorporado ou em uma array, use a notação de ponto.

Comportamento

A partir do MongoDB 5.0, os operadores de atualização processam campos de documento com nomes baseados em cadeia de caracteres em ordem lexicográfica. Os campos com nomes numéricos são processados em ordem numérica. Consulte Atualizar Comportamento de Operadores para detalhes.

Se você especificar um <condition> e os elementos de array forem documentos incorporados, o operador aplicará$pull o <condition> como se cada elemento de array fosse um documento em uma coleção.Consulte Remover itens de uma matriz de documentos para obter um exemplo.

Se o especificado <value> a ser removido for uma array, removerá somente os elementos na array que$pull correspondam <value> exatamente ao especificado, incluindo a ordem.

Se o especificado <value> a ser removido for um documento, $pull removerá apenas os elementos na array que têm exatamente os mesmos campos e valores. A ordem dos campos pode ser diferente.

A partir do MongoDB,5.0 mongod não gera mais um erro quando você usa um operador de atualização como $pull com uma expressão de operando vazia ( { } ). Uma atualização vazia não resulta em nenhuma alteração e nenhuma entrada no oplog é criada (o que significa que a operação é um no-op).

Exemplos

Remover todos os itens que equivalem a um valor especificado

Crie a coleção stores:

db.stores.insertMany( [
   {
      _id: 1,
      fruits: [ "apples", "pears", "oranges", "grapes", "bananas" ],
      vegetables: [ "carrots", "celery", "squash", "carrots" ]
   },
   {
      _id: 2,
      fruits: [ "plums", "kiwis", "oranges", "bananas", "apples" ],
      vegetables: [ "broccoli", "zucchini", "carrots", "onions" ]
   }
] )

A seguinte operação remove

"apples" e "oranges" a partir da array fruits
"carrots" da array vegetables

db.stores.updateMany(
    { },
    { $pull: { fruits: { $in: [ "apples", "oranges" ] }, vegetables: "carrots" } }
)

Confirme o resultado com db.collection.find():

{
  _id: 1,
  fruits: [ 'pears', 'grapes', 'bananas' ],
  vegetables: [ 'celery', 'squash' ]
},
{
  _id: 2,
  fruits: [ 'plums', 'kiwis', 'bananas' ],
  vegetables: [ 'broccoli', 'zucchini', 'onions' ]
}

Remover todos os itens que correspondem a uma condição `$pull` especificada

Crie a coleção profiles:

db.profiles.insertOne( { _id: 1, votes: [ 3, 5, 6, 7, 7, 8 ] } )

A operação a seguir removerá todos os itens da array votes que são maiores ou iguais a ( $gte ) 6:

db.profiles.updateOne( { _id: 1 }, { $pull: { votes: { $gte: 6 } } } )

Após a operação de atualização, o documento só apresenta valores inferiores a 6:

{ _id: 1, votes: [  3,  5 ] }

Remover itens usando `bulkWrite()`

A seguinte operação do db.collection.bulkWrite():

Cria a coleção profilesBulkWrite.
Remove todos os itens da array votes que são maiores ou iguais a ( $gte ) 6.
Remove todos os itens da array votes que são menores ou iguais a ( $lte ) 3.

try {
   db.profilesBulkWrite.bulkWrite( [
      {
         insertOne: {
            "document": { _id: 1, votes: [ 3, 5, 6, 7, 7, 8 ] }
         }
      },
      {
         updateOne: {
            "filter": { _id: 1 },
            "update": { $pull: { votes: { $gte: 6 } } }
         }
      },
      {
         updateOne: {
            "filter": { _id: 1 },
            "update": { $pull: { votes: { $lte: 3 } } }
         }
      }
   ] );
} catch (e) {
   print(e);
}

Após a operação, você pode confirmar que o documento só tem valores menores que 6 e maiores que 3:

db.profilesBulkWrite.find()

A operação retorna o seguinte:

[ { _id: 1, votes: [ 5 ] } ]

Remover itens de uma bandeja de documentos

Crie a coleção survey:

db.survey.insertMany([
   {
      _id: 1,
      results: [
         { item: "A", score: 5 },
         { item: "B", score: 8 }
      ]
   },
   {
      _id: 2,
      results: [
         { item: "C", score: 8 },
         { item: "B", score: 4 }
      ]
   }
] )

A operação a seguir remove todos os elementos da array results que contém um campo score igual a 8 e um campo item igual a "B":

db.survey.updateMany(
  { },
  { $pull: { results: { score: 8 , item: "B" } } }
)

A expressão aplica a condição para cada elemento $pull da results array como se fosse um documento de nível superior.

Após a operação, a array results não contém documentos que contenham um campo score igual a 8 e um campo item igual a "B".

{ _id: 1, results: [ { item: 'A', score: 5 } ] },
{
  _id: 2,
  results: [ { item: 'C', score: 8 }, { item: 'B', score: 4 } ]
}

O operador trata cada elemento como um objeto de nível superior.$pull $elemMatch A consulta é aplicada a cada elemento. A expressão não precisa usar para especificar condições de correspondência.

No entanto, a operação a seguir não nenhum elemento da coleção $pull original:

db.survey.updateMany(
  { },
  { $pull: { results: { $elemMatch: { score: 8 , item: "B" } } } }
)

Observação

Solte a coleção survey com:

db.survey.drop()

Em seguida, recrie-o para executar este exemplo.

Remover documentos de arrays aninhadas

Crie uma nova coleção do survey com documentos incorporados em arrays aninhados.

db.survey.drop()
db.survey.insertMany( [
   {
      _id: 1,
      results: [
         {
            item: "A",
            score: 5,
            answers: [ { q: 1, a: 4 }, { q: 2, a: 6 } ]
         },
         {
            item: "B",
            score: 8,
            answers: [ { q: 1, a: 8 }, { q: 2, a: 9 } ]
         }
      ]
   },
   {
      _id: 2,
      results: [
         {
            item: "C",
            score: 8,
            answers: [ { q: 1, a: 8 }, { q: 2, a: 7 } ]
         },
         {
            item: "B",
            score: 4,
            answers: [ { q: 1, a: 0 }, { q: 2, a: 8 } ]
         }
      ]
   }
] )

Para especificar várias condições nos elementos da array answers, use $elemMatch:

db.survey.updateMany(
  { },
  {
     $pull:
        {
           results:
              {
                 answers: { $elemMatch: { q: 2, a: { $gte: 8 } } }
              }
        }
  }
)

A operação atualizou a array results em cada documento que correspondeu. db.collection.updateMany() documentos removidos do results quando um elemento da array answers incorporada correspondia às condições de seleção na linha realçada.

{
  _id: 1,
  results: [
    {
      item: 'A',
      score: 5,
      answers: [ { q: 1, a: 4 }, { q: 2, a: 6 } ]
    }
  ]
},
{
  _id: 2,
  results: [
    {
      item: 'C',
      score: 8,
      answers: [ { q: 1, a: 8 }, { q: 2, a: 7 } ]
    }
  ]
}