Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Perbarui operator
<a name="mongo-apis-update-operators"></a>

Bagian ini memberikan informasi terperinci tentang operator pembaruan yang didukung oleh 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>

Operator `$` posisi memperbarui elemen array pertama yang cocok dengan kondisi kueri. Ini bertindak sebagai placeholder untuk posisi elemen array yang cocok.

**Parameter**
+ `field.$`: Bidang array dengan operator posisi untuk memperbarui elemen pencocokan pertama.

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

Contoh berikut menunjukkan menggunakan operator `$` posisi untuk memperbarui elemen array tertentu.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

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

Untuk melihat contoh kode untuk menggunakan operator `$` posisi, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Operator `$[]` semua posisi memperbarui semua elemen dalam array. Hal ini digunakan ketika Anda perlu memodifikasi setiap elemen dalam bidang array.

**Parameter**
+ `field.$[]`: Bidang array dengan operator semua posisi untuk memperbarui semua elemen.

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

Contoh berikut menunjukkan menggunakan `$[]` operator untuk memperbarui semua elemen array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

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

Untuk melihat contoh kode untuk menggunakan `$[]` operator, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Operator posisi yang `$[<identifier>]` difilter memperbarui semua elemen array yang cocok dengan kondisi filter yang ditentukan. Hal ini digunakan dengan `arrayFilters` pilihan untuk selektif memperbarui elemen array.

**Parameter**
+ `field.$[identifier]`: Bidang array dengan operator posisi yang disaring.
+ `arrayFilters`: Array kondisi filter yang menentukan elemen mana yang akan diperbarui.

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

Contoh berikut menunjukkan menggunakan `$[<identifier>]` operator untuk memperbarui elemen array tertentu berdasarkan kondisi.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

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

Untuk melihat contoh kode untuk menggunakan `$[<identifier>]` operator, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$addToSet`Operator di Amazon DocumentDB digunakan untuk menambahkan nilai ke array hanya jika nilainya belum ada dalam array. Ini berguna untuk memastikan bahwa array berisi elemen unik.

**Parameter**
+ `field`: Bidang untuk memperbarui.
+ `value`: Nilai untuk ditambahkan ke bidang array. Ini bisa berupa nilai tunggal atau ekspresi.

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

Contoh berikut menunjukkan bagaimana menggunakan `$addToSet` operator untuk menambahkan elemen unik ke array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Dalam contoh ini, `$addToSet` operator menambahkan tag “hijau” ke array “tag” dokumen di mana bidang “item” adalah “apel”. Karena “hijau” belum ada dalam array, itu ditambahkan.

## Contoh kode
<a name="addToSet-code"></a>

Untuk melihat contoh kode untuk menggunakan `$addToSet` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$bit`Operator di Amazon DocumentDB memungkinkan Anda melakukan operasi bitwise pada bit bidang tertentu. Ini dapat berguna untuk tugas-tugas seperti pengaturan, pembersihan, atau memeriksa status bit individu dalam angka.

**Parameter**
+ `field`: Bidang untuk melakukan operasi bitwise pada.
+ `and`: Nilai integer yang digunakan untuk melakukan operasi AND bitwise di lapangan.
+ `or`: Nilai integer yang digunakan untuk melakukan operasi OR bitwise di lapangan.
+ `xor`: Nilai integer yang digunakan untuk melakukan operasi XOR bitwise di lapangan.

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

Contoh berikut menunjukkan bagaimana menggunakan `$bit` operator untuk melakukan operasi bitwise pada bidang numerik.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Dalam contoh ini, `$bit` operator digunakan untuk melakukan operasi bitwise AND pada bidang “angka” dokumen dengan 1. `_id` Hasilnya adalah bahwa nilai bidang “angka” diatur ke 1, yang merupakan hasil dari operasi bitwise AND antara nilai asli 5 dan nilai 3.

## Contoh kode
<a name="bit-code"></a>

Untuk melihat contoh kode untuk menggunakan `$bit` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$currentDate`Operator digunakan untuk mengatur nilai bidang ke tanggal dan waktu saat ini. Operator ini berguna untuk memperbarui bidang secara otomatis dengan stempel waktu saat ini ketika dokumen dimasukkan atau diperbarui.

**Parameter**
+ `field`: Bidang untuk memperbarui dengan tanggal dan waktu saat ini.
+ `type`: (opsional) Menentukan jenis BSON untuk digunakan untuk tanggal saat ini. Bisa salah satu `date` atau`timestamp`.

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

Contoh berikut menunjukkan cara menggunakan `$currentDate` operator untuk mengatur `lastModified` bidang ke tanggal dan waktu saat ini ketika dokumen baru dimasukkan.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Lihat dokumen yang diperbarui**

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

**Keluaran**

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

## Contoh kode
<a name="currentDate-code"></a>

Untuk melihat contoh kode untuk menggunakan `$currentDate` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$each`Operator digunakan bersama dengan operator pembaruan lainnya, seperti `$push` dan`$addToSet`, untuk menambahkan beberapa nilai ke bidang array. Ini memungkinkan menambahkan beberapa elemen ke array dalam satu operasi, daripada harus menjalankan beberapa operasi pembaruan.

