Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Operatoren aktualisieren
<a name="mongo-apis-update-operators"></a>

Dieser Abschnitt enthält detaillierte Informationen zu Aktualisierungsoperatoren, die von Amazon DocumentDB unterstützt werden.

**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>

Der `$` Positionsoperator aktualisiert das erste Array-Element, das der Abfragebedingung entspricht. Er dient als Platzhalter für die Position des übereinstimmenden Array-Elements.

**Parameter**
+ `field.$`: Das Array-Feld mit dem Positionsoperator zur Aktualisierung des ersten passenden Elements.

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

Das folgende Beispiel zeigt, wie der `$` Positionsoperator verwendet wird, um ein bestimmtes Array-Element zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

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

Um ein Codebeispiel für die Verwendung des `$` Positionsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$[]` All-Position-Operator aktualisiert alle Elemente in einem Array. Er wird verwendet, wenn Sie jedes Element in einem Array-Feld ändern müssen.

**Parameter**
+ `field.$[]`: Das Array-Feld mit dem All-Position-Operator zur Aktualisierung aller Elemente.

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

Das folgende Beispiel zeigt, wie der `$[]` Operator verwendet wird, um alle Array-Elemente zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

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

Um ein Codebeispiel für die Verwendung des `$[]` Operators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$[<identifier>]` gefilterte Positionsoperator aktualisiert alle Array-Elemente, die den angegebenen Filterbedingungen entsprechen. Er wird mit der `arrayFilters` Option verwendet, Array-Elemente selektiv zu aktualisieren.

**Parameter**
+ `field.$[identifier]`: Das Array-Feld mit dem gefilterten Positionsoperator.
+ `arrayFilters`: Eine Reihe von Filterbedingungen, die bestimmen, welche Elemente aktualisiert werden sollen.

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

Das folgende Beispiel zeigt, wie der `$[<identifier>]` Operator verwendet wird, um bestimmte Array-Elemente auf der Grundlage einer Bedingung zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

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

Um ein Codebeispiel für die Verwendung des `$[<identifier>]` Operators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$addToSet` Operator in Amazon DocumentDB wird nur verwendet, um einem Array einen Wert hinzuzufügen, wenn der Wert nicht bereits im Array vorhanden ist. Dies ist nützlich, um sicherzustellen, dass ein Array eindeutige Elemente enthält.

**Parameter**
+ `field`: Das zu aktualisierende Feld.
+ `value`: Der Wert, der dem Array-Feld hinzugefügt werden soll. Dies kann ein einzelner Wert oder ein Ausdruck sein.

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

Das folgende Beispiel zeigt, wie der `$addToSet` Operator verwendet wird, um einem Array eindeutige Elemente hinzuzufügen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

In diesem Beispiel fügt der `$addToSet` Operator das Tag „green“ zum Array „tags“ des Dokuments hinzu, wobei das Feld „item“ den Wert „apple“ hat. Da „grün“ noch nicht im Array enthalten war, wurde es hinzugefügt.

## Codebeispiele
<a name="addToSet-code"></a>

Um ein Codebeispiel für die Verwendung des `$addToSet` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$bit` Operator in Amazon DocumentDB ermöglicht es Ihnen, bitweise Operationen an den Bits eines bestimmten Feldes durchzuführen. Dies kann für Aufgaben wie das Setzen, Löschen oder Überprüfen des Zustands einzelner Bits innerhalb einer Zahl nützlich sein.

**Parameter**
+ `field`: Das Feld, in dem bitweise Operationen ausgeführt werden sollen.
+ `and`: Ein ganzzahliger Wert, der verwendet wird, um eine bitweise UND-Operation für das Feld durchzuführen.
+ `or`: Ein ganzzahliger Wert, der verwendet wird, um eine bitweise OR-Operation für das Feld durchzuführen.
+ `xor`: Ein ganzzahliger Wert, der verwendet wird, um eine bitweise XOR-Operation für das Feld durchzuführen.

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

Das folgende Beispiel zeigt, wie der `$bit` Operator verwendet wird, um bitweise Operationen an einem numerischen Feld durchzuführen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

In diesem Beispiel wird der `$bit` Operator verwendet, um eine bitweise UND-Operation für das Feld „Zahl“ des Dokuments mit dem `_id` Wert 1 durchzuführen. Das Ergebnis ist, dass der Wert des Felds „Zahl“ auf 1 gesetzt wird, was das Ergebnis der bitweisen UND-Operation zwischen dem ursprünglichen Wert 5 und dem Wert 3 ist.

