Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Mettre à jour les opérateurs
<a name="mongo-apis-update-operators"></a>

Cette section fournit des informations détaillées sur les opérateurs de mise à jour pris en charge par 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>

L'opérateur `$` positionnel met à jour le premier élément du tableau qui correspond à la condition de requête. Il agit comme un espace réservé pour la position de l'élément du tableau correspondant.

**Paramètres**
+ `field.$`: Le champ du tableau avec l'opérateur de position pour mettre à jour le premier élément correspondant.

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

L'exemple suivant montre comment utiliser l'opérateur `$` positionnel pour mettre à jour un élément de tableau spécifique.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="dollar-update-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de l'opérateur `$` positionnel, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'opérateur de position `$[]` all met à jour tous les éléments d'un tableau. Il est utilisé lorsque vous devez modifier chaque élément d'un champ de tableau.

**Paramètres**
+ `field.$[]`: Le champ du tableau avec l'opérateur de position all pour mettre à jour tous les éléments.

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

L'exemple suivant montre comment utiliser l'`$[]`opérateur pour mettre à jour tous les éléments d'un tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="dollarBrackets-update-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de `$[]` l'opérateur, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'opérateur de position `$[<identifier>]` filtré met à jour tous les éléments du tableau qui répondent aux conditions de filtre spécifiées. Il est utilisé avec l'`arrayFilters`option de mise à jour sélective des éléments du tableau.

**Paramètres**
+ `field.$[identifier]`: Le champ du tableau avec l'opérateur de position filtré.
+ `arrayFilters`: ensemble de conditions de filtre qui déterminent les éléments à mettre à jour.

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

L'exemple suivant montre comment utiliser l'`$[<identifier>]`opérateur pour mettre à jour des éléments de tableau spécifiques en fonction d'une condition.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="dollarIdentifier-update-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de `$[<identifier>]` l'opérateur, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$addToSet`opérateur dans Amazon DocumentDB est utilisé pour ajouter une valeur à un tableau uniquement si la valeur n'est pas déjà présente dans le tableau. Cela est utile pour garantir qu'un tableau contient des éléments uniques.

**Paramètres**
+ `field`: champ à mettre à jour.
+ `value`: valeur à ajouter au champ du tableau. Il peut s'agir d'une valeur unique ou d'une expression.

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

L'exemple suivant montre comment utiliser l'`$addToSet`opérateur pour ajouter des éléments uniques à un tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

Dans cet exemple, l'`$addToSet`opérateur ajoute la balise « verte » au tableau « tags » du document où le champ « item » est « apple ». Comme le mot « vert » ne figurait pas déjà dans le tableau, il a été ajouté.

## Exemples de code
<a name="addToSet-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$addToSet` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$bit`opérateur d'Amazon DocumentDB vous permet d'effectuer des opérations binaires sur les bits d'un champ donné. Cela peut être utile pour des tâches telles que le réglage, l'effacement ou la vérification de l'état de bits individuels au sein d'un nombre.

**Paramètres**
+ `field`: champ sur lequel effectuer des opérations au niveau du bit.
+ `and`: valeur entière utilisée pour effectuer une opération ET au niveau du bit sur le terrain.
+ `or`: valeur entière utilisée pour effectuer une opération OR au niveau du bit sur le terrain.
+ `xor`: valeur entière utilisée pour effectuer une opération XOR bit à bit sur le terrain.

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

L'exemple suivant montre comment utiliser l'`$bit`opérateur pour effectuer des opérations au niveau du bit sur un champ numérique.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

Dans cet exemple, l'`$bit`opérateur est utilisé pour effectuer une opération AND bit à bit sur le champ « numéro » du document avec le `_id` chiffre 1. Le résultat est que la valeur du champ « numéro » est définie sur 1, résultat de l'opération AND bit à bit entre la valeur initiale de 5 et la valeur 3.

## Exemples de code
<a name="bit-code"></a>

Pour afficher un exemple de code d'utilisation de la `$bit` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$currentDate`opérateur est utilisé pour définir la valeur d'un champ à la date et à l'heure actuelles. Cet opérateur est utile pour mettre à jour automatiquement un champ avec l'horodatage actuel lorsqu'un document est inséré ou mis à jour.

**Paramètres**
+ `field`: champ à mettre à jour avec la date et l'heure actuelles.
+ `type`: (facultatif) Spécifie le type BSON à utiliser pour la date actuelle. Peut avoir la valeur `date` ou `timestamp`.

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

L'exemple suivant montre comment utiliser l'`$currentDate`opérateur pour définir le `lastModified` champ à la date et à l'heure actuelles d'insertion d'un nouveau document.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Afficher le document mis à jour**

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

