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

Menanyakan di Amazon DocumentDB

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

Menanyakan dokumen

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.

Mengambil semua dokumen dalam koleksi

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

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

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

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

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

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

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.

Rencana kueri

Bagaimana Saya Dapat Melihat executionStats untuk Rencana Kueri?

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.

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

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

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.

Tahap pemindaian dan filter

Pengoptimal dapat memilih salah satu pemindaian berikut:

COLLSCAN

Tahap ini adalah pemindaian koleksi sekuensial.

{
    "stage" : "COLLSCAN"
}
    

IXSCAN

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

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

FETCH

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

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

IXONLYSCANmemindai hanya kunci indeks. Membuat indeks majemuk tidak akan menghindariFETCH.

Persimpangan indeks

IXAND

Amazon DocumentDB dapat menyertakan IXAND tahap dengan inputStages array jika dapat IXSCAN 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

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

Amazon DocumentDB dapat menggabungkan beberapa tahap persimpangan atau persatuan indeks bersama-sama kemudian mengambil hasilnya. Sebagai 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

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

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

Amazon DocumentDB mendukung dua strategi grup yang berbeda: