As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Operadores de atualização
<a name="mongo-apis-update-operators"></a>

Esta seção fornece informações detalhadas sobre operadores de atualização compatíveis com o Amazon DocumentDB.

**Topics**
+ [\$1](dollar-update.md)
+ [\$1[]](dollarBrackets-update.md)
+ [\$1[<identifier>]](dollarIdentifier-update.md)
+ [\$1addToSet](addToSet.md)
+ [\$1bit](bit.md)
+ [\$1currentDate](currentDate.md)
+ [\$1each](each.md)
+ [\$1inc](inc.md)
+ [\$1max](max-update.md)
+ [\$1min](min-update.md)
+ [\$1mul](mul.md)
+ [\$1pop](pop.md)
+ [\$1position](position.md)
+ [\$1pull](pull.md)
+ [\$1pullAll](pullAll.md)
+ [\$1push](push.md)
+ [\$1rename](rename.md)
+ [\$1set](set-update.md)
+ [\$1setOnInsert](setOnInsert.md)
+ [\$1slice](slice-update.md)
+ [\$1sort](sort-update.md)
+ [\$1unset](unset-update.md)

# \$1
<a name="dollar-update"></a>

O operador `$` posicional atualiza o primeiro elemento da matriz que corresponde à condição de consulta. Ele atua como um espaço reservado para a posição do elemento de matriz correspondente.

**Parâmetros**
+ `field.$`: o campo de matriz com o operador posicional para atualizar o primeiro elemento correspondente.

## Exemplo (MongoDB Shell)
<a name="dollar-update-examples"></a>

O exemplo a seguir demonstra o uso do operador `$` posicional para atualizar um elemento específico da matriz.

**Crie documentos de amostra**

```
db.inventory.insertMany([
  { _id: 1, item: "Widget", quantities: [10, 20, 30] },
  { _id: 2, item: "Gadget", quantities: [5, 15, 25] }
]);
```

**Exemplo de consulta**

```
db.inventory.updateOne(
  { _id: 1, quantities: 20 },
  { $set: { "quantities.$": 22 } }
);
```

**Saída**

```
{
  "_id" : 1,
  "item" : "Widget",
  "quantities" : [ 10, 22, 30 ]
}
```

## Exemplos de código
<a name="dollar-update-code"></a>

Para ver um exemplo de código para usar o operador `$` posicional, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('inventory');

  await collection.updateOne(
    { _id: 1, quantities: 20 },
    { $set: { "quantities.$": 22 } }
  );

  const updatedDocument = await collection.findOne({ _id: 1 });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.inventory

    collection.update_one(
        {'_id': 1, 'quantities': 20},
        {'$set': {'quantities.$': 22}}
    )

    updated_document = collection.find_one({'_id': 1})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1[]
<a name="dollarBrackets-update"></a>

O operador `$[]` all posicional atualiza todos os elementos em uma matriz. Ele é usado quando você precisa modificar cada elemento em um campo de matriz.

**Parâmetros**
+ `field.$[]`: o campo de matriz com o operador posicional all para atualizar todos os elementos.

## Exemplo (MongoDB Shell)
<a name="dollarBrackets-update-examples"></a>

O exemplo a seguir demonstra o uso do `$[]` operador para atualizar todos os elementos da matriz.

**Crie documentos de amostra**

```
db.products.insertOne({
  _id: 1,
  name: "Laptop",
  prices: [1000, 1100, 1200]
});
```

**Exemplo de consulta**

```
db.products.updateOne(
  { _id: 1 },
  { $inc: { "prices.$[]": 50 } }
);
```

**Saída**

```
{
  "_id" : 1,
  "name" : "Laptop",
  "prices" : [ 1050, 1150, 1250 ]
}
```

## Exemplos de código
<a name="dollarBrackets-update-code"></a>

Para ver um exemplo de código para usar o `$[]` operador, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('products');

  await collection.updateOne(
    { _id: 1 },
    { $inc: { "prices.$[]": 50 } }
  );

  const updatedDocument = await collection.findOne({ _id: 1 });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.products

    collection.update_one(
        {'_id': 1},
        {'$inc': {'prices.$[]': 50}}
    )

    updated_document = collection.find_one({'_id': 1})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1[<identifier>]
<a name="dollarIdentifier-update"></a>

O operador posicional `$[<identifier>]` filtrado atualiza todos os elementos da matriz que correspondem às condições de filtro especificadas. Ele é usado com a `arrayFilters` opção de atualizar seletivamente os elementos da matriz.

**Parâmetros**
+ `field.$[identifier]`: o campo de matriz com o operador posicional filtrado.
+ `arrayFilters`: uma matriz de condições de filtro que determinam quais elementos atualizar.

## Exemplo (MongoDB Shell)
<a name="dollarIdentifier-update-examples"></a>

O exemplo a seguir demonstra o uso do `$[<identifier>]` operador para atualizar elementos específicos da matriz com base em uma condição.

**Crie documentos de amostra**

```
db.students.insertOne({
  _id: 1,
  name: "Alice",
  grades: [
    { subject: "Math", score: 85 },
    { subject: "Science", score: 92 },
    { subject: "History", score: 78 }
  ]
});
```

**Exemplo de consulta**

```
db.students.updateOne(
  { _id: 1 },
  { $inc: { "grades.$[elem].score": 5 } },
  { arrayFilters: [{ "elem.score": { $gte: 80 } }] }
);
```

**Saída**

```
{
  "_id" : 1,
  "name" : "Alice",
  "grades" : [
    { "subject" : "Math", "score" : 90 },
    { "subject" : "Science", "score" : 97 },
    { "subject" : "History", "score" : 78 }
  ]
}
```

## Exemplos de código
<a name="dollarIdentifier-update-code"></a>