**Sortie**

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

## Exemples de code
<a name="currentDate-code"></a>

Pour afficher un exemple de code d'utilisation de la `$currentDate` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$each`opérateur est utilisé conjointement avec d'autres opérateurs de mise à jour, tels que `$push` et`$addToSet`, pour ajouter plusieurs valeurs à un champ de tableau. Il permet d'ajouter plusieurs éléments à un tableau en une seule opération, plutôt que d'avoir à exécuter plusieurs opérations de mise à jour.

**Paramètres**
+ `value`: tableau de valeurs à ajouter au champ du tableau.

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

L'exemple suivant montre comment utiliser l'`$each`opérateur avec l'`$push`opérateur pour ajouter plusieurs éléments à un champ de tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Afficher le document mis à jour**

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

**Sortie**

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

## Exemples de code
<a name="each-code"></a>

Pour afficher un exemple de code d'utilisation de la `$each` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$inc`opérateur est utilisé pour incrémenter la valeur d'un champ d'un montant spécifié. Il est utilisé pour mettre à jour un champ numérique, tel qu'un compteur ou une évaluation, sans avoir à récupérer la valeur actuelle, à calculer la nouvelle valeur, puis à mettre à jour le champ.

**Paramètres**
+ `field`: nom du champ à incrémenter.
+ `amount`: montant par lequel le champ doit être incrémenté. Il peut s'agir d'une valeur positive ou négative.

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

L'exemple suivant montre comment utiliser l'`$inc`opérateur pour incrémenter le `age` champ d'un document.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Afficher le document mis à jour**

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

**Sortie**

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

## Exemples de code
<a name="inc-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$inc` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'opérateur de `$max` mise à jour met à jour la valeur d'un champ uniquement si la valeur spécifiée est supérieure à la valeur du champ actuel. Cet opérateur est utile pour maintenir les valeurs maximales entre les mises à jour.

**Paramètres**
+ `field`: champ à mettre à jour.
+ `value`: valeur à comparer avec la valeur actuelle du champ.

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

L'exemple suivant montre comment utiliser l'`$max`opérateur pour mettre à jour le score le plus élevé enregistré pour un joueur.

**Création d'exemples de documents**

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

**Exemple de mise à jour**

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

**Result**

Le `highScore` champ pour Alice est mis à jour à 95 car 95 est supérieur à la valeur actuelle de 85.

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

## Exemples de code
<a name="max-update-code"></a>

Pour afficher un exemple de code d'utilisation de la `$max` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'opérateur de `$min` mise à jour met à jour la valeur d'un champ uniquement si la valeur spécifiée est inférieure à la valeur du champ actuel. Cet opérateur est utile pour maintenir les valeurs minimales lors des mises à jour.

**Paramètres**
+ `field`: champ à mettre à jour.
+ `value`: valeur à comparer avec la valeur actuelle du champ.

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

L'exemple suivant montre comment utiliser l'`$min`opérateur pour mettre à jour la température la plus basse enregistrée pour une station météo.

**Création d'exemples de documents**

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

**Exemple de mise à jour**

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

**Result**

Le `lowestTemp` champ de la station A est mis à jour à 12 car 12 est inférieur à la valeur actuelle de 15.

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

## Exemples de code
<a name="min-update-code"></a>

Pour afficher un exemple de code d'utilisation de la `$min` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$mul`opérateur dans Amazon DocumentDB est utilisé pour multiplier la valeur d'un champ par un nombre spécifié. Cela peut être utile pour mettre à jour plusieurs documents de manière atomique et cohérente, par exemple pour mettre à jour les miles de vol en fonction du statut d'une carte de crédit.

**Paramètres**
+ `field`: Le champ à multiplier.
+ `multiplier`: le nombre par lequel multiplier la valeur du champ.

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

Cet exemple montre comment utiliser l'`$mul`opérateur pour doubler la `flight_miles` valeur de tous les documents où se trouve le `credit_card` champ`true`.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

```
{ "_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 ] }
```

Pour les clients détenteurs d'une carte de crédit, leurs miles de vol ont été doublés.

L'opérateur de tableau `$[]` positionnel est utilisé pour appliquer l'`$mul`opération à chaque élément du `flight_miles` tableau.

## Exemples de code
<a name="mul-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$mul` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$pop`opérateur dans Amazon DocumentDB est utilisé pour supprimer le premier ou le dernier élément d'un champ de tableau. Cela est particulièrement utile lorsque vous devez gérer un tableau de taille fixe ou implémenter une structure de données semblable à une file d'attente dans un document.