**Parameter**
+ `value`: Array nilai untuk ditambahkan ke bidang array.

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

Contoh berikut menunjukkan menggunakan `$each` operator dengan `$push` operator untuk menambahkan beberapa elemen ke bidang array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Lihat dokumen yang diperbarui**

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

**Keluaran**

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

## Contoh kode
<a name="each-code"></a>

Untuk melihat contoh kode untuk menggunakan `$each` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$inc`Operator digunakan untuk menambah nilai bidang dengan jumlah tertentu. Ini digunakan untuk memperbarui bidang numerik, seperti penghitung atau peringkat, tanpa harus mengambil nilai saat ini, menghitung nilai baru, dan kemudian memperbarui bidang.

**Parameter**
+ `field`: Nama bidang untuk kenaikan.
+ `amount`: Jumlah yang digunakan untuk menambah bidang. Ini bisa menjadi nilai positif atau negatif.

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

Contoh berikut menunjukkan bagaimana menggunakan `$inc` operator untuk menambah `age` bidang dokumen.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Lihat dokumen yang diperbarui**

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

**Keluaran**

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

## Contoh kode
<a name="inc-code"></a>

Untuk melihat contoh kode untuk menggunakan `$inc` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Operator `$max` pembaruan memperbarui nilai bidang hanya jika nilai yang ditentukan lebih besar dari nilai bidang saat ini. Operator ini berguna untuk mempertahankan nilai maksimum di seluruh pembaruan.

**Parameter**
+ `field`: Bidang untuk memperbarui.
+ `value`: Nilai untuk membandingkan dengan nilai bidang saat ini.

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

Contoh berikut menunjukkan menggunakan `$max` operator untuk memperbarui skor tertinggi yang tercatat untuk pemain.

**Buat dokumen sampel**

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

**Perbarui contoh**

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

**Hasil**

`highScore`Bidang untuk Alice diperbarui menjadi 95 karena 95 lebih besar dari nilai saat ini 85.

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

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

Untuk melihat contoh kode untuk menggunakan `$max` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Operator `$min` pembaruan memperbarui nilai bidang hanya jika nilai yang ditentukan kurang dari nilai bidang saat ini. Operator ini berguna untuk mempertahankan nilai minimum di seluruh pembaruan.

**Parameter**
+ `field`: Bidang untuk memperbarui.
+ `value`: Nilai untuk membandingkan dengan nilai bidang saat ini.

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

Contoh berikut menunjukkan menggunakan `$min` operator untuk memperbarui suhu terendah yang tercatat untuk stasiun cuaca.

**Buat dokumen sampel**

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

**Perbarui contoh**

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

**Hasil**

`lowestTemp`Bidang untuk Stasiun A diperbarui ke 12 karena 12 kurang dari nilai saat ini 15.

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

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

Untuk melihat contoh kode untuk menggunakan `$min` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$mul`Operator di Amazon DocumentDB digunakan untuk mengalikan nilai bidang dengan nomor tertentu. Ini dapat berguna untuk memperbarui beberapa dokumen secara atomik dan konsisten, seperti memperbarui mil penerbangan berdasarkan status kartu kredit.

**Parameter**
+ `field`: Bidang yang akan dikalikan.
+ `multiplier`: Angka untuk mengalikan nilai bidang dengan.

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

Contoh ini menunjukkan bagaimana menggunakan `$mul` operator untuk menggandakan `flight_miles` nilai untuk semua dokumen di mana `credit_card` bidang tersebut`true`.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Untuk pelanggan yang memiliki kartu kredit, mil penerbangan mereka telah berlipat ganda.

Operator array `$[]` posisional digunakan untuk menerapkan `$mul` operasi ke setiap elemen dalam `flight_miles` array.

## Contoh kode
<a name="mul-code"></a>

Untuk melihat contoh kode untuk menggunakan `$mul` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$pop`Operator di Amazon DocumentDB digunakan untuk menghapus elemen pertama atau terakhir dari bidang array. Ini sangat berguna ketika Anda perlu mempertahankan array ukuran tetap atau menerapkan struktur data seperti antrian dalam dokumen.

**Parameter**
+ `field`: Nama bidang array untuk menghapus elemen dari.
+ `value`: Nilai integer yang menentukan posisi elemen untuk menghapus. Nilai `1` menghapus elemen terakhir, sementara nilai `-1` menghapus elemen pertama.

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

Contoh ini menunjukkan bagaimana menggunakan `$pop` operator untuk menghapus elemen pertama dan terakhir dari bidang array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

## Contoh kode
<a name="pop-code"></a>

Untuk melihat contoh kode untuk menggunakan `$pop` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$position`Pengubah di Amazon DocumentDB menentukan lokasi dalam array di `$push` mana operator menyisipkan elemen. Tanpa `$position` modifier, `$push` operator menyisipkan elemen ke akhir array.

