Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Operadores de actualización
<a name="mongo-apis-update-operators"></a>

En esta sección se proporciona información detallada sobre los operadores de actualización compatibles con 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>

El operador `$` posicional actualiza el primer elemento de la matriz que coincide con la condición de consulta. Actúa como marcador de posición para la posición del elemento de matriz coincidente.

**Parámetros**
+ `field.$`: El campo de matriz con el operador posicional para actualizar el primer elemento coincidente.

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

El siguiente ejemplo demuestra el uso del operador `$` posicional para actualizar un elemento de matriz específico.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el operador `$` posicional, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El operador `$[]` all positional actualiza todos los elementos de una matriz. Se utiliza cuando se necesita modificar todos los elementos de un campo de matriz.

**Parámetros**
+ `field.$[]`: El campo de matriz con el operador totalmente posicional para actualizar todos los elementos.

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

El siguiente ejemplo demuestra el uso del `$[]` operador para actualizar todos los elementos de la matriz.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$[]` operador, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El operador posicional `$[<identifier>]` filtrado actualiza todos los elementos de la matriz que coinciden con las condiciones de filtro especificadas. Se utiliza con la `arrayFilters` opción de actualizar selectivamente los elementos de la matriz.

**Parámetros**
+ `field.$[identifier]`: El campo de matriz con el operador posicional filtrado.
+ `arrayFilters`: un conjunto de condiciones de filtro que determinan qué elementos se van a actualizar.

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

El siguiente ejemplo demuestra el uso del `$[<identifier>]` operador para actualizar elementos de matriz específicos en función de una condición.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$[<identifier>]` operador, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El `$addToSet` operador de Amazon DocumentDB se utiliza para añadir un valor a una matriz solo si el valor aún no está presente en la matriz. Esto resulta útil para garantizar que una matriz contenga elementos únicos.

**Parámetros**
+ `field`: el campo que se va a actualizar.
+ `value`: el valor que se va a añadir al campo de matriz. Puede ser un valor único o una expresión.

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

El siguiente ejemplo muestra cómo utilizar el `$addToSet` operador para añadir elementos únicos a una matriz.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

En este ejemplo, el `$addToSet` operador añade la etiqueta «verde» a la matriz de «etiquetas» del documento, donde el campo «elemento» es «manzana». Como la palabra «verde» aún no estaba en la matriz, se agregó.

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

Para ver un ejemplo de código para usar el `$addToSet` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

  await client.close();
}

example();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

example()
```

------

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

El `$bit` operador de Amazon DocumentDB le permite realizar operaciones bit a bit en los bits de un campo determinado. Esto puede resultar útil para tareas como configurar, borrar o comprobar el estado de los bits individuales de un número.

**Parámetros**
+ `field`: El campo en el que se realizan operaciones bit a bit.
+ `and`: un valor entero que se utiliza para realizar una operación AND bit a bit en el campo.
+ `or`: un valor entero que se utiliza para realizar una operación OR bit a bit en el campo.
+ `xor`: un valor entero que se utiliza para realizar una operación XOR bit a bit en el campo.

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

El siguiente ejemplo muestra cómo utilizar el `$bit` operador para realizar operaciones bit a bit en un campo numérico.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

En este ejemplo, el `$bit` operador se utiliza para realizar una operación AND bit a bit en el campo «numérico» del documento con un valor `_id` de 1. El resultado es que el valor del campo «numérico» se establece en 1, que es el resultado de la operación AND bit a bit entre el valor original de 5 y el valor 3.

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

Para ver un ejemplo de código para usar el `$bit` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

  await client.close();
}

main();
```

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

```
from pymongo import MongoClient

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

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

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

client.close()
```

------

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

El `$currentDate` operador se utiliza para establecer el valor de un campo en la fecha y hora actuales. Este operador es útil para actualizar automáticamente un campo con la marca de tiempo actual cuando se inserta o actualiza un documento.

**Parámetros**
+ `field`: el campo que se va a actualizar con la fecha y hora actuales.
+ `type`: (opcional) Especifica el tipo de BSON que se utilizará en la fecha actual. Puede ser `date` o `timestamp`.

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

En el siguiente ejemplo, se muestra cómo utilizar el `$currentDate` operador para establecer el `lastModified` campo en la fecha y hora actuales al insertar un documento nuevo.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Ver documento actualizado**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$currentDate` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

updateUserWithCurrentDate();
```

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

```
from pymongo import MongoClient

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

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

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

update_user_with_current_date()
```

------

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