Para ver um exemplo de código para usar o `$[<identifier>]` operador, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('students');

  await collection.updateOne(
    { _id: 1 },
    { $inc: { "grades.$[elem].score": 5 } },
    { arrayFilters: [{ "elem.score": { $gte: 80 } }] }
  );

  const updatedDocument = await collection.findOne({ _id: 1 });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.students

    collection.update_one(
        {'_id': 1},
        {'$inc': {'grades.$[elem].score': 5}},
        array_filters=[{'elem.score': {'$gte': 80}}]
    )

    updated_document = collection.find_one({'_id': 1})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1addToSet
<a name="addToSet"></a>

O `$addToSet` operador no Amazon DocumentDB é usado para adicionar um valor a uma matriz somente se o valor ainda não estiver presente na matriz. Isso é útil para garantir que uma matriz contenha elementos exclusivos.

**Parâmetros**
+ `field`: O campo a ser atualizado.
+ `value`: o valor a ser adicionado ao campo da matriz. Isso pode ser um valor único ou uma expressão.

## Exemplo (MongoDB Shell)
<a name="addToSet-examples"></a>

O exemplo a seguir demonstra como usar o `$addToSet` operador para adicionar elementos exclusivos a uma matriz.

**Crie documentos de amostra**

```
db.products.insertMany([
  { "_id": 1, "item": "apple", "tags": ["fruit", "red", "round"] },
  { "_id": 2, "item": "banana", "tags": ["fruit", "yellow"] },
  { "_id": 3, "item": "cherry", "tags": ["fruit", "red"] }
])
```

**Exemplo de consulta**

```
db.products.update(
  { "item": "apple" },
  { $addToSet: { "tags": "green" } }
)
```

**Saída**

```
{ "_id": 1, "item": "apple", "tags": ["fruit", "red", "round", "green"] }
```

Neste exemplo, o `$addToSet` operador adiciona a tag “verde” à matriz “tags” do documento em que o campo “item” é “maçã”. Como “verde” ainda não estava na matriz, ele foi adicionado.

## Exemplos de código
<a name="addToSet-code"></a>

Para ver um exemplo de código para usar o `$addToSet` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('products');

  await collection.updateOne(
    { "item": "apple" },
    { $addToSet: { "tags": "green" } }
  );

  const updatedDoc = await collection.findOne({ "item": "apple" });
  console.log(updatedDoc);

  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.products

    collection.update_one(
        {"item": "apple"},
        {"$addToSet": {"tags": "green"}}
    )

    updated_doc = collection.find_one({"item": "apple"})
    print(updated_doc)

    client.close()

example()
```

------

# \$1bit
<a name="bit"></a>

O `$bit` operador no Amazon DocumentDB permite que você execute operações bit a bit nos bits de um determinado campo. Isso pode ser útil para tarefas como definir, limpar ou verificar o estado de bits individuais em um número.

**Parâmetros**
+ `field`: O campo no qual realizar operações bit a bit.
+ `and`: um valor inteiro usado para realizar uma operação AND bit a bit no campo.
+ `or`: um valor inteiro usado para realizar uma operação OR bit a bit no campo.
+ `xor`: um valor inteiro usado para realizar uma operação XOR bit a bit no campo.

## Exemplo (MongoDB Shell)
<a name="bit-examples"></a>

O exemplo a seguir demonstra como usar o `$bit` operador para realizar operações bit a bit em um campo numérico.

**Crie documentos de amostra**

```
db.numbers.insert([
  { "_id": 1, "number": 5 },
  { "_id": 2, "number": 12 }
])
```

**Exemplo de consulta**

```
db.numbers.update(
  { "_id": 1 },
  { "$bit": { "number": { "and": 3 } } }
)
```

**Saída**

```
{
  "_id": 1,
  "number": 1
}
```

Neste exemplo, o `$bit` operador é usado para realizar uma operação AND bit a bit no campo “número” do documento com o `_id` de 1. O resultado é que o valor do campo “número” é definido como 1, que é o resultado da operação AND bit a bit entre o valor original de 5 e o valor 3.

## Exemplos de código
<a name="bit-code"></a>

Para ver um exemplo de código para usar o `$bit` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function main() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('numbers');

  await collection.updateOne(
    { "_id": 1 },
    { "$bit": { "number": { "and": 3 } } }
  );

  const result = await collection.findOne({ "_id": 1 });
  console.log(result);

  await client.close();
}

main();
```

------
#### [ Python ]

```
from pymongo import MongoClient

client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['numbers']

collection.update_one(
    {"_id": 1},
    {"$bit": {"number": {"and": 3}}}
)

result = collection.find_one({"_id": 1})
print(result)

client.close()
```

------

# \$1currentDate
<a name="currentDate"></a>

O `$currentDate` operador é usado para definir o valor de um campo para a data e a hora atuais. Esse operador é útil para atualizar automaticamente um campo com o carimbo de data/hora atual quando um documento é inserido ou atualizado.

**Parâmetros**
+ `field`: o campo a ser atualizado com a data e a hora atuais.
+ `type`: (opcional) Especifica o tipo de BSON a ser usado na data atual. Pode ser `date` ou `timestamp`.

## Exemplo (MongoDB Shell)
<a name="currentDate-examples"></a>

O exemplo a seguir demonstra como usar o `$currentDate` operador para definir o `lastModified` campo com a data e a hora atuais quando um novo documento é inserido.

**Crie documentos de amostra**

```
db.users.insert({
  name: "John Doe",
  email: "john.doe@example.com"
})
```

**Exemplo de consulta**

```
db.users.updateOne(
  { name: "John Doe" },
  { $currentDate: { lastModified: true } }
)
```

**Exibir documento atualizado**

```
db.users.findOne({ name: "John Doe" })
```

**Saída**