**Paramètres**
+ `field`: nom du champ du tableau dont un élément doit être supprimé.
+ `value`: valeur entière qui détermine la position de l'élément à supprimer. La valeur de `1` supprime le dernier élément, tandis que la valeur de `-1` supprime le premier élément.

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

Cet exemple montre comment utiliser l'`$pop`opérateur pour supprimer le premier et le dernier élément d'un champ de tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

```
// 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 } })
```

**Sortie**

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

## Exemples de code
<a name="pop-code"></a>

Pour afficher un exemple de code d'utilisation de la `$pop` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

Le `$position` modificateur dans Amazon DocumentDB indique l'emplacement dans le tableau où l'`$push`opérateur insère les éléments. Sans le `$position` modificateur, l'`$push`opérateur insère des éléments à la fin du tableau.

**Paramètres**
+ `field`: champ du tableau à mettre à jour.
+ `num`: position dans le tableau où les éléments doivent être insérés, sur la base d'une indexation basée sur zéro.

**Remarque** : Pour utiliser le `$position` modificateur, il doit apparaître avec le `$each` modificateur.

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

L'exemple suivant montre comment utiliser l'`$position`opérateur pour insérer des tâches à des positions spécifiques dans un système de gestion de projet.

**Création d'exemples de documents**

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

**Exemple de requête 1 - Ajouter des tâches urgentes au début**

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

**Sortie 1**

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

**Exemple de requête 2 - Ajouter des tâches à une position spécifique**

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

**Produit 2**

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

## Exemples de code
<a name="position-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$position` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$pull`opérateur est utilisé pour supprimer d'un tableau toutes les instances d'une valeur ou de valeurs correspondant à une condition spécifiée. Cet opérateur est utile lorsque vous devez supprimer des éléments spécifiques d'un champ de tableau dans un document.

**Paramètres**
+ `field`: nom du champ du tableau dont vous souhaitez supprimer la ou les valeurs.
+ `value`: valeur ou condition qui détermine le ou les éléments à supprimer du tableau.

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

L'exemple suivant montre comment utiliser l'`$pull`opérateur pour supprimer des éléments d'un champ de tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

La requête ci-dessus supprime la fonction « Takeout » de tous les documents dont le `cuisine` champ est « italien ».

## Exemples de code
<a name="pull-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$pull` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$pullAll`opérateur dans Amazon DocumentDB est utilisé pour supprimer toutes les instances des valeurs spécifiées d'un champ de tableau. Cela est particulièrement utile lorsque vous devez supprimer plusieurs éléments d'un tableau en une seule opération.

**Paramètres**
+ `field`: nom du champ du tableau dans lequel les éléments doivent être supprimés.
+ `value`: tableau de valeurs à supprimer du champ du tableau.

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

L'exemple suivant montre comment utiliser l'`$pullAll`opérateur pour supprimer plusieurs éléments d'un champ de tableau.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="pullAll-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$pullAll` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$push`opérateur dans Amazon DocumentDB est utilisé pour ajouter un élément à un champ de tableau dans un document. Cet opérateur est particulièrement utile lorsque vous devez ajouter de nouvelles données à un tableau existant sans remplacer le tableau entier.

**Paramètres**
+ `field`: nom du champ du tableau auquel le nouvel élément doit être ajouté.
+ `value`: valeur à ajouter au tableau.
+ `position`: (facultatif) Un modificateur qui spécifie la position dans le tableau où le nouvel élément doit être ajouté. Les modificateurs pris en charge incluent `$` (ajouter à la fin du tableau) et `$[]` (ajouter à la fin du tableau, en ignorant les filtres du tableau).

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

L'exemple suivant montre comment utiliser l'`$push`opérateur pour ajouter de nouveaux éléments à un champ de tableau dans un document.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

Après avoir exécuté la mise à jour, le `hobbies` tableau du document contenant `_id: 1` sera mis à jour en`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

## Exemples de code
<a name="push-code"></a>

Pour afficher un exemple de code d'utilisation de la `$push` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$rename`opérateur dans Amazon DocumentDB est utilisé pour renommer un champ dans un document. Cet opérateur peut être particulièrement utile lorsque vous devez mettre à jour la structure de vos documents ou les aligner sur de nouveaux modèles de données.

**Paramètres**
+ `field`: champ à renommer.
+ `newName`: nouveau nom du champ.

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

L'exemple suivant montre comment utiliser l'`$rename`opérateur pour renommer le `&quot;Date.DoW&quot;` champ `&quot;Date.DayOfWeek&quot;` en dans un document dont le `&quot;DocName&quot;` champ est défini sur. `&quot;Document 1&quot;`

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="rename-code"></a>

