Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Aggiorna operatori
<a name="mongo-apis-update-operators"></a>

Questa sezione fornisce informazioni dettagliate sugli operatori di aggiornamento supportati da 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'operatore `$` posizionale aggiorna il primo elemento dell'array che corrisponde alla condizione di interrogazione. Funge da segnaposto per la posizione dell'elemento dell'array corrispondente.

**Parametri**
+ `field.$`: Il campo dell'array con l'operatore posizionale per aggiornare il primo elemento corrispondente.

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

L'esempio seguente dimostra l'utilizzo dell'operatore `$` posizionale per aggiornare un elemento specifico dell'array.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

## Esempi di codice
<a name="dollar-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo dell'operatore `$` posizionale, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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'operatore `$[]` all posizionale aggiorna tutti gli elementi di un array. Viene utilizzato quando è necessario modificare ogni elemento in un campo dell'array.

**Parametri**
+ `field.$[]`: Il campo array con l'operatore all-posizionale per aggiornare tutti gli elementi.

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

L'esempio seguente dimostra l'utilizzo dell'`$[]`operatore per aggiornare tutti gli elementi dell'array.

**Crea documenti di esempio**

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

**Esempio di query**

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

**Output**

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

## Esempi di codice
<a name="dollarBrackets-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo `$[]` dell'operatore, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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'operatore posizionale `$[<identifier>]` filtrato aggiorna tutti gli elementi dell'array che corrispondono alle condizioni di filtro specificate. Viene utilizzato con l'`arrayFilters`opzione di aggiornare selettivamente gli elementi dell'array.

**Parametri**
+ `field.$[identifier]`: Il campo dell'array con l'operatore posizionale filtrato.
+ `arrayFilters`: una serie di condizioni di filtro che determinano gli elementi da aggiornare.

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

L'esempio seguente dimostra l'utilizzo dell'`$[<identifier>]`operatore per aggiornare elementi specifici dell'array in base a una condizione.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

## Esempi di codice
<a name="dollarIdentifier-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo `$[<identifier>]` dell'operatore, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per aggiungere un valore a un array solo se il valore non è già presente nell'array. Ciò è utile per garantire che un array contenga elementi unici.

**Parametri**
+ `field`: Il campo da aggiornare.
+ `value`: Il valore da aggiungere al campo dell'array. Può essere un singolo valore o un'espressione.

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

L'esempio seguente mostra come utilizzare l'`$addToSet`operatore per aggiungere elementi unici a un array.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

In questo esempio, l'`$addToSet`operatore aggiunge il tag «verde» all'array «tags» del documento in cui il campo «item» è «apple». Poiché «green» non era già presente nell'array, è stato aggiunto.

## Esempi di codice
<a name="addToSet-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$addToSet` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB consente di eseguire operazioni bit per bit sui bit di un determinato campo. Questo può essere utile per attività come l'impostazione, la cancellazione o il controllo dello stato dei singoli bit all'interno di un numero.

**Parametri**
+ `field`: Il campo su cui eseguire operazioni bit per bit.
+ `and`: Un valore intero utilizzato per eseguire un'operazione AND bit per bit sul campo.
+ `or`: un valore intero utilizzato per eseguire un'operazione OR bit per bit sul campo.
+ `xor`: Un valore intero utilizzato per eseguire un'operazione XOR bit per bit sul campo.

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

L'esempio seguente mostra come utilizzare l'`$bit`operatore per eseguire operazioni bit per bit su un campo numerico.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

In questo esempio, l'`$bit`operatore viene utilizzato per eseguire un'operazione AND bit per bit sul campo «numero» del documento con il valore `_id` di 1. Il risultato è che il valore del campo «numero» è impostato su 1, che è il risultato dell'operazione AND bit per bit tra il valore originale di 5 e il valore 3.

## Esempi di codice
<a name="bit-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$bit` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore viene utilizzato per impostare il valore di un campo sulla data e l'ora correnti. Questo operatore è utile per aggiornare automaticamente un campo con il timestamp corrente quando un documento viene inserito o aggiornato.

**Parametri**
+ `field`: Il campo da aggiornare con la data e l'ora correnti.
+ `type`: (opzionale) Specificate il tipo BSON da utilizzare per la data corrente. Può essere `date` o `timestamp`.

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

