Página inicial do Docs → Desenvolver aplicações → Manual do MongoDB

db.collection.updateMany()

Nesta página

Definição

Compatibilidade
Sintaxe
Controle de acesso
Comportamento
Exemplos

Definição

db.collection.updateMany(filter, update, options): Importante
Método mongosh
Esta página documenta um método mongosh . Esta não é a documentação para comandos de banco de dados ou drivers específicos de idioma, como Node.js.
Para o comando do banco de dados, consulte o comando update.
Para drivers de API do MongoDB, consulte a documentação do driver MongoDB específica do idioma.
Para a documentação de shell legada do mongo, consulte a documentação para a versão correspondente do MongoDB Server:
mongo shell v4.4
Atualiza todos os documentos que correspondem ao filtro especificado para uma collection.

Compatibilidade

Você pode utilizar o db.collection.updateMany() para implantações hospedadas nos seguintes ambientes:

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

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

Sintaxe

O método updateMany() tem o seguinte formulário:

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>        // Available starting in MongoDB 4.2.1
   }
)

Parâmetros

O método updateMany() utiliza os seguintes parâmetros:

Parâmetro

Tipo

Descrição

filtro, filtro

documento

Os critérios de seleção para a atualização. Os mesmos seletores de query que no método find() estão disponíveis.

Especifique um documento vazio { } para atualizar todos os documentos da coleção.

atualizar

documento ou pipeline

As modificações a serem aplicadas. Podem ser uma dos seguintes:


Atualizar documento	Contém somente atualizar expressões do operador. Para obter mais informações, consulte Atualizar com um documento de expressões do operador de atualização
Aggregation pipeline (começando no MongoDB 4.2)	Contém apenas os seguintes estágios de agregação: `$addFields` e seu alias `$set` `$project` e seu alias `$unset` `$replaceRoot` e seu nome alternativo `$replaceWith`. Para mais informações, consulte Atualizar com um aggregation pipeline.

Para atualizar com um documento de substituição, consulte db.collection.replaceOne().

upsert

boleano

Opcional. Quando true, updateMany() ou:

Cria um novo documento se nenhum documento corresponder a filter. Para obter mais detalhes, consulte comportamento upsert.
Atualiza documentos que correspondem ao filter.

Para evitar várias alterações, certifique-se de que os campos filter sejam indexados exclusivamente.

Padrão é false.

writeConcern

documento

Opcional. Um documento que expressa o write concern. Omitir para usar o write concern padrão.

Não defina explicitamente a preocupação de gravação para a operação se for executada em uma transação. Para usar write concern com transações, consulte Transações e write concern.

collation

documento

Opcional.

Especifica o agrupamento a ser usado para a operação.

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

A opção de agrupamento tem a seguinte sintaxe:

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

Ao especificar agrupamento, o campo locale é obrigatório; todos os outros campos de agrupamento são opcionais. Para obter descrições dos campos, consulte Documento de agrupamento.

Se o agrupamento não for especificado, mas a coleção tiver um agrupamento padrão (consulte db.createCollection()), a operação usará o agrupamento especificado para a coleção.

Se nenhum agrupamento for especificado para a collection ou para as operações, o MongoDB usa a comparação binária simples usada nas versões anteriores para comparações de strings.

Você não pode especificar vários agrupamentos para uma operação. Por exemplo, você não pode especificar agrupamentos diferentes por campo ou, se estiver realizando uma busca com uma classificação, não poderá usar um agrupamento para a busca e outro para a classificação.

arrayFilters

variedade

Opcional. Uma matriz de documentos de filtro que determina quais elementos da matriz modificar para uma operação de atualização em um campo da matriz.

No documento de upgrade, use o operador posicional filtrado $[<identifier>] para definir um identificador, que você então faz referência nos documentos do filtro de matriz. Você não pode ter um documento de filtro de matriz para um identificador se o identificador não estiver incluído no documento de atualização.

Observação

O <identifier> deve começar com uma letra minúscula e conter apenas caracteres alfanuméricos.