**Parameter**
+ `field`: Bidang array untuk memperbarui.
+ `num`: Posisi dalam array di mana elemen harus dimasukkan, berdasarkan pengindeksan berbasis nol.

**Catatan**: Untuk menggunakan `$position` pengubah, itu harus muncul dengan `$each` pengubah.

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

Contoh berikut menunjukkan bagaimana menggunakan `$position` operator untuk menyisipkan tugas pada posisi tertentu dalam sistem manajemen proyek.

**Buat dokumen sampel**

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

**Contoh kueri 1 - Tambahkan tugas mendesak di awal**

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

**Keluaran 1**

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

**Contoh kueri 2 - Tambahkan tugas pada posisi tertentu**

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

**Keluaran 2**

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

## Contoh kode
<a name="position-code"></a>

Untuk melihat contoh kode untuk menggunakan `$position` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$pull`Operator digunakan untuk menghapus dari array semua contoh nilai atau nilai yang cocok dengan kondisi tertentu. Operator ini berguna ketika Anda perlu menghapus elemen tertentu dari bidang array dalam dokumen.

**Parameter**
+ `field`: Nama bidang array dari mana untuk menghapus nilai (s).
+ `value`: Nilai atau kondisi yang menentukan elemen mana yang akan dihapus dari array.

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

Contoh berikut menunjukkan bagaimana menggunakan `$pull` operator untuk menghapus elemen dari bidang array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Kueri di atas menghapus fitur “Takeout” dari semua dokumen yang `cuisine` bidangnya “Italia”.

## Contoh kode
<a name="pull-code"></a>

Untuk melihat contoh kode untuk menggunakan `$pull` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$pullAll`Operator di Amazon DocumentDB digunakan untuk menghapus semua instance nilai yang ditentukan dari bidang array. Ini sangat berguna ketika Anda perlu menghapus beberapa elemen dari array dalam satu operasi.

**Parameter**
+ `field`: Nama bidang array dari mana untuk menghapus elemen.
+ `value`: Sebuah array nilai untuk menghapus dari bidang array.

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

Contoh berikut menunjukkan bagaimana menggunakan `$pullAll` operator untuk menghapus beberapa elemen dari bidang array.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

## Contoh kode
<a name="pullAll-code"></a>

Untuk melihat contoh kode untuk menggunakan `$pullAll` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$push`Operator di Amazon DocumentDB digunakan untuk menambahkan item ke bidang array dalam dokumen. Operator ini sangat berguna ketika Anda perlu menambahkan data baru ke array yang ada tanpa menimpa seluruh array.

**Parameter**
+ `field`: Nama bidang array yang elemen baru harus ditambahkan.
+ `value`: Nilai yang akan ditambahkan ke array.
+ `position`: (opsional) Sebuah modifier yang menentukan posisi dalam array di mana elemen baru harus ditambahkan. Pengubah yang didukung termasuk `$` (tambahkan ke akhir array) dan `$[]` (tambahkan ke akhir array, mengabaikan filter array apa pun).

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

Contoh berikut menunjukkan bagaimana menggunakan `$push` operator untuk menambahkan elemen baru ke bidang array dalam dokumen.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Setelah menjalankan pembaruan, dokumen dengan `hobbies` array `_id: 1` akan diperbarui`[&quot;reading&quot;, &quot;swimming&quot;, &quot;hiking&quot;]`.

## Contoh kode
<a name="push-code"></a>

Untuk melihat contoh kode untuk menggunakan `$push` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$rename`Operator di Amazon DocumentDB digunakan untuk mengganti nama bidang dalam dokumen. Operator ini dapat sangat berguna ketika Anda perlu memperbarui struktur dokumen Anda atau menyelaraskannya dengan model data baru.

**Parameter**
+ `field`: Bidang yang akan diganti namanya.
+ `newName`: Nama baru untuk bidang.

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

Contoh berikut menunjukkan cara menggunakan `$rename` operator untuk mengganti nama bidang menjadi `&quot;Date.DayOfWeek&quot;` dalam dokumen dengan `&quot;Date.DoW&quot;` bidang yang disetel ke. `&quot;DocName&quot;` `&quot;Document 1&quot;`

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

## Contoh kode
<a name="rename-code"></a>