## Codebeispiele
<a name="bit-code"></a>

Um ein Codebeispiel für die Verwendung des `$bit` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$currentDate` Operator wird verwendet, um den Wert eines Felds auf das aktuelle Datum und die aktuelle Uhrzeit festzulegen. Dieser Operator ist nützlich, um ein Feld automatisch mit dem aktuellen Zeitstempel zu aktualisieren, wenn ein Dokument eingefügt oder aktualisiert wird.

**Parameter**
+ `field`: Das Feld, das mit dem aktuellen Datum und der aktuellen Uhrzeit aktualisiert werden soll.
+ `type`: (optional) Gibt den BSON-Typ an, der für das aktuelle Datum verwendet werden soll. Kann `date` oder `timestamp` sein.

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

Das folgende Beispiel zeigt, wie der `$currentDate` Operator verwendet wird, um das `lastModified` Feld auf das aktuelle Datum und die aktuelle Uhrzeit einzustellen, wenn ein neues Dokument eingefügt wird.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Aktualisiertes Dokument anzeigen**

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

**Ausgabe**

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

## Codebeispiele
<a name="currentDate-code"></a>

Um ein Codebeispiel für die Verwendung des `$currentDate` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$each` Operator wird in Verbindung mit anderen Aktualisierungsoperatoren wie `$push` und verwendet`$addToSet`, um einem Array-Feld mehrere Werte hinzuzufügen. Es ermöglicht das Hinzufügen mehrerer Elemente zu einem Array in einem einzigen Vorgang, anstatt mehrere Aktualisierungsvorgänge ausführen zu müssen.

**Parameter**
+ `value`: Das Array von Werten, die dem Array-Feld hinzugefügt werden sollen.

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

Das folgende Beispiel zeigt, wie der `$each` Operator zusammen mit dem `$push` Operator verwendet wird, um einem Array-Feld mehrere Elemente hinzuzufügen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Aktualisiertes Dokument anzeigen**

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

**Ausgabe**

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

## Codebeispiele
<a name="each-code"></a>

Um ein Codebeispiel für die Verwendung des `$each` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$inc` Operator wird verwendet, um den Wert eines Felds um einen bestimmten Betrag zu erhöhen. Er wird verwendet, um ein numerisches Feld, z. B. einen Zähler oder eine Bewertung, zu aktualisieren, ohne dass der aktuelle Wert abgerufen, der neue Wert berechnet und das Feld anschließend aktualisiert werden muss.

**Parameter**
+ `field`: Der Name des Feldes, das erhöht werden soll.
+ `amount`: Der Betrag, um den das Feld erhöht werden soll. Dies kann ein positiver oder negativer Wert sein.

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

Das folgende Beispiel zeigt, wie der `$inc` Operator verwendet wird, um das `age` Feld eines Dokuments zu erhöhen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Aktualisiertes Dokument anzeigen**

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

**Ausgabe**

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

## Codebeispiele
<a name="inc-code"></a>

Um ein Codebeispiel für die Verwendung des `$inc` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$max` Aktualisierungsoperator aktualisiert den Wert eines Felds nur, wenn der angegebene Wert größer als der aktuelle Feldwert ist. Dieser Operator ist nützlich, um Maximalwerte bei Aktualisierungen beizubehalten.

**Parameter**
+ `field`: Das zu aktualisierende Feld.
+ `value`: Der Wert, der mit dem aktuellen Feldwert verglichen werden soll.

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

Das folgende Beispiel zeigt, wie der `$max` Operator verwendet wird, um die höchste aufgezeichnete Punktzahl für einen Spieler zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel aktualisieren**

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

**Ergebnis**

Das `highScore` Feld für Alice wird auf 95 aktualisiert, weil 95 größer als der aktuelle Wert von 85 ist.

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

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