Você pode incluir o mesmo identificador várias vezes no documento de atualização; entretanto, para cada identificador distinto ($[identifier]) no documento de atualização, você deve especificar exatamente um documento de filtro de matriz correspondente. Ou seja, não é possível especificar vários documentos de filtro de matriz para o mesmo identificador. Por exemplo, se a instrução de atualização incluir o identificador x (possivelmente várias vezes), você não poderá especificar o seguinte para arrayFilters que inclui 2 documentos de filtro separados para x:

// INVALID
[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]

No entanto, você pode especificar condições compostas no mesmo identificador em um único documento de filtro, como nos exemplos a seguir:

// Example 1
[
  { $or: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 2
[
  { $and: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 3
[
  { "x.a": { $gt: 85 }, "x.b": { $gt: 80 } }
]

Para obter exemplos, consulte Especificar arrayFilters para uma operação de atualização de matriz.

dica

Documento ou string

Opcional. Um documento ou string que especifica o índice a ser usado para dar suporte ao predicado de query.

A opção pode usar um documento de especificação de índice ou a string do nome do índice.

Se você especificar um índice que não existe, a operação ocorrerá erros.

Para um exemplo, consulte Especificar hint para Operações de Atualização.

Novidades na versão 4.2.1.

Devoluções

O método retorna um documento que contém:

Um valor booleano acknowledged como true se a operação for executada com referência de escritarefer ou false se a referência de escrita estiver desativada
matchedCount contendo o número de documentos correspondentes
modifiedCount contendo o número de documentos modificados
upsertedId contendo o _id para o documento atualizado
upsertedCount contendo o número de documentos upserted

Controle de acesso

Em implantações executadas com authorization, o usuário deve ter acesso que inclua os seguintes privilégios:

update ação na(s) coleção(ões) especificada(s).
find ação na(s) coleção(ões) especificada(s).
insert ação na(s) coleção(s) especificada(s) se a operação resultar em um upsert.

O papel embutido readWrite fornece os privilégios exigidos.

Comportamento

updateMany() atualiza todos os documentos correspondentes na coleção que correspondem ao filter, utilizando os critérios do update para aplicar modificações.

Upsert

Se upsert: true e nenhum documento corresponder ao filter, db.collection.updateMany() cria um novo documento com base nos parâmetros filter e update .

Se você especificar upsert: true em uma coleção fragmentada, você deverá incluir a chave de shard completa no filter. Para comportamento db.collection.updateMany() adicional, consulte Coleções Fragmentadas.

Consulte Atualizar vários documentos com Upsert.

Atualizar com um Documento de Expressões do Operador de Atualização

Para a especificação de modificação, o método db.collection.updateMany() pode aceitar um documento que contém apenas expressões de operador de atualização a serem executadas.

Por exemplo:

db.collection.updateMany(
   <query>,
   { $set: { status: "D" }, $inc: { quantity: 2 } },
   ...
)

Atualize com um pipeline de agregação.

A partir do MongoDB 4.2, o método db.collection.updateMany() pode aceitar um aggregation pipeline [ <stage1>, <stage2>, ... ] que especifica as modificações a serem executadas. O pipeline pode consistir nas seguintes etapas:

$addFields e seu alias $set
$project e seu alias $unset
$replaceRoot e seu nome alternativo $replaceWith.

O uso do aggregation pipeline permite uma instrução de atualização mais expressiva, como atualizações condicionais Express com base em valores de campo atuais ou atualização de um campo usando o valor de outro(s) campo(s).

Por exemplo:

db.collection.updateMany(
   <query>,
   [
      { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
      { $unset: [ "misc1", "misc2" ] }
   ]
   ...
)

Observação

O $set e o $unset usados no pipeline referem-se aos estágios de aggregation $set e $unset, respectivamente, e não aos operadores de atualização $set e $unset.

Para obter exemplos, consulte Atualizar com o aggregation pipeline.

Capped collections

Se uma operação de atualização alterar o tamanho do documento, a operação falhará.

Coleções de Time Series

O método updateMany() está disponível para coleções de séries temporais começando no MongoDB 5.1.

Os comandos de atualização devem atender aos seguintes requisitos:

Você só pode combinar metaField ao valor do campo.
Você só pode modificar o valor do campo metaField.
Seu documento de atualização só pode conter expressões de operador de atualização.
Seu comando de atualização não deve limitar o número de documentos a serem atualizados. Defina multi: true ou use o método updateMany() .
Seu comando de atualização não deve definir upsert: true.

Coleções partilhadas

Para uma operação do db.collection.updateMany() que inclui upsert: true e está em uma coleção fragmentada, você deve incluir a chave de shard completa no filter.

Explicabilidade

updateMany() não é compatível com db.collection.explain().

Transações

db.collection.updateMany() pode ser usado dentro de transações distribuídas.

Importante

Na maioria dos casos, uma transação distribuída incorre em um custo de desempenho maior do que as gravações de um único documento, e a disponibilidade de transações distribuídas não deve substituir o design eficaz do esquema. Em muitos cenários, o modelo de dados desnormalizado (documentos e arrays incorporados) continuará a ser ideal para seus dados e casos de uso. Ou seja, para muitos cenários, modelar seus dados adequadamente minimizará a necessidade de transações distribuídas.

Para considerações adicionais sobre o uso de transações (como limite de tempo de execução e limite de tamanho do oplog), consulte também Considerações de produção.

Inserção nas Transações

Você pode criar coleção e indexes dentro de uma transaction distribuída se a transaction não for uma transação de escrita de estilhaço cruzado.

db.collection.updateMany() com upsert: true pode ser executado em uma coleção existente ou uma coleção não existente. Se for executada em uma coleção inexistente, a operação cria a coleção.

Dica

Veja também:

Crie coleções e índices em uma transação

Write concerns e transações

Não defina explicitamente a preocupação de gravação para a operação se for executada em uma transação. Para usar write concern com transações, consulte Transações e write concern.

Entradas Oplog

Se uma operação db.collection.updateMany() atualizar com êxito um ou mais documentos, a operação adicionará uma entrada no oplog (registro de operações) para cada documento atualizado. Se a operação falhar ou não encontrar nenhum documento para atualizar, a operação não adicionará uma entrada no oplog.

Exemplos

Atualizar vários documentos

A coleção restaurant contém os seguintes documentos:

{ "_id" : 1, "name" : "Central Perk Cafe", "violations" : 3 }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "violations" : 2 }
{ "_id" : 3, "name" : "Empire State Sub", "violations" : 5 }
{ "_id" : 4, "name" : "Pizza Rat's Pizzaria", "violations" : 8 }

A operação a seguir atualiza todos os documentos em que violations é maior que 4 e $set é um sinalizador para revisão:

try {
   db.restaurant.updateMany(
      { violations: { $gt: 4 } },
      { $set: { "Review" : true } }
   );
} catch (e) {
   print(e);
}

A operação retorna:

{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }

A coleção agora contém os seguintes documentos:

{ "_id" : 1, "name" : "Central Perk Cafe", "violations" : 3 }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "violations" : 2 }
{ "_id" : 3, "name" : "Empire State Sub", "violations" : 5, "Review" : true }
{ "_id" : 4, "name" : "Pizza Rat's Pizzaria", "violations" : 8, "Review" : true }

Se nenhuma correspondência for encontrada, a operação retornará:

{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }

A configuração upsert: true inseriria um documento se nenhuma correspondência fosse encontrada.

Atualização com aggregation pipeline

A partir do MongoDB 4.2, o db.collection.updateMany() pode usar um aggregation pipeline para a atualização. O pipeline pode consistir nas seguintes etapas:

$addFields e seu alias $set
$project e seu alias $unset
$replaceRoot e seu nome alternativo $replaceWith.

Exemplo 1: Atualização com Pipeline de Agregação Usando Campos Existentes

Os exemplos a seguir usam o aggregation pipeline para modificar um campo usando os valores de outros campos no documento.

Criar uma coleção students com os seguintes documentos:

db.students.insertMany( [
   { "_id" : 1, "student" : "Skye", "points" : 75, "commentsSemester1" : "great at math", "commentsSemester2" : "loses temper", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "students" : "Elizabeth", "points" : 60, "commentsSemester1" : "well behaved", "commentsSemester2" : "needs improvement", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") }
] )

Suponha que, em vez de separar os campos commentsSemester1 e commentsSemester2 , você queira reuni-los em um novo campo comments . A seguinte operação de atualização usa um pipeline de agregação para:

adicione o novo campo comments e defina o campo lastUpdate.
remova os campos commentsSemester1 e commentsSemester2 de todos os documentos da coleção.

db.students.updateMany(
   { },
   [
      { $set: { comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ]
)

Observação

O $set e o $unset usados no pipeline referem-se aos estágios de aggregation $set e $unset, respectivamente, e não aos operadores de atualização $set e $unset.

Primeira etapa

O estágio $set:

cria um novo campo de array comments cujos elementos são o conteúdo atual dos campos commentsSemester1 e commentsSemester2 e
define o campo lastUpdate para o valor da variável de agregação NOW. A variável de agregação NOW é resolvida para o valor de data e hora atual e permanece a mesma em todo o pipeline. Para acessar variáveis de agregação, prefixe a variável com cifrões duplos $$ e coloque entre aspas.

Segunda etapa

O estágio $unset remove os campos commentsSemester1 e commentsSemester2.

Após o comando, a coleção contém os seguintes documentos:

{ "_id" : 1, "student" : "Skye", "status" : "Modified", "points" : 75, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "great at math", "loses temper" ] }
{ "_id" : 2, "student" : "Elizabeth", "status" : "Modified", "points" : 60, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "well behaved", "needs improvement" ] }

Exemplo 2: Atualização com Pipeline de Agregação Usando Campos Existentes Condicionalmente

O aggregation pipeline permite que a atualização execute atualizações condicionais com base nos valores de campo atuais, bem como use valores de campo atuais para calcular um valor de campo separado.

Por exemplo, criar uma coleção students3 com os seguintes documentos:

db.students3.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2019-01-01T00:00:00Z") }
] )

Usando um aggregation pipeline, você pode atualizar os documentos com a média calculada e a nota por letra.

db.students3.updateMany(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] } , lastUpdate: "$$NOW" } },
     { $set: { grade: { $switch: {
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ]
)

Observação

O $set usado no pipeline refere-se ao estágio de aggregation $set, e não aos operadores de atualização $set.

Primeira etapa

O estágio $set:

calcula um novo campo average com base na média do campo tests. Consulte $avg para obter mais informações sobre o operador de agregação do $avg e $trunc para obter mais informações sobre o operador de agregação truncada $trunc.
define o campo lastUpdate para o valor da variável de agregação NOW. A variável de agregação NOW é resolvida para o valor de data e hora atual e permanece a mesma em todo o pipeline. Para acessar variáveis de agregação, prefixe a variável com cifrões duplos $$ e coloque entre aspas.

Segunda etapa

O estágio $set calcula um novo campo grade com base no campo average calculado no estágio anterior. Consulte $switch para obter mais informações sobre o operador de aggregation do $switch.

Após o comando, a coleção contém os seguintes documentos:

{ "_id" : 1, "tests" : [ 95, 92, 90 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 92, "grade" : "A" }
{ "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 90, "grade" : "A" }
{ "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2020-01-24T17:31:01.670Z"), "average" : 75, "grade" : "C" }

Dica

Veja também:

Atualizações com pipeline de agregação

Atualizar Vários Documentos com Inserção

A coleção inspectors contém os seguintes documentos:

{ "_id" : 92412, "inspector" : "F. Drebin", "Sector" : 1, "Patrolling" : true },
{ "_id" : 92413, "inspector" : "J. Clouseau", "Sector" : 2, "Patrolling" : false },
{ "_id" : 92414, "inspector" : "J. Clouseau", "Sector" : 3, "Patrolling" : true },
{ "_id" : 92415, "inspector" : "R. Coltrane", "Sector" : 3, "Patrolling" : false }

A operação a seguir atualiza todos os documentos com Sector maior que 4 e inspector igual a "R. Coltrane":

try {
   db.inspectors.updateMany(
      { "Sector" : { $gt : 4 }, "inspector" : "R. Coltrane" },
      { $set: { "Patrolling" : false } },
      { upsert: true }
   );
} catch (e) {
   print(e);
}

A operação retorna:

{
   "acknowledged" : true,
   "matchedCount" : 0,
   "modifiedCount" : 0,
   "upsertedId" : ObjectId("56fc5dcb39ee682bdc609b02"),
   "upsertedCount": 1
}

A coleção agora contém os seguintes documentos:

{ "_id" : 92412, "inspector" : "F. Drebin", "Sector" : 1, "Patrolling" : true },
{ "_id" : 92413, "inspector" : "J. Clouseau", "Sector" : 2, "Patrolling" : false },
{ "_id" : 92414, "inspector" : "J. Clouseau", "Sector" : 3, "Patrolling" : true },
{ "_id" : 92415, "inspector" : "R. Coltrane", "Sector" : 3, "Patrolling" : false },
{ "_id" : ObjectId("56fc5dcb39ee682bdc609b02"), "inspector" : "R. Coltrane", "Patrolling" : false }

Como nenhum documento correspondeu ao filtro, e upsert era true, updateMany() inseriu o documento com _id gerado, as condições de igualdade de filter e os modificadores update .

Atualize com referência de gravação (write concern)

Dado um conjunto de réplicas de três membros, a operação a seguir especifica um w de majority e wtimeout de 100

try {
   db.restaurant.updateMany(
       { "name" : "Pizza Rat's Pizzaria" },
       { $inc: { "violations" : 3}, $set: { "Closed" : true } },
       { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print(e);
}

Se a confirmação demorar mais que o limite wtimeout , a exceção será lançada:

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})

A tabela a seguir explica os possíveis valores de errInfo.writeConcern.provenance:

Proveniência	Descrição
`clientSupplied`	A preocupação de escrita foi especificada no aplicativo.
`customDefault`	A write concern originou-se de um valor padrão personalizado definido. Consulte `setDefaultRWConcern`.
`getLastErrorDefaults`	A write concern originada do campo `settings.getLastErrorDefaults` do conjunto de réplicas.
`implicitDefault`	A preocupação de gravação originou-se do servidor na ausência de todas as outras especificações de preocupação de gravação.

Especifique o agrupamento

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

Uma coleção myColl possui os seguintes documentos:

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

A seguinte operação inclui a opção coleção:

db.myColl.updateMany(
   { category: "cafe" },
   { $set: { status: "Updated" } },
   { collation: { locale: "fr", strength: 1 } }
);

Especificar `arrayFilters` para uma Operação de Atualização de Matriz

A partir do MongoDB 3,6, ao atualizar um campo de array, você pode especificar arrayFilters que determina quais elementos da array devem ser atualizados.

Atualizar elementos que correspondem aos critérios `arrayFilters`

Crie uma collection students com os seguintes documentos:

db.students.insertMany( [
   { "_id" : 1, "grades" : [ 95, 92, 90 ] },
   { "_id" : 2, "grades" : [ 98, 100, 102 ] },
   { "_id" : 3, "grades" : [ 95, 110, 100 ] }
] )

Para atualizar todos os elementos que são maiores ou iguais a 100 na array grades, utilize o operador posicional filtrado $[<identifier>] com a opção arrayFilters:

db.students.updateMany(
   { grades: { $gte: 100 } },
   { $set: { "grades.$[element]" : 100 } },
   { arrayFilters: [ { "element": { $gte: 100 } } ] }
)

Após a operação, a coleção contém os seguintes documentos:

{ "_id" : 1, "grades" : [ 95, 92, 90 ] }
{ "_id" : 2, "grades" : [ 98, 100, 100 ] }
{ "_id" : 3, "grades" : [ 95, 100, 100 ] }

Atualizar Elementos Específicos de uma Matriz de Documentos

Crie uma collection students2 com os seguintes documentos:

db.students2.insertMany( [
   {
      "_id" : 1,
      "grades" : [
         { "grade" : 80, "mean" : 75, "std" : 6 },
         { "grade" : 85, "mean" : 90, "std" : 4 },
         { "grade" : 85, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "grade" : 90, "mean" : 75, "std" : 6 },
         { "grade" : 87, "mean" : 90, "std" : 3 },
         { "grade" : 85, "mean" : 85, "std" : 4 }
      ]
   }
] )

Para modificar o valor do campo mean para todos os elementos da array grades onde a nota é maior ou igual a 85, use o operador posicional filtrado com $[<identifier>] o arrayFilters

db.students2.updateMany(
   { },
   { $set: { "grades.$[elem].mean" : 100 } },
   { arrayFilters: [ { "elem.grade": { $gte: 85 } } ] }
)

Após a operação, a coleção conta com os seguintes documentos:

{
   "_id" : 1,
   "grades" : [
      { "grade" : 80, "mean" : 75, "std" : 6 },
      { "grade" : 85, "mean" : 100, "std" : 4 },
      { "grade" : 85, "mean" : 100, "std" : 6 }
   ]
}
{
   "_id" : 2,
   "grades" : [
      { "grade" : 90, "mean" : 100, "std" : 6 },
      { "grade" : 87, "mean" : 100, "std" : 3 },
      { "grade" : 85, "mean" : 100, "std" : 4 }
   ]
}

Especifique `hint` para operações de atualização

Novidades na versão 4.2.1.

Criar uma coleção students de amostra com os seguintes documentos:

db.students.insertMany( [
   { "_id" : 1, "student" : "Richard", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 2, "student" : "Jane", "grade" : "A", "points" : 60,  "comments1" : "well behaved", "comments2" : "fantastic student" },
   { "_id" : 3, "student" : "Ronan", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 4, "student" : "Noah", "grade" : "D", "points" : 20,  "comments1" : "needs improvement", "comments2" : null },
   { "_id" : 5, "student" : "Adam", "grade" : "F", "points" :  0,  "comments1" : null, "comments2" : null },
   { "_id" : 6, "student" : "Henry", "grade" : "A", "points" : 86,  "comments1" : "fantastic student", "comments2" : "well behaved" }
] )

Crie os seguintes índices na coleção:

db.students.createIndex( { grade: 1 } )

A seguinte operação de atualização sugere explicitamente o uso do índice { grade: 1 }:

Observação

Se você especificar um índice que não existe, a operação ocorrerá erros.

db.students.updateMany(
   { "points": { $lte: 20 }, "grade": "F" },
   { $set: { "comments1": "failed class" } },
   { hint: { grade: 1 } }
)

O comando de atualização retorna o seguinte:

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

Para ver se o índice sugerido é usado, execute o pipeline $indexStats:

db.students.aggregate( [ { $indexStats: { } }, { $sort: { name: 1 } }, { $match: {key: { grade: 1 } } } ] )

← db.collection.updateOne()

db.collection.watch() →

Definição

Importante

Método mongosh

Compatibilidade

Sintaxe

Parâmetros

Observação

Devoluções

Controle de acesso

Comportamento

Upsert

Atualizar com um Documento de Expressões do Operador de Atualização

Atualize com um pipeline de agregação.

Observação

Capped collections

Coleções de Time Series

Coleções partilhadas

Explicabilidade

Transações

Importante

Inserção nas Transações

Dica

Veja também:

Write concerns e transações

Entradas Oplog

Exemplos

Atualizar vários documentos

Atualização com aggregation pipeline

Exemplo 1: Atualização com Pipeline de Agregação Usando Campos Existentes

Observação

Exemplo 2: Atualização com Pipeline de Agregação Usando Campos Existentes Condicionalmente

Observação

Dica

Veja também:

Atualizar Vários Documentos com Inserção

Atualize com referência de gravação (write concern)

Especifique o agrupamento

Especificar arrayFilters para uma Operação de Atualização de Matriz

Atualizar elementos que correspondem aos critérios arrayFilters

Atualizar Elementos Específicos de uma Matriz de Documentos

Especifique hint para operações de atualização

Observação

Especificar `arrayFilters` para uma Operação de Atualização de Matriz

Atualizar elementos que correspondem aos critérios `arrayFilters`

Especifique `hint` para operações de atualização