Untuk melihat contoh kode untuk menggunakan `$rename` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$set`Operator di Amazon DocumentDB digunakan untuk memperbarui nilai bidang tertentu dalam dokumen. Operator ini memungkinkan Anda untuk menambahkan bidang baru atau memodifikasi yang sudah ada dalam dokumen. Ini adalah operator pembaruan mendasar dalam driver MongoDB Java, yang kompatibel dengan Amazon DocumentDB.

**Parameter**
+ `field`: Bidang untuk memperbarui.
+ `value`: Nilai baru untuk bidang.

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

Contoh berikut menunjukkan bagaimana menggunakan `$set` operator untuk memperbarui `Item` bidang dalam dokumen.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

## Contoh kode
<a name="set-code"></a>

Untuk melihat contoh kode untuk menggunakan `$set` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$setOnInsert`Operator di Amazon DocumentDB digunakan untuk menetapkan nilai bidang jika dokumen dimasukkan, tetapi tidak berpengaruh jika dokumen sedang diperbarui.

**Parameter**
+ `field`: Bidang yang akan diatur.
+ `value`: Nilai yang akan ditetapkan ke bidang.

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

Contoh berikut menunjukkan penggunaan `$setOnInsert` operator di Amazon DocumentDB. Ini membuat dokumen baru jika dokumen belum ada, tetapi tidak berpengaruh jika dokumen sedang diperbarui.

**Buat dokumen sampel**

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

**Contoh kueri 1 - Perbarui dokumen yang ada**

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

**Keluaran 1**

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

Output menunjukkan bahwa dokumen telah diperbarui, tetapi `createdAt` bidang **TIDAK ditambahkan** karena dokumen sudah ada. `$setOnInsert`Operator hanya berlaku saat memasukkan dokumen baru.

**Contoh kueri 2 - Sisipkan dokumen baru (upsert)**

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

**Keluaran 2**

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

## Contoh kode
<a name="setOnInsert-code"></a>

Untuk melihat contoh kode untuk menggunakan `$setOnInsert` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Operator `$slice` pembaruan memodifikasi array dengan membatasi ukurannya. Ketika digunakan dengan `$push` operator, ini membatasi jumlah elemen dalam array, hanya menyimpan jumlah tertentu dari elemen terbaru atau tertua.

**Parameter**
+ `field`: Bidang array untuk memodifikasi.
+ `count`: Jumlah maksimum elemen yang harus disimpan. Nilai positif menjaga elemen N pertama, nilai negatif menjaga elemen N terakhir.

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

Contoh berikut menunjukkan cara menggunakan operator `$slice` pembaruan `$push` untuk mempertahankan array ukuran tetap dari skor terbaru.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Dalam contoh ini, `$slice: -3` pengubah hanya menyimpan tiga elemen terakhir setelah mendorong nilai baru ke array.

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

Untuk melihat contoh kode untuk menggunakan operator `$slice` pembaruan, pilih tab untuk bahasa yang ingin Anda gunakan:

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

Pengubah `$sort` pembaruan memesan elemen array saat digunakan dengan `$push` operator. Ini mengatur elemen array dalam urutan naik atau turun berdasarkan nilai bidang tertentu atau elemen itu sendiri.

**Parameter**
+ `field`: Bidang array untuk memodifikasi.
+ `order`: Gunakan `1` untuk urutan menaik atau `-1` untuk urutan menurun.

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

Contoh berikut menunjukkan menggunakan `$sort` pengubah dengan `$push` untuk menambahkan skor kuis baru dan menjaga mereka diurutkan dalam urutan menurun.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

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

Untuk melihat contoh kode untuk menggunakan pengubah `$sort` pembaruan, pilih tab untuk bahasa yang ingin Anda gunakan:

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

`$unset`Operator di Amazon DocumentDB digunakan untuk menghapus bidang tertentu dari dokumen. Ketika bidang dihapus menggunakan`$unset`, bidang dihapus dari dokumen, dan ukuran dokumen dikurangi sesuai. Ini dapat berguna ketika Anda ingin menghapus data yang tidak perlu dari dokumen Anda.

**Parameter**
+ `field`: Bidang untuk menghapus dari dokumen. Ini bisa berupa bidang tunggal atau jalur putus-putus ke bidang bersarang.

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

Contoh berikut menunjukkan cara menggunakan `$unset` operator untuk menghapus `Words` bidang dari dokumen dalam `example` koleksi.

**Buat dokumen sampel**

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

**Contoh kueri**

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

**Keluaran**

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

Dalam contoh ini, `$unset` operator digunakan untuk menghapus `Words` bidang dari dokumen dengan `DocName` sama dengan “Dokumen 1". Dokumen yang dihasilkan tidak lagi berisi `Words` bidang.

## Contoh kode
<a name="unset-code"></a>

Untuk melihat contoh kode untuk menggunakan `$unset` perintah, pilih tab untuk bahasa yang ingin Anda gunakan:

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

------