El `$each` operador se utiliza junto con otros operadores de actualización, como `$push` y`$addToSet`, para añadir varios valores a un campo de matriz. Permite añadir varios elementos a una matriz en una sola operación, en lugar de tener que ejecutar varias operaciones de actualización.

**Parámetros**
+ `value`: La matriz de valores que se van a añadir al campo de la matriz.

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

En el siguiente ejemplo, se muestra el uso `$each` del operador con el `$push` operador para añadir varios elementos a un campo de matriz.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Ver documento actualizado**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$each` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

  await client.close();
}

example();
```

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

```
from pymongo import MongoClient

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

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

    client.close()

example()
```

------

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

El `$inc` operador se usa para incrementar el valor de un campo en una cantidad específica. Se utiliza para actualizar un campo numérico, como un contador o una calificación, sin tener que recuperar el valor actual, calcular el nuevo valor y, a continuación, actualizar el campo.

**Parámetros**
+ `field`: el nombre del campo que se va a incrementar.
+ `amount`: la cantidad en la que se va a incrementar el campo. Puede ser un valor positivo o negativo.

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

El siguiente ejemplo muestra cómo utilizar el `$inc` operador para incrementar el `age` campo de un documento.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Ver documento actualizado**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$inc` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

  console.log(result);

  await client.close();
}

updateWithInc();
```

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

```
from pymongo import MongoClient

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

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

    print(result.modified_count)

    client.close()

update_with_inc()
```

------

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

El operador de `$max` actualización actualiza el valor de un campo solo si el valor especificado es mayor que el valor del campo actual. Este operador es útil para mantener los valores máximos en todas las actualizaciones.

**Parámetros**
+ `field`: el campo que se va a actualizar.
+ `value`: el valor que se va a comparar con el valor del campo actual.

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

En el siguiente ejemplo, se muestra el uso `$max` del operador para actualizar la puntuación más alta registrada para un jugador.

**Cree documentos de muestra**

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

**Ejemplo de actualización**

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

**Resultado**

El `highScore` campo de Alice se actualiza a 95 porque 95 es mayor que el valor actual de 85.

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

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

Para ver un ejemplo de código para usar el `$max` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

example();
```

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

```
from pymongo import MongoClient

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

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

    print(result)
    client.close()

example()
```

------

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

El operador de `$min` actualización actualiza el valor de un campo solo si el valor especificado es inferior al valor del campo actual. Este operador es útil para mantener los valores mínimos en todas las actualizaciones.

**Parámetros**
+ `field`: el campo que se va a actualizar.
+ `value`: el valor que se va a comparar con el valor del campo actual.

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

El siguiente ejemplo muestra cómo utilizar el `$min` operador para actualizar la temperatura más baja registrada en una estación meteorológica.

**Cree documentos de muestra**

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

**Ejemplo de actualización**

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

**Resultado**

El `lowestTemp` campo de la estación A se actualiza a 12 porque 12 es menor que el valor actual de 15.

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

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

Para ver un ejemplo de código para usar el `$min` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

example();
```

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

```
from pymongo import MongoClient

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

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

    print(result)
    client.close()

example()
```

------

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

El `$mul` operador de Amazon DocumentDB se utiliza para multiplicar el valor de un campo por un número específico. Esto puede resultar útil para actualizar varios documentos de forma atómica y coherente, por ejemplo, para actualizar las millas de vuelo en función del estado de una tarjeta de crédito.

**Parámetros**
+ `field`: El campo que se va a multiplicar.
+ `multiplier`: el número por el que se va a multiplicar el valor del campo.

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

En este ejemplo se muestra cómo utilizar el `$mul` operador para duplicar el `flight_miles` valor de todos los documentos en los que se encuentra el `credit_card` campo. `true`

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

Para los clientes que tienen una tarjeta de crédito, sus millas de vuelo se han duplicado.

El operador de matriz `$[]` posicional se utiliza para aplicar la `$mul` operación a cada elemento de la `flight_miles` matriz.

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

Para ver un ejemplo de código para usar el `$mul` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateFlightMiles();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_flight_miles()
```

------

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

El `$pop` operador de Amazon DocumentDB se utiliza para eliminar el primer o el último elemento de un campo de matriz. Resulta especialmente útil cuando necesita mantener una matriz de tamaño fijo o implementar una estructura de datos similar a una cola en un documento.

**Parámetros**
+ `field`: el nombre del campo de matriz del que se va a eliminar un elemento.
+ `value`: un valor entero que determina la posición del elemento que se va a eliminar. Un valor de `1` elimina el último elemento, mientras que un valor de `-1` elimina el primer elemento.

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

En este ejemplo se muestra cómo utilizar el `$pop` operador para eliminar el primer y el último elemento de un campo matricial.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$pop` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

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

  await client.close();
}