L'esempio seguente mostra come utilizzare l'`$currentDate`operatore per impostare il `lastModified` campo sulla data e l'ora correnti quando viene inserito un nuovo documento.

**Crea documenti di esempio**

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

**Esempio di query**

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

**Visualizza il documento aggiornato**

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

**Output**

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

## Esempi di codice
<a name="currentDate-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$currentDate` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore viene utilizzato insieme ad altri operatori di aggiornamento, come `$push` e`$addToSet`, per aggiungere più valori a un campo di matrice. Consente di aggiungere più elementi a un array in un'unica operazione, anziché dover eseguire più operazioni di aggiornamento.

**Parametri**
+ `value`: La matrice di valori da aggiungere al campo dell'array.

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

L'esempio seguente dimostra l'utilizzo `$each` dell'operatore con l'`$push`operatore per aggiungere più elementi a un campo di matrice.

**Crea documenti di esempio**

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

**Esempio di query**

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

**Visualizza il documento aggiornato**

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

**Output**

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

## Esempi di codice
<a name="each-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$each` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore viene utilizzato per incrementare il valore di un campo di un importo specificato. Viene utilizzato per aggiornare un campo numerico, ad esempio un contatore o una valutazione, senza dover recuperare il valore corrente, calcolare il nuovo valore e quindi aggiornare il campo.

**Parametri**
+ `field`: nome del campo da incrementare.
+ `amount`: La quantità di cui incrementare il campo. Può essere un valore positivo o negativo.

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

L'esempio seguente mostra come utilizzare l'`$inc`operatore per incrementare il `age` campo di un documento.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Visualizza il documento aggiornato**

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

**Output**

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

## Esempi di codice
<a name="inc-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$inc` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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'operatore `$max` update aggiorna il valore di un campo solo se il valore specificato è maggiore del valore del campo corrente. Questo operatore è utile per mantenere i valori massimi tra gli aggiornamenti.

**Parametri**
+ `field`: Il campo da aggiornare.
+ `value`: Il valore da confrontare con il valore del campo corrente.

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

L'esempio seguente dimostra l'utilizzo `$max` dell'operatore per aggiornare il punteggio più alto registrato per un giocatore.

**Crea documenti di esempio**

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

**Esempio di aggiornamento**

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

**Risultato**

Il `highScore` campo per Alice viene aggiornato a 95 perché 95 è maggiore del valore corrente di 85.

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

## Esempi di codice
<a name="max-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$max` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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'operatore `$min` update aggiorna il valore di un campo solo se il valore specificato è inferiore al valore del campo corrente. Questo operatore è utile per mantenere i valori minimi tra gli aggiornamenti.

**Parametri**
+ `field`: Il campo da aggiornare.
+ `value`: Il valore da confrontare con il valore del campo corrente.

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

L'esempio seguente dimostra l'utilizzo `$min` dell'operatore per aggiornare la temperatura più bassa registrata per una stazione meteorologica.

**Crea documenti di esempio**

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

**Esempio di aggiornamento**

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

**Risultato**

Il `lowestTemp` campo per la stazione A viene aggiornato a 12 perché 12 è inferiore al valore corrente di 15.

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

## Esempi di codice
<a name="min-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$min` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per moltiplicare il valore di un campo per un numero specificato. Ciò può essere utile per aggiornare più documenti in modo atomico e coerente, ad esempio per aggiornare le miglia di volo in base allo stato di una carta di credito.

**Parametri**
+ `field`: Il campo da moltiplicare.
+ `multiplier`: Il numero per cui moltiplicare il valore del campo.

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

Questo esempio dimostra come utilizzare l'`$mul`operatore per raddoppiare il `flight_miles` valore di tutti i documenti in cui si trova il `credit_card` campo. `true`

**Crea documenti di esempio**

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

**Esempio di query**

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

**Output**

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

Per i clienti che dispongono di una carta di credito, le miglia di volo sono state raddoppiate.

L'operatore di matrice `$[]` posizionale viene utilizzato per applicare l'`$mul`operazione a ciascun elemento dell'array. `flight_miles`

## Esempi di codice
<a name="mul-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$mul` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per rimuovere il primo o l'ultimo elemento da un campo array. È particolarmente utile quando è necessario mantenere un array a dimensione fissa o implementare una struttura di dati simile a una coda all'interno di un documento.