Um ein Codebeispiel für die Verwendung des `$max` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$min` Aktualisierungsoperator aktualisiert den Wert eines Felds nur, wenn der angegebene Wert kleiner als der aktuelle Feldwert ist. Dieser Operator ist nützlich, um Mindestwerte bei Aktualisierungen beizubehalten.

**Parameter**
+ `field`: Das zu aktualisierende Feld.
+ `value`: Der Wert, der mit dem aktuellen Feldwert verglichen werden soll.

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

Das folgende Beispiel zeigt, wie der `$min` Operator verwendet wird, um die niedrigste gemessene Temperatur für eine Wetterstation zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel aktualisieren**

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

**Ergebnis**

Das `lowestTemp` Feld für Station A wird auf 12 aktualisiert, weil 12 kleiner als der aktuelle Wert von 15 ist.

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

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

Um ein Codebeispiel für die Verwendung des `$min` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$mul` Operator in Amazon DocumentDB wird verwendet, um den Wert eines Felds mit einer bestimmten Zahl zu multiplizieren. Dies kann nützlich sein, um mehrere Dokumente automatisch und konsistent zu aktualisieren, z. B. um Flugmeilen auf der Grundlage eines Kreditkartenstatus zu aktualisieren.

**Parameter**
+ `field`: Das Feld, das multipliziert werden soll.
+ `multiplier`: Die Zahl, mit der der Feldwert multipliziert werden soll.

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

Dieses Beispiel zeigt, wie der `$mul` Operator verwendet wird, um den `flight_miles` Wert für alle Dokumente zu verdoppeln, in denen sich das `credit_card` Feld befindet`true`.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

Für Kunden, die eine Kreditkarte besitzen, wurden ihre Flugmeilen verdoppelt.

Der `$[]` Positions-Array-Operator wird verwendet, um die `$mul` Operation auf jedes Element im `flight_miles` Array anzuwenden.

## Codebeispiele
<a name="mul-code"></a>

Um ein Codebeispiel für die Verwendung des `$mul` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$pop` Operator in Amazon DocumentDB wird verwendet, um das erste oder letzte Element aus einem Array-Feld zu entfernen. Dies ist besonders nützlich, wenn Sie ein Array mit fester Größe verwalten oder eine warteschlangenartige Datenstruktur innerhalb eines Dokuments implementieren müssen.

**Parameter**
+ `field`: Der Name des Array-Felds, aus dem ein Element entfernt werden soll.
+ `value`: Ein ganzzahliger Wert, der die Position des zu entfernenden Elements bestimmt. Ein Wert von `1` entfernt das letzte Element, während ein Wert von das erste Element `-1` entfernt.

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

Dieses Beispiel zeigt, wie der `$pop` Operator verwendet wird, um das erste und das letzte Element aus einem Array-Feld zu entfernen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

## Codebeispiele
<a name="pop-code"></a>

Um ein Codebeispiel für die Verwendung des `$pop` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$position` Modifikator in Amazon DocumentDB gibt die Position im Array an, an der der `$push` Operator Elemente einfügt. Ohne den `$position` Modifikator fügt der `$push` Operator Elemente am Ende des Arrays ein.

**Parameter**
+ `field`: Das zu aktualisierende Array-Feld.
+ `num`: Die Position im Array, an der Elemente eingefügt werden sollen, basierend auf einer Nullindizierung.

**Hinweis**: Um den `$position` Modifikator verwenden zu können, muss er zusammen mit dem Modifikator erscheinen. `$each`

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

Das folgende Beispiel zeigt, wie der `$position` Operator verwendet wird, um Aufgaben an bestimmten Positionen in einem Projektmanagementsystem einzufügen.

**Erstellen Sie Beispieldokumente**

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

**Abfragebeispiel 1 — Fügen Sie am Anfang dringende Aufgaben hinzu**

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

**Ausgang 1**

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

**Abfragebeispiel 2 — Aufgaben an einer bestimmten Position hinzufügen**

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

**Ausgabe 2**

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

## Codebeispiele
<a name="position-code"></a>