```
{
  _id: ObjectId('...'),
  name: 'John Doe',
  email: 'john.doe@example.com',
  lastModified: ISODate('2025-10-25T22:50:29.963Z')
}
```

## Exemplos de código
<a name="currentDate-code"></a>

Para ver um exemplo de código para usar o `$currentDate` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateUserWithCurrentDate() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const users = db.collection('users');

  await users.updateOne(
    { name: 'John Doe' },
    { $currentDate: { lastModified: true } }
  );

  console.log('User updated with current date');
  client.close();
}

updateUserWithCurrentDate();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_user_with_current_date():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    users = db.users

    result = users.update_one(
        {'name': 'John Doe'},
        {'$currentDate': {'lastModified': True}}
    )

    print('User updated with current date')
    client.close()

update_user_with_current_date()
```

------

# \$1each
<a name="each"></a>

O `$each` operador é usado em conjunto com outros operadores de atualização, como `$push` e`$addToSet`, para adicionar vários valores a um campo de matriz. Ele permite adicionar vários elementos a uma matriz em uma única operação, em vez de precisar executar várias operações de atualização.

**Parâmetros**
+ `value`: a matriz de valores a serem adicionados ao campo da matriz.

## Exemplo (MongoDB Shell)
<a name="each-examples"></a>

O exemplo a seguir demonstra o uso do `$each` operador com o `$push` operador para adicionar vários elementos a um campo de matriz.

**Crie documentos de amostra**

```
db.fruits.insertOne({
  _id: 1,
  fruits: ["apple", "banana"]
})
```

**Exemplo de consulta**

```
db.fruits.updateOne(
  { _id: 1 },
  { $push: { fruits: { $each: ["cherry", "durian", "elderberry"] } } }
)
```

**Exibir documento atualizado**

```
db.fruits.findOne({ _id: 1 })
```

**Saída**

```
{
  _id: 1,
  fruits: [ 'apple', 'banana', 'cherry', 'durian', 'elderberry' ]
}
```

## Exemplos de código
<a name="each-code"></a>

Para ver um exemplo de código para usar o `$each` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('fruits');

  await collection.updateOne(
    { _id: 1 },
    { $push: { fruits: { $each: ["cherry", "durian", "elderberry"] } } }
  );

  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['fruits']

    collection.update_one(
        {'_id': 1},
        {'$push': {'fruits': {'$each': ['cherry', 'durian', 'elderberry']}}}
    )

    client.close()

example()
```

------

# \$1inc
<a name="inc"></a>

O `$inc` operador é usado para incrementar o valor de um campo em um valor especificado. Ele é usado para atualizar um campo numérico, como um contador ou uma classificação, sem precisar recuperar o valor atual, calcular o novo valor e, em seguida, atualizar o campo.

**Parâmetros**
+ `field`: o nome do campo a ser incrementado.
+ `amount`: o valor pelo qual incrementar o campo. Isso pode ser um valor positivo ou negativo.

## Exemplo (MongoDB Shell)
<a name="inc-examples"></a>

O exemplo a seguir demonstra como usar o `$inc` operador para incrementar o `age` campo de um documento.

**Crie documentos de amostra**

```
db.users.insertOne({_id: 123, name: "John Doe", age: 30})
```

**Exemplo de consulta**

```
db.users.updateOne({_id: 123}, {$inc: {age: 1}})
```

**Exibir documento atualizado**

```
db.users.findOne({_id: 123})
```

**Saída**

```
{ "_id" : 123, "name" : "John Doe", "age" : 31 }
```

## Exemplos de código
<a name="inc-code"></a>

Para ver um exemplo de código para usar o `$inc` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateWithInc() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('users');

  const result = await collection.updateOne(
    { _id: 123 },
    { $inc: { age: 1 } }
  );

  console.log(result);

  await client.close();
}

updateWithInc();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_with_inc():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['users']

    result = collection.update_one(
        {'_id': 123},
        {'$inc': {'age': 1}}
    )

    print(result.modified_count)

    client.close()

update_with_inc()
```

------

# \$1max
<a name="max-update"></a>

O operador de `$max` atualização atualiza o valor de um campo somente se o valor especificado for maior que o valor do campo atual. Esse operador é útil para manter valores máximos em todas as atualizações.

**Parâmetros**
+ `field`: O campo a ser atualizado.
+ `value`: o valor a ser comparado com o valor do campo atual.

## Exemplo (MongoDB Shell)
<a name="max-update-examples"></a>

O exemplo a seguir demonstra o uso do `$max` operador para atualizar a pontuação mais alta registrada para um jogador.

**Crie documentos de amostra**

```
db.scores.insertMany([
  { _id: 1, player: "Alice", highScore: 85 },
  { _id: 2, player: "Bob", highScore: 92 },
  { _id: 3, player: "Charlie", highScore: 78 }
])
```

**Exemplo de atualização**

```
db.scores.updateOne(
  { _id: 1 },
  { $max: { highScore: 95 } }
)
```

**Resultado**

O `highScore` campo para Alice é atualizado para 95 porque 95 é maior que o valor atual de 85.

```
{ "_id": 1, "player": "Alice", "highScore": 95 }
```

## Exemplos de código
<a name="max-update-code"></a>

Para ver um exemplo de código para usar o `$max` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('scores');

  const result = await collection.updateOne(
    { _id: 1 },
    { $max: { highScore: 95 } }
  );

  console.log(result);
  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['scores']

    result = collection.update_one(
        { '_id': 1 },
        { '$max': { 'highScore': 95 } }
    )

    print(result)
    client.close()

example()
```

------

# \$1min
<a name="min-update"></a>

O operador de `$min` atualização atualiza o valor de um campo somente se o valor especificado for menor que o valor do campo atual. Esse operador é útil para manter valores mínimos em todas as atualizações.

