Atualize documentos

Atualizar padrão do documento

No MongoDB, os métodos de atualização seguem o mesmo padrão:

Esses métodos usam os seguintes parâmetros:

• Filtro de consulta para corresponder a um ou mais documentos para atualizar

• Atualizar documento que especifica o campo e as alterações de valor

O campo _id

Cada documento em uma coleção MongoDB tem um campo _id exclusivo e imutável. Se você tentar alterar o campo _id por meio de uma operação de atualização, o driver gerará uma WriteError e não executará atualizações.

Parâmetros

Cada método utiliza um filtro de query e um documento de atualização que inclui pelo menos um operador de atualização. O operador de atualização especifica o tipo de atualização a ser executada e inclui os campos e valores que descrevem a alteração. Atualize os documentos usando o seguinte formato:

doc! { "<update operator>": doc! { "<field>": <value> } }

Para especificar várias atualizações em um documento de atualização, use o seguinte formato:

doc! {
    "<update operator>": doc!{"<field>": <value>},
    "<update operator>": doc!{"<field>": <value>},
    ...
}

Consulte o manual do MongoDB Server para obter uma lista completa de operadores de atualização e descrições.

Valor de retorno

Os métodos update_one() e update_many() retornam um tipo UpdateResult se a operação for bem-sucedida. O tipo UpdateResult contém as seguintes propriedades que descrevem a operação:

Se vários documentos corresponderem ao filtro de query que você passa para update_one(), o método selecionará e atualizará o primeiro documento correspondente. Se nenhum documento corresponder ao filtro de query, a operação de atualização não fará alterações.

Exemplo de atualização

Os seguintes documentos descrevem os funcionários de uma empresa:

{
  "_id": ObjectId('4337'),
  "name": "Shelley Olson",
  "department": "Marketing",
  "role": "Director",
  "bonus": 3000
},
{
  "_id": ObjectId('4902'),
  "name": "Remi Ibrahim",
  "department": "Marketing",
  "role": "Consultant",
  "bonus": 1800
}

Este exemplo executa uma operação de atualização utilizando o método update_many(). O método update_many() utiliza os seguintes parâmetros:

• Filtro de query para corresponder a documentos onde o valor do campo department é "Marketing"

• documento de atualização que contém as seguintes atualizações:

  • Um operador $set para alterar o valor de department para "Business Operations" e role para "Analytics Specialist"

  • Um operador $inc para aumentar o valor de bonus em 500

let update_doc = doc! {
        "$set": doc! { "department": "Business Operations",
                      "role": "Analytics Specialist" },
        "$inc": doc! { "bonus": 500 }
};
let res = my_coll
    .update_many(doc! { "department": "Marketing" }, update_doc)
    .await?;
println!("Modified documents: {}", res.modified_count);

Modified documents: 2

Os seguintes documentos refletem as alterações resultantes da operação de atualização anterior:

{
  "_id": ObjectId('4337'),
  "name": "Shelley Olson",
  "department": "Business Operations",
  "role": "Analytics Specialist",
  "bonus": 3500
},
{
  "_id": ObjectId('4902'),
  "name": "Remi Ibrahim",
  "department": "Business Operations",
  "role": "Analytics Specialist",
  "bonus": 2300
}

Atualizar por exemplo do ObjectId

O seguinte documento descreve um funcionário de uma empresa:

{
  "_id": ObjectId('4274'),
  "name": "Jill Millerton",
  "department": "Marketing",
  "role": "Consultant"
}

Este exemplo query o documento anterior especificando um filtro de query para corresponder ao valor _id exclusivo do documento. Em seguida, o código executa uma operação de atualização com o método update_one() . O método update_one() utiliza os seguintes parâmetros:

• Filtro de query que corresponde a um documento no qual o valor do campo _id é ObjectId('4274')

• Atualizar documento que cria instruções para definir o valor de name para "Jill Gillison"

let id = ObjectId::from_str("4274").expect("Could not convert to ObjectId");
let filter_doc = doc! { "_id": id };
let update_doc = doc! {
        "$set": doc! { "name": "Jill Gillison" }
};
let res = my_coll
    .update_one(filter_doc, update_doc)
    .await?;
println!("Modified documents: {}", res.modified_count);

Modified documents: 1

O documento a seguir reflete as alterações resultantes da operação de atualização anterior:

{
  "_id": ObjectId('4274'),
  "name": "Jill Gillison",
  "department": "Marketing",
  "role": "Consultant"
}

Exemplo de arquivo completo: atualizar um documento

Este exemplo atualiza um documento na coleção restaurants do banco de dados sample_restaurants. O método update_one() adiciona o campo price ao primeiro documento no qual o valor do campo name é "Spice Market".

Você pode acessar os documentos na coleção restaurants como instâncias do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, substitua o parâmetro de tipo <T> na linha realçada por um dos seguintes valores:

• <Document>: acessa documentos de coleção como documentos BSON

• <Restaurant>: acessa documentos de coleção como instâncias da estrutura Restaurant, definidas na parte superior do código

Selecione a aba Asynchronous ou Synchronous para ver o código correspondente para cada tempo de execução:

use std::env;
use mongodb::{
    bson::{ Document, doc },
    Client,
    Collection
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    price: String,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter = doc! { "name": "Spice Market" };
    let update = doc! { "$set": doc! {"price": "$$$"} };
    let res = my_coll.update_one(filter, update).await?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

Updated documents: 1

use std::env;
use mongodb::{
    bson::{ Document, doc },
    sync::{ Client, Collection }
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    price: String,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter = doc! { "name": "Spice Market" };
    let update = doc! { "$set": doc! {"price": "$$$"} };
    let res = my_coll.update_one(filter, update).run()?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

Updated documents: 1

Exemplo de arquivo completo: atualizar vários documentos

Este exemplo atualiza um documento na coleção restaurants do banco de dados sample_restaurants. O método update_many() adiciona o campo near_me a documentos nos quais o valor do campo address.street é "Sullivan Street" e o campo borough é "Manhattan".

Você pode acessar os documentos na coleção restaurants como instâncias do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, substitua o parâmetro de tipo <T> na linha realçada por um dos seguintes valores:

• <Document>: acessa documentos de coleção como documentos BSON.

• <Restaurant>: acessa documentos de coleção como instâncias da estrutura Restaurant, definidas na parte superior do código

Selecione a guia Asynchronous ou Synchronous para ver o código correspondente para cada tempo de execução:

use std::env;
use mongodb::{ bson::doc, Client, Collection };
use bson::Document;
use serde::{ Deserialize, Serialize };
#[derive(Debug, Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
}
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: String,
    address: Address,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter =
        doc! { 
            "address.street": "Sullivan Street", 
            "borough": "Manhattan" 
        };
    let update = doc! { "$set": doc! { "near_me": true } };
    let res = my_coll.update_many(filter, update).await?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

// Your values might differ
Updated documents: 22

use std::env;
use mongodb::{
    bson::{ Document, doc },
    sync::{ Client, Collection } 
};
use serde::{ Deserialize, Serialize };
#[derive(Debug, Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
}
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: String,
    address: Address,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter =
        doc! { 
        "address.street": "Sullivan Street", 
        "borough": "Manhattan" 
    };
    let update = doc! { "$set": doc! { "near_me": true } };
    let res = my_coll.update_many(filter, update).run()?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

// Your values might differ
Updated documents: 22

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

• update_one()

• update_many()

• UpdateResult

• UpdateOptions

• WriteError