Um ein Codebeispiel für die Verwendung des `$position` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$pull` Operator wird verwendet, um alle Instanzen eines Werts oder von Werten, die einer bestimmten Bedingung entsprechen, aus einem Array zu entfernen. Dieser Operator ist nützlich, wenn Sie bestimmte Elemente aus einem Array-Feld innerhalb eines Dokuments entfernen müssen.

**Parameter**
+ `field`: Der Name des Array-Feldes, aus dem die Werte entfernt werden sollen.
+ `value`: Der Wert oder die Bedingung, die bestimmt, welche Elemente aus dem Array entfernt werden sollen.

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

Das folgende Beispiel zeigt, wie der `$pull` Operator verwendet wird, um Elemente aus einem Array-Feld zu entfernen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

Die obige Abfrage entfernt die Funktion „Mitnehmen“ aus allen Dokumenten, in denen das `cuisine` Feld „Italienisch“ ist.

## Codebeispiele
<a name="pull-code"></a>

Um ein Codebeispiel für die Verwendung des `$pull` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$pullAll` Operator in Amazon DocumentDB wird verwendet, um alle Instanzen der angegebenen Werte aus einem Array-Feld zu entfernen. Dies ist besonders nützlich, wenn Sie in einem einzigen Vorgang mehrere Elemente aus einem Array entfernen müssen.

**Parameter**
+ `field`: Der Name des Array-Feldes, aus dem die Elemente entfernt werden sollen.
+ `value`: Eine Reihe von Werten, die aus dem Array-Feld entfernt werden sollen.

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

Das folgende Beispiel zeigt, wie der `$pullAll` Operator verwendet wird, um mehrere Elemente aus einem Array-Feld zu entfernen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

## Codebeispiele
<a name="pullAll-code"></a>

Um ein Codebeispiel für die Verwendung des `$pullAll` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$push` Operator in Amazon DocumentDB wird verwendet, um ein Element zu einem Array-Feld in einem Dokument hinzuzufügen. Dieser Operator ist besonders nützlich, wenn Sie neue Daten an ein vorhandenes Array anhängen müssen, ohne das gesamte Array zu überschreiben.

**Parameter**
+ `field`: Der Name des Array-Feldes, zu dem das neue Element hinzugefügt werden soll.
+ `value`: Der Wert, der dem Array hinzugefügt werden soll.
+ `position`: (optional) Ein Modifikator, der die Position im Array angibt, an der das neue Element hinzugefügt werden soll. Zu den unterstützten Modifikatoren gehören `$` (am Ende des Arrays hinzufügen) und `$[]` (am Ende des Arrays hinzufügen, dabei alle Array-Filter ignorieren).

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

Das folgende Beispiel zeigt, wie der `$push` Operator verwendet wird, um einem Array-Feld in einem Dokument neue Elemente hinzuzufügen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

Nach dem Ausführen des Updates `_id: 1` wird das `hobbies` Array für das Dokument mit aktualisiert`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

## Codebeispiele
<a name="push-code"></a>

Um ein Codebeispiel für die Verwendung des `$push` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$rename` Operator in Amazon DocumentDB wird verwendet, um ein Feld in einem Dokument umzubenennen. Dieser Operator kann besonders nützlich sein, wenn Sie die Struktur Ihrer Dokumente aktualisieren oder sie an neue Datenmodelle anpassen müssen.

**Parameter**
+ `field`: Das Feld, das umbenannt werden soll.
+ `newName`: Der neue Name für das Feld.

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

Das folgende Beispiel zeigt, wie Sie den `$rename` Operator verwenden, um das `&quot;Date.DoW&quot;` Feld `&quot;Date.DayOfWeek&quot;` in einem Dokument umzubenennen, in dem das `&quot;DocName&quot;` Feld auf `&quot;Document 1&quot;` gesetzt ist.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

## Codebeispiele
<a name="rename-code"></a>

Um ein Codebeispiel für die Verwendung des `$rename` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$set` Operator in Amazon DocumentDB wird verwendet, um den Wert eines bestimmten Felds in einem Dokument zu aktualisieren. Mit diesem Operator können Sie neue Felder hinzufügen oder bestehende Felder innerhalb eines Dokuments ändern. Es ist ein grundlegender Aktualisierungsoperator im MongoDB-Java-Treiber, der mit Amazon DocumentDB kompatibel ist.

**Parameter**
+ `field`: Das zu aktualisierende Feld.
+ `value`: Der neue Wert für das Feld.

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

Das folgende Beispiel zeigt, wie der `$set` Operator verwendet wird, um das `Item` Feld in einem Dokument zu aktualisieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

## Codebeispiele
<a name="set-code"></a>