**Parâmetros**
+ `field`: O campo a ser atualizado.
+ `value`: o valor a ser comparado com o valor do campo atual.

## Exemplo (MongoDB Shell)
<a name="min-update-examples"></a>

O exemplo a seguir demonstra o uso do `$min` operador para atualizar a temperatura mais baixa registrada para uma estação meteorológica.

**Crie documentos de amostra**

```
db.weather.insertMany([
  { _id: 1, station: "Station A", lowestTemp: 15 },
  { _id: 2, station: "Station B", lowestTemp: 20 },
  { _id: 3, station: "Station C", lowestTemp: 18 }
])
```

**Exemplo de atualização**

```
db.weather.updateOne(
  { _id: 1 },
  { $min: { lowestTemp: 12 } }
)
```

**Resultado**

O `lowestTemp` campo da Estação A é atualizado para 12 porque 12 é menor que o valor atual de 15.

```
{ "_id": 1, "station": "Station A", "lowestTemp": 12 }
```

## Exemplos de código
<a name="min-update-code"></a>

Para ver um exemplo de código para usar o `$min` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('weather');

  const result = await collection.updateOne(
    { _id: 1 },
    { $min: { lowestTemp: 12 } }
  );

  console.log(result);
  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['weather']

    result = collection.update_one(
        { '_id': 1 },
        { '$min': { 'lowestTemp': 12 } }
    )

    print(result)
    client.close()