**Parametri**
+ `field`: il nome del campo dell'array da cui rimuovere un elemento.
+ `value`: un valore intero che determina la posizione dell'elemento da rimuovere. Un valore di `1` rimuove l'ultimo elemento, mentre un valore di `-1` rimuove il primo elemento.

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

Questo esempio dimostra come utilizzare l'`$pop`operatore per rimuovere il primo e l'ultimo elemento da un campo di matrice.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

## Esempi di codice
<a name="pop-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$pop` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

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

Il `$position` modificatore in Amazon DocumentDB specifica la posizione nell'array in cui l'operatore inserisce `$push` gli elementi. Senza il `$position` modificatore, l'`$push`operatore inserisce gli elementi alla fine dell'array.

**Parametri**
+ `field`: il campo dell'array da aggiornare.
+ `num`: la posizione nell'array in cui gli elementi devono essere inseriti, in base all'indicizzazione a base zero.

**Nota**: per utilizzare il `$position` modificatore, deve apparire insieme al modificatore. `$each`

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

L'esempio seguente dimostra come utilizzare l'`$position`operatore per inserire attività in posizioni specifiche in un sistema di gestione dei progetti.

**Crea documenti di esempio**

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

**Esempio di query 1: aggiungi attività urgenti all'inizio**

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

**Uscita 1**

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

**Esempio di query 2: aggiungere attività in una posizione specifica**

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

**Output 2**

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

## Esempi di codice
<a name="position-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$position` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore viene utilizzato per rimuovere da un array tutte le istanze di uno o più valori che corrispondono a una condizione specificata. Questo operatore è utile quando è necessario rimuovere elementi specifici da un campo di matrice all'interno di un documento.

**Parametri**
+ `field`: il nome del campo dell'array da cui rimuovere i valori.
+ `value`: il valore o la condizione che determina quali elementi rimuovere dall'array.

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

L'esempio seguente mostra come utilizzare l'`$pull`operatore per rimuovere elementi da un campo di matrice.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

La query precedente rimuove la funzione «Takeout» da tutti i documenti in cui il `cuisine` campo è «italiano».

## Esempi di codice
<a name="pull-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$pull` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per rimuovere tutte le istanze dei valori specificati da un campo array. Ciò è particolarmente utile quando è necessario rimuovere più elementi da un array in un'unica operazione.

**Parametri**
+ `field`: il nome del campo dell'array da cui rimuovere gli elementi.
+ `value`: Una matrice di valori da rimuovere dal campo dell'array.

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

L'esempio seguente mostra come utilizzare l'`$pullAll`operatore per rimuovere più elementi da un campo di matrice.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

## Esempi di codice
<a name="pullAll-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$pullAll` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per aggiungere un elemento a un campo array in un documento. Questo operatore è particolarmente utile quando è necessario aggiungere nuovi dati a un array esistente senza sovrascrivere l'intero array.

**Parametri**
+ `field`: il nome del campo dell'array a cui aggiungere il nuovo elemento.
+ `value`: Il valore da aggiungere all'array.
+ `position`: (opzionale) Un modificatore che specifica la posizione nell'array in cui deve essere aggiunto il nuovo elemento. I modificatori supportati includono `$` (aggiungi alla fine dell'array) e `$[]` (aggiungi alla fine dell'array, ignorando qualsiasi filtro dell'array).

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

L'esempio seguente mostra come utilizzare l'`$push`operatore per aggiungere nuovi elementi a un campo di matrice in un documento.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

Dopo aver eseguito l'aggiornamento, il documento con `_id: 1` avrà l'`hobbies`array aggiornato a`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

## Esempi di codice
<a name="push-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$push` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per rinominare un campo in un documento. Questo operatore può essere particolarmente utile quando è necessario aggiornare la struttura dei documenti o allinearli a nuovi modelli di dati.

**Parametri**
+ `field`: Il campo da rinominare.
+ `newName`: Il nuovo nome per il campo.

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

L'esempio seguente mostra come utilizzare l'`$rename`operatore per rinominare il `&quot;Date.DoW&quot;` campo `&quot;Date.DayOfWeek&quot;` in un documento con il `&quot;DocName&quot;` campo impostato su. `&quot;Document 1&quot;`

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

