Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/
Referência
/
Operadores
/
Update
/
arrays

$pull

Nesta página

  • Compatibilidade
  • Sintaxe
  • Comportamento
  • Exemplos
$pull

O operador $pull remove de uma array existente todas as instâncias de um valor ou valores que correspondem a uma condição 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 $pull tem o seguinte 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 $pull aplicará o <condition> como se cada elemento de array fosse um documento em uma coleção. Consulte Remover todos os itens que correspondem a uma condição $pull especificada com bulkWrite() para obter um exemplo.

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

Se o <value> especificado a ser removido for um documento, $pull removerá apenas os elementos da 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 ao usar um operador de atualização como $pull com uma expressão de operando vazia ( { } ). Uma atualização vazia não resulta em alteração e nenhuma entrada no oplog é criada (o que significa que é sem operação).

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 todos os itens que correspondem a uma condição $pull especificada com 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);
}

Observação

bulkWrite()

O método db.collection.bulkWrite() executa múltiplas operações de gravação listadas em uma array. Neste exemplo, o db.collection.bulkWrite() executa diversas operações na coleção profiles .

Após a operação db.collection.bulkWrite(), você pode confirmar que o documento só tem valores menores que 6 e maiores que 3 usando a seguinte operação:

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 $pull aplica a condição para cada elemento da array results 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 $pull trata cada elemento como um objeto de nível superior. A consulta é aplicada a cada elemento. A expressão não precisa usar $elemMatch para especificar condições de correspondência.

Pelo contrário, a operação a seguir não $pull (extrai) nenhum elemento da coleção original:

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

Observação

Solte a coleção survey com:

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

Em seguida, você pode especificar várias condições nos elementos da array answers com $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 } ]
    }
  ]
}

Dica

Veja também:

Voltar

$pop

Próximo

$push