example()
```

------

# \$1mul
<a name="mul"></a>

O `$mul` operador no Amazon DocumentDB é usado para multiplicar o valor de um campo por um número especificado. Isso pode ser útil para atualizar vários documentos de forma atômica e consistente, como atualizar milhas de voo com base no status do cartão de crédito.

**Parâmetros**
+ `field`: O campo a ser multiplicado.
+ `multiplier`: o número pelo qual multiplicar o valor do campo.

## Exemplo (MongoDB Shell)
<a name="mul-examples"></a>

Este exemplo demonstra como usar o `$mul` operador para dobrar o `flight_miles` valor de todos os documentos em que o `credit_card` campo está`true`.

**Crie documentos de amostra**

```
db.miles.insertMany([
  { "_id": 1, "member_since": new Date("1987-01-01"), "credit_card": false, "flight_miles": [1205, 2560, 880] },
  { "_id": 2, "member_since": new Date("1982-01-01"), "credit_card": true, "flight_miles": [2410, 5120, 1780, 5560] },
  { "_id": 3, "member_since": new Date("1999-01-01"), "credit_card": true, "flight_miles": [2410, 1760] }
]);
```

**Exemplo de consulta**

```
db.miles.update(
  { "credit_card": { "$eq": true } },
  { "$mul": { "flight_miles.$[]": NumberInt(2) } },
  { "multi": true }
);
```

**Saída**

```
{ "_id" : 1, "member_since" : ISODate("1987-01-01T00:00:00Z"), "credit_card" : false, "flight_miles" : [ 1205, 2560, 880 ] }
{ "_id" : 2, "member_since" : ISODate("1982-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 4820, 10240, 3560, 11120 ] }
{ "_id" : 3, "member_since" : ISODate("1999-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 4820, 3520 ] }
```

Para os clientes que têm cartão de crédito, suas milhas de voo foram dobradas.

O operador de matriz `$[]` posicional é usado para aplicar a `$mul` operação a cada elemento na `flight_miles` matriz.

## Exemplos de código
<a name="mul-code"></a>

Para ver um exemplo de código para usar o `$mul` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateFlightMiles() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('miles');

  await collection.updateMany(
    { credit_card: true },
    { $mul: { 'flight_miles.$[]': 2 } }
  );

  const documents = await collection.find().toArray();
  console.log(documents);

  await client.close();
}

updateFlightMiles();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_flight_miles():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.miles

    collection.update_many(
        {'credit_card': True},
        {'$mul': {'flight_miles.$[]': 2}}
    )

    documents = list(collection.find())
    print(documents)

    client.close()

update_flight_miles()
```

------

# \$1pop
<a name="pop"></a>

O `$pop` operador no Amazon DocumentDB é usado para remover o primeiro ou o último elemento de um campo de matriz. É particularmente útil quando você precisa manter uma matriz de tamanho fixo ou implementar uma estrutura de dados semelhante a uma fila em um documento.

**Parâmetros**
+ `field`: o nome do campo de matriz do qual remover um elemento.
+ `value`: um valor inteiro que determina a posição do elemento a ser removido. Um valor de `1` remove o último elemento, enquanto um valor de `-1` remove o primeiro elemento.

## Exemplo (MongoDB Shell)
<a name="pop-examples"></a>

Este exemplo demonstra como usar o `$pop` operador para remover o primeiro e o último elementos de um campo de matriz.

**Crie documentos de amostra**

```
db.users.insertMany([
  { "_id": 1, "name": "John Doe", "hobbies": ["reading", "swimming", "hiking"] },
  { "_id": 2, "name": "Jane Smith", "hobbies": ["cooking", "gardening", "painting"] }
])
```

**Exemplo de consulta**

```
// Remove the first element from the "hobbies" array
db.users.update({ "_id": 1 }, { $pop: { "hobbies": -1 } })

// Remove the last element from the "hobbies" array
db.users.update({ "_id": 2 }, { $pop: { "hobbies": 1 } })
```

**Saída**

```
{ "_id" : 1, "name" : "John Doe", "hobbies" : [ "swimming", "hiking" ] }
{ "_id" : 2, "name" : "Jane Smith", "hobbies" : [ "cooking", "gardening" ] }
```

## Exemplos de código
<a name="pop-code"></a>

Para ver um exemplo de código para usar o `$pop` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('users');

  // Remove the first element from the "hobbies" array
  await collection.updateOne({ "_id": 1 }, { $pop: { "hobbies": -1 } });

  // Remove the last element from the "hobbies" array
  await collection.updateOne({ "_id": 2 }, { $pop: { "hobbies": 1 } });

  const users = await collection.find().toArray();
  console.log(users);

  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['users']

    # Remove the first element from the "hobbies" array
    collection.update_one({"_id": 1}, {"$pop": {"hobbies": -1}})

    # Remove the last element from the "hobbies" array
    collection.update_one({"_id": 2}, {"$pop": {"hobbies": 1}})

    users = list(collection.find())
    print(users)

    client.close()

example()
```

------

# \$1position
<a name="position"></a>

O `$position` modificador no Amazon DocumentDB especifica a localização na matriz na qual `$push` o operador insere elementos. Sem o `$position` modificador, o `$push` operador insere elementos no final da matriz.

**Parâmetros**
+ `field`: o campo de matriz a ser atualizado.
+ `num`: a posição na matriz em que os elementos devem ser inseridos, com base na indexação com base em zero.

**Nota**: Para usar o `$position` modificador, ele deve aparecer com o `$each` modificador.

## Exemplo (MongoDB Shell)
<a name="position-examples"></a>

O exemplo a seguir demonstra como usar o `$position` operador para inserir tarefas em posições específicas em um sistema de gerenciamento de projetos.

**Crie documentos de amostra**

```
db.projects.insertOne({ "_id": 1, "name": "Website Redesign", "tasks": ["Design mockups"] })
```

**Exemplo de consulta 1 - Adicione tarefas urgentes no início**

```
db.projects.updateOne(
   { _id: 1 },
   {
     $push: {
        tasks: {
           $each: ["Security audit", "Performance review"],
           $position: 0
        }
     }
   }
)
```

**Saída 1**

```
{ "_id": 1, "name": "Website Redesign", "tasks": ["Security audit", "Performance review", "Design mockups"] }
```

**Exemplo de consulta 2 - Adicionar tarefas em uma posição específica**

```
db.projects.insertOne({ "_id": 2, "name": "Mobile App", "tasks": ["Setup project", "Create wireframes", "Deploy to store"] })

db.projects.updateOne(
   { _id: 2 },
   {
     $push: {
        tasks: {
           $each: ["Code review", "Testing phase"],
           $position: 2
        }
     }
   }
)
```

**Saída 2**

```
{ "_id": 2, "name": "Mobile App", "tasks": ["Setup project", "Create wireframes", "Code review", "Testing phase", "Deploy to store"] }
```

## Exemplos de código
<a name="position-code"></a>

Para ver um exemplo de código para usar o `$position` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function insertTasksAtPosition() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('projects');

  await collection.updateOne(
    { _id: 1 },
    {
      $push: {
        tasks: {
          $each: ["Security audit", "Performance review"],
          $position: 0
        }
      }
    }
  );

  const updatedProject = await collection.findOne({ _id: 1 });
  console.log(updatedProject);

  await client.close();
}

insertTasksAtPosition();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def insert_tasks_at_position():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['projects']

    result = collection.update_one(
        {'_id': 1},
        {
            '$push': {
                'tasks': {
                    '$each': ['Security audit', 'Performance review'],
                    '$position': 0
                }
            }
        }
    )

    updated_project = collection.find_one({'_id': 1})
    print(updated_project)

    client.close()

insert_tasks_at_position()
```

------

# \$1pull
<a name="pull"></a>

O `$pull` operador é usado para remover de uma matriz todas as instâncias de um valor ou valores que correspondam a uma condição especificada. Esse operador é útil quando você precisa remover elementos específicos de um campo de matriz em um documento.

**Parâmetros**
+ `field`: o nome do campo de matriz do qual remover o (s) valor (es).
+ `value`: o valor ou condição que determina quais elementos devem ser removidos da matriz.

## Exemplo (MongoDB Shell)
<a name="pull-examples"></a>

O exemplo a seguir demonstra como usar o `$pull` operador para remover elementos de um campo de matriz.

**Crie documentos de amostra**

```
db.restaurants.insertMany([
  {
    name: "Pizza Hut",
    cuisine: "Italian",
    features: ["Delivery", "Takeout", "Dine-in"]
  },
  {
    name: "Sushi Saito",
    cuisine: "Japanese",
    features: ["Dine-in", "Private Dining"]
  },
  {
    name: "Taco Bell",
    cuisine: "Mexican",
    features: ["Delivery", "Takeout", "Drive-thru"]
  }
])
```

**Exemplo de consulta**

```
db.restaurants.updateMany(
  { cuisine: "Italian" },
  { $pull: { features: "Takeout" } }
)
```

**Saída**

```
{
  "acknowledged" : true,
  "matchedCount" : 1,
  "modifiedCount" : 1
}
```

A consulta acima remove o recurso “Takeout” de todos os documentos em que o `cuisine` campo é “italiano”.

## Exemplos de código
<a name="pull-code"></a>

Para ver um exemplo de código para usar o `$pull` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateRestaurants() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const restaurants = db.collection('restaurants');

  await restaurants.updateMany(
    { cuisine: 'Italian' },
    { $pull: { features: 'Takeout' } }
  );

  const updatedRestaurants = await restaurants.find({}).toArray();
  console.log(updatedRestaurants);

  await client.close();
}

updateRestaurants();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_restaurants():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    restaurants = db.restaurants

    result = restaurants.update_many(
        { 'cuisine': 'Italian' },
        { '$pull': { 'features': 'Takeout' } }
    )

    updated_restaurants = list(restaurants.find({}))
    print(updated_restaurants)

    client.close()

update_restaurants()
```

------

# \$1pullAll
<a name="pullAll"></a>

O `$pullAll` operador no Amazon DocumentDB é usado para remover todas as instâncias dos valores especificados de um campo de matriz. Isso é particularmente útil quando você precisa remover vários elementos de uma matriz em uma única operação.

**Parâmetros**
+ `field`: o nome do campo de matriz do qual remover os elementos.
+ `value`: uma matriz de valores a serem removidos do campo da matriz.

## Exemplo (MongoDB Shell)
<a name="pullAll-examples"></a>

O exemplo a seguir demonstra como usar o `$pullAll` operador para remover vários elementos de um campo de matriz.

**Crie documentos de amostra**

```
db.restaurants.insert([
  {
    "name": "Taj Mahal",
    "cuisine": "Indian",
    "features": ["Private Dining", "Live Music"]
  },
  {
    "name": "Golden Palace",
    "cuisine": "Chinese",
    "features": ["Private Dining", "Takeout"]
  },
  {
    "name": "Olive Garden",
    "cuisine": "Italian",
    "features": ["Private Dining", "Outdoor Seating"]
  }
])
```

**Exemplo de consulta**

```
db.restaurants.update(
  { "name": "Taj Mahal" },
  { $pullAll: { "features": ["Private Dining", "Live Music"] } }
)
```

**Saída**

```
{
  "name": "Taj Mahal",
  "cuisine": "Indian",
  "features": []
}
```

## Exemplos de código
<a name="pullAll-code"></a>

Para ver um exemplo de código para usar o `$pullAll` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function main() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('restaurants');

  await collection.updateMany(
    { "name": "Taj Mahal" },
    { $pullAll: { "features": ["Private Dining", "Live Music"] } }
  );

  const updatedDocument = await collection.findOne({ "name": "Taj Mahal" });
  console.log(updatedDocument);

  await client.close();
}

main();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def main():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['restaurants']

    collection.update_many(
        {"name": "Taj Mahal"},
        {"$pullAll": {"features": ["Private Dining", "Live Music"]}}
    )

    updated_document = collection.find_one({"name": "Taj Mahal"})
    print(updated_document)

    client.close()

if __name__ == '__main__':
    main()
```

------

# \$1push
<a name="push"></a>

O `$push` operador no Amazon DocumentDB é usado para adicionar um item a um campo de matriz em um documento. Esse operador é particularmente útil quando você precisa acrescentar novos dados a uma matriz existente sem sobrescrever a matriz inteira.

**Parâmetros**
+ `field`: o nome do campo de matriz ao qual o novo elemento deve ser adicionado.
+ `value`: o valor a ser adicionado à matriz.
+ `position`: (opcional) Um modificador que especifica a posição na matriz em que o novo elemento deve ser adicionado. Os modificadores compatíveis incluem `$` (adicionar ao final da matriz) e `$[]` (adicionar ao final da matriz, ignorando quaisquer filtros da matriz).

## Exemplo (MongoDB Shell)
<a name="push-examples"></a>

O exemplo a seguir demonstra como usar o `$push` operador para adicionar novos elementos a um campo de matriz em um documento.

**Crie documentos de amostra**

```
db.users.insert([
  { _id: 1, name: "John Doe", hobbies: ["reading", "swimming"] },
  { _id: 2, name: "Jane Smith", hobbies: ["gardening", "cooking"] }
])
```

**Exemplo de consulta**

```
db.users.updateOne(
  { _id: 1 },
  { $push: { hobbies: "hiking" } }
)
```

**Saída**

```
{
  "acknowledged" : true,
  "matchedCount" : 1,
  "modifiedCount" : 1
}
```

Depois de executar a atualização, o documento com `_id: 1` terá a `hobbies` matriz atualizada para`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

## Exemplos de código
<a name="push-code"></a>

Para ver um exemplo de código para usar o `$push` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('users');

  const result = await collection.updateOne(
    { _id: 1 },
    { $push: { hobbies: "hiking" } }
  );

  console.log(result);
  client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['users']

    result = collection.update_one(
        {'_id': 1},
        {'$push': {'hobbies': 'hiking'}}
    )

    print(result.raw_result)
    client.close()

update_document()
```

------

# \$1rename
<a name="rename"></a>

O `$rename` operador no Amazon DocumentDB é usado para renomear um campo em um documento. Esse operador pode ser particularmente útil quando você precisa atualizar a estrutura de seus documentos ou alinhá-los com novos modelos de dados.

**Parâmetros**
+ `field`: O campo a ser renomeado.
+ `newName`: o novo nome do campo.

## Exemplo (MongoDB Shell)
<a name="rename-examples"></a>

O exemplo a seguir demonstra como usar o `$rename` operador para renomear o `&quot;Date.DoW&quot;` campo para `&quot;Date.DayOfWeek&quot;` em um documento com o `&quot;DocName&quot;` campo definido como. `&quot;Document 1&quot;`

**Crie documentos de amostra**

```
db.example.insertOne({
    "DocName": "Document 1",
    "Date": {
        "Month": 4,
        "Day": 18,
        "Year": 1987,
        "DoW": "Saturday"
    },
    "Words": 2482
})
```

**Exemplo de consulta**

```
db.example.update(
    { "DocName": "Document 1" },
    { $rename: { "Date.DoW": "Date.DayOfWeek" } }
)
```

**Saída**

```
{
    "DocName": "Document 1",
    "Date": {
        "Month": 4,
        "Day": 18,
        "Year": 1987,
        "DayOfWeek": "Saturday"
    },
    "Words": 2482
}
```

## Exemplos de código
<a name="rename-code"></a>

Para ver um exemplo de código para usar o `$rename` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
    const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
    const db = client.db('test');
    const collection = db.collection('example');

    await collection.updateOne(
        { "DocName": "Document 1" },
        { $rename: { "Date.DoW": "Date.DayOfWeek" } }
    );

    const updatedDoc = await collection.findOne({ "DocName": "Document 1" });
    console.log(updatedDoc);

    await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['example']

    collection.update_one(
        {"DocName": "Document 1"},
        {"$rename": {"Date.DoW": "Date.DayOfWeek"}}
    )

    updated_doc = collection.find_one({"DocName": "Document 1"})
    print(updated_doc)

    client.close()

example()
```

------

# \$1set
<a name="set-update"></a>

O `$set` operador no Amazon DocumentDB é usado para atualizar o valor de um campo especificado em um documento. Esse operador permite que você adicione novos campos ou modifique os existentes em um documento. É um operador de atualização fundamental no driver Java do MongoDB, compatível com o Amazon DocumentDB.

**Parâmetros**
+ `field`: O campo a ser atualizado.
+ `value`: o novo valor do campo.

## Exemplo (MongoDB Shell)
<a name="set-examples"></a>

O exemplo a seguir demonstra como usar o `$set` operador para atualizar o `Item` campo em um documento.

**Crie documentos de amostra**

```
db.example.insert([
  {
    "Item": "Pen",
    "Colors": ["Red", "Green", "Blue", "Black"],
    "Inventory": {
      "OnHand": 244,
      "MinOnHand": 72
    }
  },
  {
    "Item": "Poster Paint",
    "Colors": ["Red", "Green", "Blue", "White"],
    "Inventory": {
      "OnHand": 120,
      "MinOnHand": 36
    }
  }
])
```

**Exemplo de consulta**

```
db.example.update(
  { "Item": "Pen" },
  { $set: { "Item": "Gel Pen" } }
)
```

**Saída**

```
{
  "Item": "Gel Pen",
  "Colors": ["Red", "Green", "Blue", "Black"],
  "Inventory": {
    "OnHand": 244,
    "MinOnHand": 72
  }
}
```

## Exemplos de código
<a name="set-code"></a>

Para ver um exemplo de código para usar o `$set` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('example');

  await collection.updateOne(
    { "Item": "Pen" },
    { $set: { "Item": "Gel Pen" } }
  );

  const updatedDocument = await collection.findOne({ "Item": "Gel Pen" });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.example

    collection.update_one(
        {"Item": "Pen"},
        {"$set": {"Item": "Gel Pen"}}
    )

    updated_document = collection.find_one({"Item": "Gel Pen"})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1setOnInsert
<a name="setOnInsert"></a>

O `$setOnInsert` operador no Amazon DocumentDB é usado para definir o valor de um campo se um documento estiver sendo inserido, mas não terá efeito se o documento estiver sendo atualizado.

**Parâmetros**
+ `field`: O campo a ser definido.
+ `value`: o valor a ser atribuído ao campo.

## Exemplo (MongoDB Shell)
<a name="setOnInsert-examples"></a>

O exemplo a seguir demonstra o uso do `$setOnInsert` operador no Amazon DocumentDB. Ele cria um novo documento se o documento ainda não existir, mas não tem efeito se o documento estiver sendo atualizado.

**Crie documentos de amostra**

```
db.users.insertOne({
  _id: 1,
  name: "John Doe",
  age: 30
})
```

**Exemplo de consulta 1 - Atualizar documento existente**

```
db.users.update(
  { _id: 1 },
  {
    $set: { age: 31 },
    $setOnInsert: { createdAt: new Date() }
  },
  { upsert: true }
)
```

**Saída 1**

```
{
  _id: 1,
  name: "John Doe",
  age: 31
}
```

A saída mostra que o documento foi atualizado, mas o `createdAt` campo **NÃO foi adicionado** porque o documento já existia. O `$setOnInsert` operador só se aplica ao inserir novos documentos.

**Exemplo de consulta 2 - Inserir novo documento (upsert)**

```
db.users.update(
  { _id: 2 },
  {
    $set: { name: "Jane Smith", age: 25 },
    $setOnInsert: { createdAt: new Date() }
  },
  { upsert: true }
)
```

**Saída 2**

```
{
  _id: 2,
  name: "Jane Smith", 
  age: 25,
  createdAt: ISODate("2025-10-31T09:57:52.459Z")
}
}
```

## Exemplos de código
<a name="setOnInsert-code"></a>

Para ver um exemplo de código para usar o `$setOnInsert` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateWithSetOnInsert() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const users = db.collection('users');

  await users.updateOne(
    { _id: 1 },
    {
      $set: { age: 31 },
      $setOnInsert: { createdAt: new Date() }
    },
    { upsert: true }
  );

  const updatedUser = await users.findOne({ _id: 1 });
  console.log(updatedUser);

  await client.close();
}

updateWithSetOnInsert();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_with_set_on_insert():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    users = db['users']

    result = users.update_one(
        {'_id': 1},
        {
            '$set': {'age': 31},
            '$setOnInsert': {'createdAt': datetime.datetime.now()}
        },
        upsert=True
    )

    updated_user = users.find_one({'_id': 1})
    print(updated_user)

    client.close()

update_with_set_on_insert()
```

------

# \$1slice
<a name="slice-update"></a>

O operador de `$slice` atualização modifica uma matriz limitando seu tamanho. Quando usado com o `$push` operador, ele restringe o número de elementos em uma matriz, mantendo somente o número especificado dos elementos mais recentes ou mais antigos.

**Parâmetros**
+ `field`: o campo de matriz a ser modificado.
+ `count`: Número máximo de elementos a serem mantidos. Valores positivos mantêm os primeiros N elementos, valores negativos mantêm os últimos N elementos.

## Exemplo (MongoDB Shell)
<a name="slice-update-examples"></a>

O exemplo a seguir demonstra como usar o operador de `$slice` atualização com `$push` para manter uma matriz de tamanho fixo das pontuações recentes.

**Crie documentos de amostra**

```
db.students.insertOne({
  _id: 1,
  name: "Alice",
  scores: [85, 90, 78]
});
```

**Exemplo de consulta**

```
db.students.updateOne(
  { _id: 1 },
  {
    $push: {
      scores: {
        $each: [92, 88],
        $slice: -3
      }
    }
  }
)
```

**Saída**

```
{
  "_id" : 1,
  "name" : "Alice",
  "scores" : [ 78, 92, 88 ]
}
```

Neste exemplo, o `$slice: -3` modificador mantém somente os últimos três elementos após inserir novos valores na matriz.

## Exemplos de código
<a name="slice-update-code"></a>

Para ver um exemplo de código para usar o operador de `$slice` atualização, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('students');

  await collection.updateOne(
    { _id: 1 },
    {
      $push: {
        scores: {
          $each: [92, 88],
          $slice: -3
        }
      }
    }
  );

  const updatedDocument = await collection.findOne({ _id: 1 });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.students

    collection.update_one(
        {'_id': 1},
        {
            '$push': {
                'scores': {
                    '$each': [92, 88],
                    '$slice': -3
                }
            }
        }
    )

    updated_document = collection.find_one({'_id': 1})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1sort
<a name="sort-update"></a>

O modificador de `$sort` atualização ordena os elementos da matriz quando usado com o `$push` operador. Ele organiza os elementos da matriz em ordem crescente ou decrescente com base nos valores de campo especificados ou nos próprios elementos.

**Parâmetros**
+ `field`: o campo de matriz a ser modificado.
+ `order`: Use `1` para ordem crescente ou `-1` decrescente.

## Exemplo (MongoDB Shell)
<a name="sort-update-examples"></a>

O exemplo a seguir demonstra o uso do `$sort` modificador with `$push` para adicionar novas pontuações do questionário e mantê-las classificadas em ordem decrescente.

**Crie documentos de amostra**

```
db.students.insertOne({
  _id: 1,
  name: "Bob",
  quizzes: [
    { score: 85, date: "2024-01-15" },
    { score: 92, date: "2024-02-10" }
  ]
});
```

**Exemplo de consulta**

```
db.students.updateOne(
  { _id: 1 },
  {
    $push: {
      quizzes: {
        $each: [{ score: 78, date: "2024-03-05" }],
        $sort: { score: -1 }
      }
    }
  }
)
```

**Saída**

```
{
  "_id" : 1,
  "name" : "Bob",
  "quizzes" : [
    { "score" : 92, "date" : "2024-02-10" },
    { "score" : 85, "date" : "2024-01-15" },
    { "score" : 78, "date" : "2024-03-05" }
  ]
}
```

## Exemplos de código
<a name="sort-update-code"></a>

Para ver um exemplo de código para usar o modificador de `$sort` atualização, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function updateDocument() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('students');

  await collection.updateOne(
    { _id: 1 },
    {
      $push: {
        quizzes: {
          $each: [{ score: 78, date: "2024-03-05" }],
          $sort: { score: -1 }
        }
      }
    }
  );

  const updatedDocument = await collection.findOne({ _id: 1 });
  console.log(updatedDocument);

  await client.close();
}

updateDocument();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def update_document():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.students

    collection.update_one(
        {'_id': 1},
        {
            '$push': {
                'quizzes': {
                    '$each': [{'score': 78, 'date': '2024-03-05'}],
                    '$sort': {'score': -1}
                }
            }
        }
    )

    updated_document = collection.find_one({'_id': 1})
    print(updated_document)

    client.close()

update_document()
```

------

# \$1unset
<a name="unset-update"></a>

O `$unset` operador no Amazon DocumentDB é usado para remover um campo especificado de um documento. Quando um campo é removido usando`$unset`, o campo é excluído do documento e o tamanho do documento é reduzido de acordo. Isso pode ser útil quando você deseja remover dados desnecessários de seus documentos.

**Parâmetros**
+ `field`: o campo a ser removido do documento. Isso pode ser um único campo ou um caminho pontilhado para um campo aninhado.

## Exemplo (MongoDB Shell)
<a name="unset-examples"></a>

O exemplo a seguir demonstra como usar o `$unset` operador para remover o `Words` campo de um documento na `example` coleção.

**Crie documentos de amostra**

```
db.example.insert({
    "DocName": "Document 1",
    "Date": {
        "Month": 4,
        "Day": 18,
        "Year": 1987,
        "DoW": "Saturday"
    },
    "Words": 2482
})
```

**Exemplo de consulta**

```
db.example.update(
    { "DocName" : "Document 1" },
    { $unset: { Words:1 } }
)
```

**Saída**

```
{
    "DocName": "Document 1",
    "Date": {
        "Month": 4,
        "Day": 18,
        "Year": 1987,
        "DoW": "Saturday"
    }
}
```

Neste exemplo, o `$unset` operador é usado para remover o `Words` campo do documento `DocName` igual a “Documento 1". O documento resultante não contém mais o `Words` campo.

## Exemplos de código
<a name="unset-code"></a>

Para ver um exemplo de código para usar o `$unset` comando, escolha a guia do idioma que você deseja usar:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function removeField() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('example');

  const result = await collection.updateOne(
    { "DocName": "Document 1" },
    { $unset: { "Words": 1 } }
  );

  console.log(`Modified ${result.modifiedCount} document(s)`);
  client.close();
}

removeField();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def remove_field():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['example']

    result = collection.update_one(
        {"DocName": "Document 1"},
        {"$unset": {"Words": 1}}
    )

    print(f"Modified {result.modified_count} document(s)")
    client.close()

remove_field()
```

------