## Esempi di codice
<a name="rename-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$rename` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per aggiornare il valore di un campo specificato in un documento. Questo operatore consente di aggiungere nuovi campi o modificare quelli esistenti all'interno di un documento. È un operatore di aggiornamento fondamentale nel driver Java MongoDB, compatibile con Amazon DocumentDB.

**Parametri**
+ `field`: Il campo da aggiornare.
+ `value`: Il nuovo valore per il campo.

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

L'esempio seguente mostra come utilizzare l'`$set`operatore per aggiornare il `Item` campo in un documento.

**Crea documenti di esempio**

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

**Esempio di query**

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

**Output**

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

## Esempi di codice
<a name="set-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$set` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per impostare il valore di un campo se viene inserito un documento, ma non ha effetto se il documento viene aggiornato.

**Parametri**
+ `field`: Il campo da impostare.
+ `value`: Il valore da assegnare al campo.

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

L'esempio seguente dimostra l'utilizzo dell'`$setOnInsert`operatore in Amazon DocumentDB. Crea un nuovo documento se il documento non esiste già, ma non ha effetto se il documento viene aggiornato.

**Crea documenti di esempio**

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

**Esempio di query 1: aggiorna un documento esistente**

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

**Output 1**

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

L'output mostra che il documento è stato aggiornato, ma il `createdAt` campo **NON è stato aggiunto** poiché il documento esisteva già. L'`$setOnInsert`operatore si applica solo quando si inseriscono nuovi documenti.

**Esempio di query 2 - Inserisci nuovo documento (upsert)**

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

**Uscita 2**

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

## Esempi di codice
<a name="setOnInsert-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$setOnInsert` comando, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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'operatore di `$slice` aggiornamento modifica un array limitandone le dimensioni. Se utilizzato con l'`$push`operatore, limita il numero di elementi in un array, mantenendo solo il numero specificato di elementi più recenti o meno recenti.

**Parametri**
+ `field`: il campo dell'array da modificare.
+ `count`: numero massimo di elementi da conservare. I valori positivi mantengono i primi N elementi, i valori negativi mantengono gli ultimi N elementi.

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

L'esempio seguente mostra come utilizzare l'operatore `$slice` update with per mantenere un array `$push` a dimensione fissa di punteggi recenti.

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

In questo esempio, il `$slice: -3` modificatore mantiene solo gli ultimi tre elementi dopo aver inserito nuovi valori nell'array.

## Esempi di codice
<a name="slice-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo dell'operatore `$slice` update, scegliete la scheda relativa alla lingua che desiderate utilizzare:

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

Il modificatore di `$sort` aggiornamento ordina gli elementi dell'array quando viene utilizzato con l'`$push`operatore. Dispone gli elementi dell'array in ordine crescente o decrescente in base ai valori di campo specificati o agli elementi stessi.

**Parametri**
+ `field`: il campo dell'array da modificare.
+ `order`: da utilizzare `1` per l'ordine crescente o `-1` per l'ordine decrescente.

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

L'esempio seguente dimostra l'utilizzo del `$sort` modificatore con `$push` per aggiungere nuovi punteggi dei quiz e mantenerli ordinati in ordine decrescente.

**Crea documenti di esempio**

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

**Esempio di query**

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

**Output**

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

## Esempi di codice
<a name="sort-update-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del modificatore di `$sort` aggiornamento, scegli la scheda relativa alla lingua che desideri utilizzare:

------
#### [ 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`operatore in Amazon DocumentDB viene utilizzato per rimuovere un campo specificato da un documento. Quando un campo viene rimosso utilizzando`$unset`, il campo viene eliminato dal documento e le dimensioni del documento vengono ridotte di conseguenza. Ciò può essere utile quando si desidera rimuovere dati non necessari dai documenti.

**Parametri**
+ `field`: Il campo da rimuovere dal documento. Può essere un campo singolo o un percorso punteggiato verso un campo nidificato.

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

L'esempio seguente mostra come utilizzare l'`$unset`operatore per rimuovere il `Words` campo da un documento della raccolta. `example`

**Crea documenti di esempio**

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

**Esempio di interrogazione**

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

**Output**

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

In questo esempio, l'`$unset`operatore viene utilizzato per rimuovere il `Words` campo dal documento `DocName` pari a «Documento 1". Il documento risultante non contiene più il `Words` campo.

## Esempi di codice
<a name="unset-code"></a>

Per visualizzare un esempio di codice per l'utilizzo del `$unset` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:

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

------