Um ein Codebeispiel für die Verwendung des `$set` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$setOnInsert` Operator in Amazon DocumentDB wird verwendet, um den Wert eines Felds festzulegen, wenn ein Dokument eingefügt wird. Er hat jedoch keine Auswirkung, wenn das Dokument aktualisiert wird.

**Parameter**
+ `field`: Das Feld, das festgelegt werden soll.
+ `value`: Der Wert, der dem Feld zugewiesen werden soll.

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

Das folgende Beispiel zeigt die Verwendung des `$setOnInsert` Operators in Amazon DocumentDB. Es erstellt ein neues Dokument, wenn das Dokument noch nicht existiert, hat aber keine Auswirkung, wenn das Dokument aktualisiert wird.

**Erstellen Sie Beispieldokumente**

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

**Abfragebeispiel 1 — Bestehendes Dokument aktualisieren**

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

**Ausgabe 1**

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

Die Ausgabe zeigt, dass das Dokument aktualisiert wurde, das `createdAt` Feld jedoch **NICHT hinzugefügt** wurde, da das Dokument bereits vorhanden war. Der `$setOnInsert` Operator gilt nur beim Einfügen neuer Dokumente.

**Abfragebeispiel 2 — Neues Dokument einfügen (upsert)**

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

**Ausgabe 2**

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

## Codebeispiele
<a name="setOnInsert-code"></a>

Um ein Codebeispiel für die Verwendung des `$setOnInsert` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$slice` Aktualisierungsoperator ändert ein Array, indem er seine Größe begrenzt. Wenn er zusammen mit dem `$push` Operator verwendet wird, schränkt er die Anzahl der Elemente in einem Array ein und behält nur die angegebene Anzahl der neuesten oder ältesten Elemente bei.

**Parameter**
+ `field`: Das zu ändernde Array-Feld.
+ `count`: Maximale Anzahl von Elementen, die beibehalten werden sollen. Positive Werte behalten die ersten N Elemente, negative Werte behalten die letzten N Elemente.

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

Das folgende Beispiel zeigt, wie der `$slice` Aktualisierungsoperator with verwendet wird`$push`, um ein Array mit fester Größe mit aktuellen Ergebnissen zu verwalten.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

In diesem Beispiel behält der `$slice: -3` Modifikator nur die letzten drei Elemente bei, nachdem er neue Werte in das Array übertragen hat.

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

Um ein Codebeispiel für die Verwendung des `$slice` Aktualisierungsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$sort` Aktualisierungsmodifikator ordnet Array-Elemente an, wenn er zusammen mit dem `$push` Operator verwendet wird. Er ordnet Array-Elemente auf der Grundlage der angegebenen Feldwerte oder der Elemente selbst in aufsteigender oder absteigender Reihenfolge an.

**Parameter**
+ `field`: Das zu ändernde Array-Feld.
+ `order`: Wird `1` für aufsteigende oder `-1` absteigende Reihenfolge verwendet.

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

Das folgende Beispiel zeigt, wie der `$sort` Modifikator mit verwendet wird`$push`, um neue Quizergebnisse hinzuzufügen und sie in absteigender Reihenfolge zu sortieren.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

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

Um ein Codebeispiel für die Verwendung des `$sort` Aktualisierungsmodifikators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

Der `$unset` Operator in Amazon DocumentDB wird verwendet, um ein bestimmtes Feld aus einem Dokument zu entfernen. Wenn ein Feld mit entfernt wird`$unset`, wird das Feld aus dem Dokument gelöscht, und die Dokumentgröße wird entsprechend reduziert. Dies kann nützlich sein, wenn Sie unnötige Daten aus Ihren Dokumenten entfernen möchten.

**Parameter**
+ `field`: Das Feld, das aus dem Dokument entfernt werden soll. Dies kann ein einzelnes Feld oder ein gepunkteter Pfad zu einem verschachtelten Feld sein.

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

Das folgende Beispiel zeigt, wie der `$unset` Operator verwendet wird, um das `Words` Feld aus einem Dokument in der `example` Sammlung zu entfernen.

**Erstellen Sie Beispieldokumente**

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

**Beispiel für eine Abfrage**

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

**Ausgabe**

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

In diesem Beispiel wird der `$unset` Operator verwendet, um das `Words` Feld aus dem Dokument zu entfernen, das „Dokument 1" `DocName` entspricht. Das resultierende Dokument enthält das `Words` Feld nicht mehr.

## Codebeispiele
<a name="unset-code"></a>

Um ein Codebeispiel für die Verwendung des `$unset` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

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

------