

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

# Menanyakan di Amazon DocumentDB
<a name="querying"></a>

Bagian ini menjelaskan semua aspek dari melakukan kueri dengan Amazon DocumentDB.

**Topics**
+ [Menanyakan dokumen](#querying.docs)
+ [Rencana kueri](#querying.queryplan)
+ [Jelaskan hasil](#querying.explainresults)
+ [Perencana kueri v2](query-planner.md)
+ [Perencana kueri v3](query-planner-v3.md)
+ [Data geospasial](geospatial.md)
+ [Indeks sebagian](partial-index.md)
+ [Pencarian teks](text-search.md)

## Menanyakan dokumen
<a name="querying.docs"></a>

Terkadang, Anda mungkin perlu mencari inventaris toko online Anda sehingga pelanggan dapat melihat dan membeli apa yang Anda jual. Melakukan kueri sebuah koleksi relatif mudah, apakah Anda ingin semua dokumen dalam koleksi atau hanya dokumen yang memenuhi kriteria tertentu.

Untuk melakukan kueri dokumen, gunakan operasi `find()`. Perintah `find()` memiliki parameter dokumen tunggal yang mendefinisikan kriteria yang akan digunakan dalam memilih dokumen yang akan dikembalikan. Output dari `find()` adalah dokumen yang diformat sebagai satu baris teks tanpa jeda baris. Untuk memformat dokumen output agar lebih mudah dibaca, gunakan `find().pretty()`. Semua contoh dalam topik ini menggunakan `.pretty()` untuk memformat output.

Contoh kode berikut menggunakan empat dokumen yang Anda sisipkan ke dalam koleksi `example` dalam dua latihan sebelumnya — `insertOne()` dan `insertMany()` yang terletak di bagian Menambahkan Dokumen pada [Bekerja dengan Dokumen](https://docs.aws.amazon.com//documentdb/latest/developerguide/document-database-working-with-documents.html).

**Topics**
+ [Mengambil semua dokumen](#querying.alldocs)
+ [Mencocokkan nilai bidang](#querying.matchfield)
+ [Dokumen yang disematkan](#querying.embedded-doc)
+ [Nilai bidang dalam dokumen yang disematkan](#querying.embedded-docs-field)
+ [Mencocokkan array](#querying.array)
+ [Mencocokkan nilai dalam array](#querying.array-values)
+ [Menggunakan operator](#querying.operators)

### Mengambil semua dokumen dalam koleksi
<a name="querying.alldocs"></a>

Untuk mengambil semua dokumen dalam koleksi Anda, gunakan operasi `find()` dengan dokumen kueri kosong.

Kueri berikut mengembalikan semua dokumen di dalam koleksi `example`.

```
db.example.find( {} ).pretty()
```

### Mengambil dokumen yang cocok dengan nilai bidang
<a name="querying.matchfield"></a>

Untuk mengambil semua dokumen yang cocok dengan bidang dan nilai, gunakan operasi `find()` dengan dokumen kueri yang mengidentifikasi bidang dan nilai yang akan dicocokkan.

Menggunakan dokumen sebelumnya, kueri ini mengembalikan semua dokumen di mana bidang "Item" sama dengan "Pena".

```
db.example.find( { "Item": "Pen" } ).pretty()
```

### Mengambil dokumen yang cocok dengan dokumen yang disematkan
<a name="querying.embedded-doc"></a>

Untuk menemukan semua dokumen yang cocok dengan dokumen yang ditanamkan, gunakan operasi `find()` dengan dokumen kueri yang menentukan nama dokumen yang ditanamkan dan semua bidang dan nilai untuk dokumen yang ditanamkan itu.

Saat mencocokkan dokumen yang ditanamkan, dokumen yang ditanamkan tersebut harus memiliki nama yang sama seperti dalam kueri. Selain itu, bidang dan nilai dalam dokumen yang ditanamkan harus cocok dengan kueri.

Kueri berikut hanya mengembalikan dokumen "Cat Poster". Ini karena "Pena" memiliki nilai yang berbeda untuk "`OnHand`" dan "`MinOnHand`", dan "Cat Semprot" memiliki satu bidang (`OrderQnty`) lebih banyak daripada dokumen kueri.

```
db.example.find({"Inventory": {
    "OnHand": 47,
    "MinOnHand": 50 } } ).pretty()
```

### Mengambil dokumen yang cocok dengan nilai bidang dalam dokumen yang disematkan
<a name="querying.embedded-docs-field"></a>

Untuk menemukan semua dokumen yang cocok dengan dokumen yang ditanamkan, gunakan operasi `find()` dengan dokumen kueri yang menentukan nama dokumen yang ditanamkan dan semua bidang dan nilai untuk dokumen yang ditanamkan itu.

Mengingat dokumen sebelumnya, kueri berikut menggunakan "notasi titik" untuk menentukan dokumen yang ditanamkan dan bidang yang diminati. Setiap dokumen yang cocok dengan ini dikembalikan, terlepas dari apa bidang lain mungkin hadir dalam dokumen tertanam. Kueri mengembalikan "Cat Poster" dan "Cat Semprot" karena keduanya cocok dengan bidang dan nilai yang ditentukan.

```
db.example.find({"Inventory.OnHand": 47, "Inventory.MinOnHand": 50 }).pretty()
```

### Mengambil dokumen yang cocok dengan array
<a name="querying.array"></a>

Untuk menemukan semua dokumen yang cocok dengan array, gunakan operasi `find()` dengan nama array yang Anda minati dan semua nilai dalam array itu. Kueri mengembalikan semua dokumen yang memiliki array dengan nama itu di mana nilai arraynya identik dengan dan dalam urutan yang sama seperti dalam kueri.

Kueri berikut hanya mengembalikan "Pena" karena "Cat Poster" memiliki warna tambahan (Putih), dan "Cat Semprot" memiliki warna dalam urutan yang berbeda.

```
db.example.find( { "Colors": ["Red","Green","Blue","Black"] } ).pretty() 
```

### Mengambil dokumen yang cocok dengan nilai dalam array
<a name="querying.array-values"></a>

Untuk menemukan semua dokumen yang memiliki nilai array tertentu, gunakan operasi `find()` dengan nama array dan nilai yang Anda minati.

```
db.example.find( { "Colors": "Red" } ).pretty() 
```

Operasi sebelumnya mengembalikan ketiga dokumen karena masing-masing memiliki array bernama `Colors` dan nilai "`Red`" di suatu tempat dalam array. Jika Anda menentukan nilai "`White`", kueri hanya akan mengembalikan "Cat Poster."

### Mengambil dokumen menggunakan operator
<a name="querying.operators"></a>

Kueri berikut mengembalikan semua dokumen dengan nilai "`Inventory.OnHand`" kurang dari 50.

```
db.example.find(
        { "Inventory.OnHand": { $lt: 50 } } )
```

Untuk daftar operator kueri yang didukung, lihat [Operator kueri dan proyeksi](mongo-apis.md#mongo-apis-query). 

## Rencana kueri
<a name="querying.queryplan"></a>

### Bagaimana Saya Dapat Melihat `executionStats` untuk Rencana Kueri?
<a name="querying.queryplan-executionStats"></a>

Saat menentukan mengapa kueri dijalankan lebih lambat dari yang diharapkan, akan berguna untuk memahami apa `executionStats` untuk rencana kueri. `executionStats` memberikan jumlah dokumen yang dikembalikan dari tahap tertentu (`nReturned`), jumlah waktu eksekusi yang dihabiskan pada setiap tahap (`executionTimeMillisEstimate`), dan jumlah waktu yang diperlukan untuk menghasilkan rencana kueri (`planningTimeMillis`). Anda dapat menentukan tahapan kueri yang paling memakan waktu untuk membantu memfokuskan upaya pengoptimalan Anda dari keluaran `executionStats`, seperti yang ditunjukkan dalam contoh kueri di bawah ini. Parameter `executionStats` saat ini tidak mendukung perintah `update` dan `delete`.

**catatan**  
Amazon DocumentDB mengemulasi MongoDB 3.6 API pada mesin basis data yang dibuat khusus yang menggunakan sistem penyimpanan terdistribusi, toleran terhadap kesalahan, dan dapat pulih sendiri. Akibatnya, rencana kueri dan keluaran dari `explain()` mungkin berbeda antara Amazon DocumentDB dan MongoDB. Pelanggan yang ingin kontrol atas rencana kueri mereka dapat menggunakan operator `$hint` untuk memaksa pemilihan indeks yang diutamakan.

Jalankan kueri yang ingin Anda tingkatkan di bawah perintah `explain()` sebagai berikut.

```
db.runCommand({explain: {query document}}).
explain("executionStats").executionStats;
```

Berikut ini adalah contoh operasi.

```
db.fish.find({}).limit(2).explain("executionStats");
```

Output dari operasi ini terlihat seperti berikut.

```
{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "test.fish",
        "winningPlan" : {
            "stage" : "SUBSCAN",
            "inputStage" : {
                "stage" : "LIMIT_SKIP",
                "inputStage" : {
                    "stage" : "COLLSCAN"
                }
            }
        }
    },
    "executionStats" : {
        "executionSuccess" : true,
        "executionTimeMillis" : "0.063",
        "planningTimeMillis" : "0.040",
        "executionStages" : {
            "stage" : "SUBSCAN",
            "nReturned" : "2",
            "executionTimeMillisEstimate" : "0.012",
            "inputStage" : {
                "stage" : "LIMIT_SKIP",
                "nReturned" : "2",
                "executionTimeMillisEstimate" : "0.005",
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "nReturned" : "2",
                    "executionTimeMillisEstimate" : "0.005"
                }
            }
        }
    },
    "serverInfo" : {
        "host" : "enginedemo",
        "port" : 27017,
        "version" : "3.6.0"
    },
    "ok" : 1
}
```

Jika Anda tertarik hanya melihat `executionStats` dari kueri di atas, Anda dapat menggunakan perintah berikut. Untuk koleksi kecil, prosesor kueri Amazon DocumentDB dapat memilih untuk tidak menggunakan indeks jika peningkatan performa dapat diabaikan.

```
db.fish.find({}).limit(2).explain("executionStats").executionStats;
```

### Cache rencana kueri
<a name="querying.queryplan-cached"></a>

Untuk mengoptimalkan performa dan mengurangi durasi perencanaan, Amazon DocumentDB melakukan cache rencana kueri secara internal. Ini memungkinkan kueri dengan bentuk yang sama untuk dieksekusi secara langsung menggunakan rencana cache.

Namun, cache ini terkadang menyebabkan penundaan acak untuk kueri yang sama; misalnya, kueri yang biasanya membutuhkan waktu satu detik untuk dijalankan terkadang membutuhkan waktu sepuluh detik. Ini karena seiring waktu, instans pembaca melakukan cache berbagai bentuk kueri, sehingga menghabiskan memori. Jika Anda mengalami kelambatan acak ini, tidak ada tindakan yang perlu Anda lakukan untuk melepaskan memori--sistem akan mengelola penggunaan memori untuk Anda dan begitu memori mencapai ambang batas tertentu, memori akan dilepaskan secara otomatis.

## Jelaskan hasil
<a name="querying.explainresults"></a>

Jika Anda ingin mengembalikan informasi tentang rencana kueri, Amazon DocumentDB mendukung mode verbositas `queryPlanner`. Hasil `explain` mengembalikan rencana kueri terpilih yang dipilih oleh pengoptimal dalam format yang mirip dengan berikut ini:

```
{
   "queryPlanner" : {
      "plannerVersion" : <int>,
      "namespace" : <string>,
      "winningPlan" : {
         "stage" : <STAGE1>,
         ...
         "inputStage" : {
            "stage" : <STAGE2>,
            ...
            "inputStage" : {
               ...
            }
         }
      }
   }
}
```

Bagian berikut akan menentukan hasil `explain` umum.

**Topics**
+ [Tahap pemindaian dan filter](#querying.explainresults-scan-filter)
+ [Persimpangan indeks](#querying.explainresults-index-intersection)
+ [Serikat indeks](#querying.explainresults-index-union)
+ [Beberapa persilangan indeks/serikat](#querying.explainresults-multiple-index-union)
+ [Indeks majemuk](#querying.explainresults-compound-index)
+ [Sortir tahap](#querying.explainresults-sort)
+ [Panggung grup](#querying.explainresults-group)

### Tahap pemindaian dan filter
<a name="querying.explainresults-scan-filter"></a>

Pengoptimal dapat memilih salah satu pemindaian berikut:

COLLSCAN

Tahap ini adalah pemindaian koleksi sekuensial.

```
{
    "stage" : "COLLSCAN"
}
```

IXSCAN

Tahap ini memindai kunci indeks. Pengoptimal dapat mengambil dokumen dalam tahap ini dan ini dapat mengakibatkan tahap FETCH ditambahkan kemudian.

```
db.foo.find({"a": 1})
{
    "stage" : "IXSCAN",
    "direction" : "forward",
    "indexName" : <idx_name>
}
```

FETCH

Jika pengoptimal mengambil dokumen dalam tahap selain IXSCAN, hasilnya akan menyertakan tahap FETCH. Misalnya, kueri IXSCAN di atas dapat menghasilkan kombinasi tahapan FETCH dan IXSCAN:

```
db.foo.find({"a": 1})
{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXSCAN",
        "indexName" : <idx_name>
    }
}
```

IXONLYSCAN hanya memindai kunci indeks. Buat indeks gabungan tidak akan menghindari FETCH.

### Persimpangan indeks
<a name="querying.explainresults-index-intersection"></a>

IXAND

Amazon DocumentDB dapat menyertakan tahap IXAND dengan array inputStages IXSCAN jika dapat memanfaatkan persimpangan indeks. Misalnya, kita mungkin melihat output seperti:

```
{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXAND",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                "indexName" : "a_1"
            },
            {
                "stage" : "IXSCAN",
                "indexName" : "b_1"
            }
        ]
    }
}
```

### Serikat indeks
<a name="querying.explainresults-index-union"></a>

IXOR

Mirip dengan persimpangan indeks, Amazon DocumentDB dapat menyertakan tahap `IXOR` dengan array `inputStages` untuk operator `$or`.

```
db.foo.find({"$or": [{"a": {"$gt": 2}}, {"b": {"$lt": 2}}]})
```

Untuk kueri di atas, output yang dijelaskan mungkin terlihat seperti ini:

```
{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXOR",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                "indexName" : "a_1"
            },
            {
                "stage" : "IXSCAN",
                "indexName" : "b_1"
            }
        ]
    }
}
```

### Beberapa persilangan indeks/serikat
<a name="querying.explainresults-multiple-index-union"></a>

Amazon DocumentDB dapat menggabungkan beberapa tahap persimpangan atau persatuan indeks bersama-sama kemudian mengambil hasilnya. Contoh:

```
{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXOR",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                ...
            },
            {
                "stage" : "IXAND",
                "inputStages" : [
                    {
                        "stage" : "IXSCAN",
                        ...
                    },
                    {
                        "stage" : "IXSCAN",
                        ...
                    }
                ]
            }
        ]
    }
}
```

Penggunaan tahap indeks persimpangan atau persatuan tidak dipengaruhi oleh jenis indeks (jarang, majemuk, dll).

### Indeks majemuk
<a name="querying.explainresults-compound-index"></a>

Penggunaan indeks gabungan Amazon DocumentDB tidak dibatasi pada subset awal bidang indeks; itu dapat menggunakan indeks dengan bagian akhiran tetapi mungkin tidak terlalu efisien. 

Misalnya, indeks gabungan `{ a: 1, b: -1 }` dapat mendukung ketiga kueri di bawah ini:

`db.orders.find( { a: 1 } )`

`db.orders.find( { b: 1 } )`

`db.orders.find( { a: 1, b: 1 } )`

### Sortir tahap
<a name="querying.explainresults-sort"></a>

Jika ada indeks pada kunci sortir yang diminta, Amazon DocumentDB dapat menggunakan indeks untuk mendapatkan pesanan. Dalam hal ini, hasilnya tidak akan mencakup tahap `SORT`, melainkan tahap `IXSCAN`. Jika pengoptimal menyukai pengurutan biasa, itu akan mencakup tahap seperti ini:

```
{
    "stage" : "SORT",
    "sortPattern" : {
        "a" : 1,
        "b" : -1
    }
}
```

### Panggung grup
<a name="querying.explainresults-group"></a>

Amazon DocumentDB mendukung dua strategi grup yang berbeda:
+ `SORT_AGGREGATE`: Pada agregat pengurutan disk.
+ `HASH_AGGREGATE`: Dalam agregat hash memori.