Pour afficher un exemple de code d'utilisation de la `$rename` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$set`opérateur dans Amazon DocumentDB est utilisé pour mettre à jour la valeur d'un champ spécifié dans un document. Cet opérateur vous permet d'ajouter de nouveaux champs ou de modifier des champs existants dans un document. Il s'agit d'un opérateur de mise à jour fondamental du pilote Java MongoDB, qui est compatible avec Amazon DocumentDB.

**Paramètres**
+ `field`: champ à mettre à jour.
+ `value`: nouvelle valeur du champ.

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

L'exemple suivant montre comment utiliser l'`$set`opérateur pour mettre à jour le `Item` champ dans un document.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="set-code"></a>

Pour afficher un exemple de code d'utilisation de la `$set` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$setOnInsert`opérateur dans Amazon DocumentDB est utilisé pour définir la valeur d'un champ si un document est inséré, mais cela n'a aucun effet si le document est mis à jour.

**Paramètres**
+ `field`: Le champ à définir.
+ `value`: valeur à attribuer au champ.

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

L'exemple suivant illustre l'utilisation de l'`$setOnInsert`opérateur dans Amazon DocumentDB. Cela crée un nouveau document s'il n'existe pas déjà, mais cela n'a aucun effet si le document est mis à jour.

**Création d'exemples de documents**

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

**Exemple de requête 1 - Mettre à jour un document existant**

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

**Sortie 1**

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

La sortie indique que le document a été mis à jour, mais le `createdAt` champ **n'a PAS été ajouté** car le document existait déjà. L'`$setOnInsert`opérateur ne s'applique que lors de l'insertion de nouveaux documents.

**Exemple de requête 2 - Insérer un nouveau document (upsert)**

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

**Produit 2**

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

## Exemples de code
<a name="setOnInsert-code"></a>

Pour afficher un exemple de code relatif à l'utilisation de la `$setOnInsert` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'opérateur de `$slice` mise à jour modifie un tableau en limitant sa taille. Lorsqu'il est utilisé avec l'`$push`opérateur, il limite le nombre d'éléments d'un tableau, en ne conservant que le nombre spécifié d'éléments les plus récents ou les plus anciens.

**Paramètres**
+ `field`: le champ du tableau à modifier.
+ `count`: Nombre maximum d'éléments à conserver. Les valeurs positives conservent les N premiers éléments, les valeurs négatives conservent les N derniers éléments.

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

L'exemple suivant montre comment utiliser l'opérateur de `$slice` mise à jour with `$push` pour gérer un tableau de taille fixe des scores récents.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

Dans cet exemple, le `$slice: -3` modificateur ne conserve que les trois derniers éléments après avoir introduit de nouvelles valeurs dans le tableau.

## Exemples de code
<a name="slice-update-code"></a>

Pour afficher un exemple de code relatif `$slice` à l'utilisation de l'opérateur de mise à jour, sélectionnez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

Le modificateur de `$sort` mise à jour ordonne les éléments du tableau lorsqu'il est utilisé avec l'`$push`opérateur. Il organise les éléments du tableau par ordre croissant ou décroissant en fonction des valeurs de champ spécifiées ou des éléments eux-mêmes.

**Paramètres**
+ `field`: le champ du tableau à modifier.
+ `order`: `1` À utiliser pour l'ordre croissant ou `-1` décroissant.

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

L'exemple suivant montre comment utiliser le `$sort` modificateur with `$push` pour ajouter de nouveaux résultats de quiz et les trier par ordre décroissant.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

## Exemples de code
<a name="sort-update-code"></a>

Pour afficher un exemple de code permettant d'utiliser le modificateur de `$sort` mise à jour, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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>

L'`$unset`opérateur dans Amazon DocumentDB est utilisé pour supprimer un champ spécifique d'un document. Lorsqu'un champ est supprimé à l'aide de`$unset`, le champ est supprimé du document et la taille du document est réduite en conséquence. Cela peut être utile lorsque vous souhaitez supprimer des données inutiles de vos documents.

**Paramètres**
+ `field`: champ à supprimer du document. Il peut s'agir d'un champ unique ou d'un chemin en pointillé vers un champ imbriqué.

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

L'exemple suivant montre comment utiliser l'`$unset`opérateur pour supprimer le `Words` champ d'un document de la `example` collection.

**Création d'exemples de documents**

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

**Exemple de requête**

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

**Sortie**

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

Dans cet exemple, l'`$unset`opérateur est utilisé pour supprimer le `Words` champ du document dont le nom est `DocName` égal à « Document 1 ». Le document obtenu ne contient plus le `Words` champ.

## Exemples de code
<a name="unset-code"></a>

Pour afficher un exemple de code d'utilisation de la `$unset` commande, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser :

------
#### [ 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()
```

------