example();
```

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

```
from pymongo import MongoClient

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

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

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

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

    client.close()

example()
```

------

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

El `$position` modificador de Amazon DocumentDB especifica la ubicación de la matriz en la que el operador inserta `$push` los elementos. Sin el `$position` modificador, el `$push` operador inserta elementos al final de la matriz.

**Parámetros**
+ `field`: El campo de matriz que se va a actualizar.
+ `num`: la posición de la matriz en la que se deben insertar los elementos, según la indexación basada en cero.

**Nota**: Para usar el `$position` modificador, debe aparecer junto con el modificador. `$each`

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

El siguiente ejemplo demuestra cómo utilizar el `$position` operador para insertar tareas en posiciones específicas de un sistema de gestión de proyectos.

**Cree documentos de muestra**

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

**Ejemplo de consulta 1: añadir tareas urgentes al principio**

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

**Resultado 1**

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

**Ejemplo de consulta 2: añadir tareas en una posición específica**

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

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

**Resultado 2**

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

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

Para ver un ejemplo de código para usar el `$position` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

insertTasksAtPosition();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

insert_tasks_at_position()
```

------

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

El `$pull` operador se utiliza para eliminar de una matriz todas las instancias de un valor o valores que coincidan con una condición especificada. Este operador resulta útil cuando se necesitan eliminar elementos específicos de un campo matricial de un documento.

**Parámetros**
+ `field`: el nombre del campo de matriz del que se van a eliminar los valores.
+ `value`: el valor o la condición que determina los elementos que se van a eliminar de la matriz.

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

En el siguiente ejemplo, se muestra cómo utilizar el `$pull` operador para eliminar elementos de un campo matricial.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

La consulta anterior elimina la función «Comida para llevar» de todos los documentos en los que el `cuisine` campo es «italiano».

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

Para ver un ejemplo de código para usar el `$pull` comando, selecciona la pestaña correspondiente al idioma que deseas usar:

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

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

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

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

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

  await client.close();
}

updateRestaurants();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_restaurants()
```

------

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

El `$pullAll` operador de Amazon DocumentDB se utiliza para eliminar todas las instancias de los valores especificados de un campo de matriz. Esto resulta especialmente útil cuando necesita eliminar varios elementos de una matriz en una sola operación.

**Parámetros**
+ `field`: el nombre del campo de matriz del que se van a eliminar los elementos.
+ `value`: una matriz de valores para eliminar del campo de matriz.

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

El siguiente ejemplo muestra cómo utilizar el `$pullAll` operador para eliminar varios elementos de un campo matricial.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$pullAll` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

main();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

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

------

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

El `$push` operador de Amazon DocumentDB se utiliza para añadir un elemento a un campo de matriz de un documento. Este operador resulta especialmente útil cuando necesita añadir nuevos datos a una matriz existente sin sobrescribir toda la matriz.

**Parámetros**
+ `field`: el nombre del campo de matriz al que se debe añadir el nuevo elemento.
+ `value`: El valor que se va a añadir a la matriz.
+ `position`: (opcional) Un modificador que especifica la posición de la matriz en la que se debe añadir el nuevo elemento. Los modificadores admitidos incluyen `$` (añadir al final de la matriz) y `$[]` (añadir al final de la matriz, ignorando cualquier filtro de matriz).

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

El siguiente ejemplo muestra cómo utilizar el `$push` operador para añadir nuevos elementos a un campo matricial de un documento.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

Tras ejecutar la actualización, el documento con la `hobbies` matriz se `_id: 1` actualizará a`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

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

Para ver un ejemplo de código para usar el `$push` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

    print(result.raw_result)
    client.close()

update_document()
```

------

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

El `$rename` operador de Amazon DocumentDB se utiliza para cambiar el nombre de un campo de un documento. Este operador puede resultar especialmente útil cuando necesita actualizar la estructura de sus documentos o alinearlos con nuevos modelos de datos.

**Parámetros**
+ `field`: el campo al que se va a cambiar el nombre.
+ `newName`: el nuevo nombre del campo.

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

En el siguiente ejemplo se muestra cómo utilizar el `$rename` operador para cambiar el nombre del `&quot;Date.DoW&quot;` campo a `&quot;Date.DayOfWeek&quot;` en un documento con el `&quot;DocName&quot;` campo establecido en. `&quot;Document 1&quot;`

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$rename` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

    await client.close();
}

example();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

example()
```

------

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

El `$set` operador de Amazon DocumentDB se utiliza para actualizar el valor de un campo específico de un documento. Este operador le permite añadir nuevos campos o modificar los existentes en un documento. Es un operador de actualización fundamental en el controlador Java de MongoDB, que es compatible con Amazon DocumentDB.

**Parámetros**
+ `field`: El campo que se va a actualizar.
+ `value`: el nuevo valor del campo.

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

En el siguiente ejemplo, se muestra cómo utilizar el `$set` operador para actualizar el `Item` campo de un documento.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el `$set` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El `$setOnInsert` operador de Amazon DocumentDB se utiliza para establecer el valor de un campo si se está insertando un documento, pero no tiene ningún efecto si el documento se está actualizando.

**Parámetros**
+ `field`: El campo que se va a configurar.
+ `value`: el valor que se va a asignar al campo.

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

En el siguiente ejemplo, se muestra el uso del `$setOnInsert` operador en Amazon DocumentDB. Crea un documento nuevo si el documento aún no existe, pero no tiene ningún efecto si el documento se está actualizando.

**Crea documentos de muestra**

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

**Ejemplo de consulta 1: Actualizar un documento existente**

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

**Resultado 1**

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

El resultado muestra que el documento se actualizó, pero el `createdAt` campo **NO se agregó** porque el documento ya existía. El `$setOnInsert` operador solo se aplica al insertar documentos nuevos.

**Ejemplo de consulta 2: Insertar un documento nuevo (parte superior)**

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

**Salida 2**

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

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

Para ver un ejemplo de código para usar el `$setOnInsert` comando, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateWithSetOnInsert();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_with_set_on_insert()
```

------

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

El operador de `$slice` actualización modifica una matriz limitando su tamaño. Cuando se usa con el `$push` operador, restringe el número de elementos de una matriz y mantiene solo el número especificado de elementos más recientes o más antiguos.

**Parámetros**
+ `field`: el campo de matriz que se va a modificar.
+ `count`: Número máximo de elementos que se deben conservar. Los valores positivos mantienen los primeros N elementos, los valores negativos mantienen los N últimos elementos.

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

El siguiente ejemplo demuestra cómo utilizar el operador de `$slice` actualización con `$push` para mantener una matriz de partituras recientes de tamaño fijo.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

En este ejemplo, el `$slice: -3` modificador conserva solo los tres últimos elementos después de introducir nuevos valores en la matriz.

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

Para ver un ejemplo de código para usar el operador de `$slice` actualización, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El modificador de `$sort` actualización ordena los elementos de la matriz cuando se usa con el `$push` operador. Organiza los elementos de la matriz en orden ascendente o descendente en función de los valores de campo especificados o de los propios elementos.

**Parámetros**
+ `field`: El campo de matriz que se va a modificar.
+ `order`: Se utiliza `1` en orden ascendente o `-1` descendente.

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

En el siguiente ejemplo, se muestra el uso del `$sort` modificador con `$push` para añadir nuevas puntuaciones a las pruebas y mantenerlas ordenadas en orden descendente.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

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

Para ver un ejemplo de código para usar el modificador de `$sort` actualización, elija la pestaña del idioma que desee usar:

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

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

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

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

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

  await client.close();
}

updateDocument();
```

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

```
from pymongo import MongoClient

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

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

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

    client.close()

update_document()
```

------

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

El `$unset` operador de Amazon DocumentDB se utiliza para eliminar un campo específico de un documento. Cuando se elimina un campo utilizando`$unset`, el campo se elimina del documento y el tamaño del documento se reduce en consecuencia. Esto puede resultar útil cuando desee eliminar datos innecesarios de sus documentos.

**Parámetros**
+ `field`: el campo que se va a eliminar del documento. Puede ser un campo único o una ruta punteada que lleve a un campo anidado.

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

El siguiente ejemplo muestra cómo utilizar el `$unset` operador para eliminar el `Words` campo de un documento de la `example` colección.

**Cree documentos de muestra**

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

**Ejemplo de consulta**

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

**Salida**

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

En este ejemplo, el `$unset` operador se utiliza para eliminar el `Words` campo del documento con `DocName` el valor «Documento 1". El documento resultante ya no contiene el `Words` campo.

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

Para ver un ejemplo de código para usar el `$unset` comando, elija la pestaña correspondiente al idioma que desee usar:

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

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

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

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

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

removeField();
```

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

```
from pymongo import MongoClient

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

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

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

remove_field()
```

------