Jenis indeks di Cloud Firestore

Indeks merupakan faktor penting dalam kinerja database. Sama seperti indeks buku yang memetakan topik dalam buku ke nomor halaman, indeks database memetakan item dalam database ke lokasinya di database. Saat Anda mengirim kueri ke database, database dapat menggunakan indeks untuk mencari lokasi item yang Anda minta dengan cepat.

Halaman ini menjelaskan dua jenis indeks yang digunakan Cloud Firestore, indeks kolom tunggal dan indeks gabungan .

Indeks di balik setiap kueri

Jika tidak ada indeks untuk kueri, sebagian besar basis data merayapi isinya item demi item, proses lambat yang semakin melambat saat basis data tumbuh. Cloud Firestore menjamin kinerja kueri yang tinggi dengan menggunakan indeks untuk semua kueri. Akibatnya, performa kueri bergantung pada ukuran kumpulan hasil dan bukan pada jumlah item dalam database.

Lebih sedikit manajemen indeks, lebih banyak pengembangan aplikasi

Cloud Firestore menyertakan fitur yang mengurangi jumlah waktu yang Anda perlukan untuk mengelola indeks. Indeks yang diperlukan untuk kueri paling dasar dibuat secara otomatis untuk Anda. Saat Anda menggunakan dan menguji aplikasi, Cloud Firestore membantu Anda mengidentifikasi dan membuat indeks tambahan yang diperlukan aplikasi Anda.

Jenis indeks

Cloud Firestore menggunakan dua jenis indeks: kolom tunggal dan komposit . Selain jumlah bidang yang diindeks, indeks bidang tunggal dan gabungan berbeda dalam cara Anda mengelolanya.

Indeks bidang tunggal

Indeks bidang tunggal menyimpan pemetaan terurut dari semua dokumen dalam kumpulan yang berisi bidang tertentu. Setiap entri dalam indeks bidang tunggal mencatat nilai dokumen untuk bidang tertentu dan lokasi dokumen dalam database. Cloud Firestore menggunakan indeks ini untuk melakukan banyak kueri dasar. Anda mengelola indeks bidang tunggal dengan mengonfigurasi pengaturan pengindeksan otomatis dan pengecualian indeks database Anda.

Pengindeksan otomatis

Secara default, Cloud Firestore secara otomatis mempertahankan indeks kolom tunggal untuk setiap kolom dalam dokumen dan setiap subkolom dalam peta. Cloud Firestore menggunakan setelan default berikut untuk indeks kolom tunggal:

• Untuk setiap kolom non-array dan non-peta, Cloud Firestore menentukan dua indeks kolom tunggal cakupan koleksi , satu dalam mode menaik dan satu lagi dalam mode menurun.

• Untuk setiap kolom peta, Cloud Firestore membuat satu indeks menaik lingkup koleksi dan satu indeks menurun untuk setiap subkolom non-array dan non-peta di peta.

• Untuk setiap kolom array dalam dokumen, Cloud Firestore membuat dan memelihara indeks array-contains lingkup koleksi.

• Indeks bidang tunggal dengan cakupan grup koleksi tidak dipertahankan secara default.

Pengecualian indeks kolom tunggal

Anda dapat mengecualikan bidang dari setelan pengindeksan otomatis dengan membuat pengecualian indeks bidang tunggal. Pengecualian pengindeksan mengesampingkan pengaturan indeks otomatis di seluruh basis data. Pengecualian dapat mengaktifkan indeks bidang tunggal yang pengaturan pengindeksan otomatis Anda akan menonaktifkan atau menonaktifkan indeks bidang tunggal yang sebaliknya akan diaktifkan oleh pengindeksan otomatis. Untuk kasus di mana pengecualian dapat bermanfaat, lihat praktik terbaik pengindeksan .

Jika Anda membuat pengecualian indeks bidang tunggal untuk bidang peta, subbidang peta akan mewarisi setelan tersebut. Namun, Anda dapat menentukan pengecualian indeks bidang tunggal untuk subbidang tertentu. Jika Anda menghapus pengecualian untuk subbidang, subbidang akan mewarisi pengaturan pengecualian induknya, jika ada, atau pengaturan seluruh database jika tidak ada pengecualian induk.

Untuk membuat dan mengelola pengecualian indeks kolom tunggal, lihat Mengelola Indeks di Cloud Firestore .

Indeks komposit

Indeks komposit menyimpan pemetaan terurut dari semua dokumen dalam koleksi, berdasarkan daftar bidang yang diurutkan untuk diindeks.

Cloud Firestore menggunakan indeks komposit untuk mendukung kueri yang belum didukung oleh indeks kolom tunggal.

Cloud Firestore tidak secara otomatis membuat indeks komposit seperti yang dilakukan untuk indeks kolom tunggal karena banyaknya kemungkinan kombinasi kolom. Sebagai gantinya, Cloud Firestore membantu Anda mengidentifikasi dan membuat indeks komposit yang diperlukan saat Anda mem-build aplikasi.

Jika Anda mencoba kueri di atas tanpa membuat indeks yang diperlukan terlebih dahulu, Cloud Firestore akan menampilkan pesan error berisi link yang dapat Anda ikuti untuk membuat indeks yang hilang. Ini terjadi setiap kali Anda mencoba kueri yang tidak didukung oleh indeks. Anda juga dapat menentukan dan mengelola indeks komposit secara manual menggunakan konsol atau menggunakan Firebase CLI . Untuk informasi selengkapnya tentang membuat dan mengelola indeks gabungan, lihat Mengelola Indeks .

Mode indeks dan cakupan kueri

Anda mengonfigurasi indeks bidang tunggal dan gabungan secara berbeda, tetapi keduanya mengharuskan Anda mengonfigurasi mode indeks dan cakupan kueri untuk indeks Anda.

Mode indeks

Saat Anda menentukan indeks, Anda memilih mode indeks untuk setiap bidang yang diindeks. Setiap mode indeks bidang mendukung klausa kueri tertentu pada bidang tersebut. Anda dapat memilih dari mode indeks berikut:

Cakupan kueri

Setiap indeks dicakup ke koleksi atau grup koleksi. Ini dikenal sebagai cakupan kueri indeks:

Cakupan koleksi

Cloud Firestore membuat indeks dengan cakupan koleksi secara default. Indeks ini mendukung kueri yang mengembalikan hasil dari satu koleksi.

Lingkup grup koleksi

Grup koleksi mencakup semua koleksi dengan ID koleksi yang sama. Untuk menjalankan kueri grup koleksi yang mengembalikan hasil yang difilter atau diurutkan dari grup koleksi, Anda harus membuat indeks yang sesuai dengan cakupan grup koleksi.

Pengurutan default dan kolom __name__

Selain mengurutkan dokumen berdasarkan mode indeks yang ditentukan untuk setiap bidang (naik atau turun), indeks menerapkan penyortiran akhir berdasarkan bidang __name__ dari setiap dokumen. Nilai bidang __name__ disetel ke jalur dokumen lengkap. Ini berarti bahwa dokumen dalam kumpulan hasil dengan nilai bidang yang sama diurutkan berdasarkan jalur dokumen.

Secara default, bidang __name__ diurutkan dengan arah yang sama dengan bidang yang terakhir diurutkan dalam definisi indeks. Sebagai contoh:

Untuk mengurutkan hasil berdasarkan arah __name__ non-default, Anda perlu membuat index.

Contoh pengindeksan

Dengan membuat indeks kolom tunggal secara otomatis untuk Anda, Cloud Firestore memungkinkan aplikasi Anda mendukung kueri database paling dasar dengan cepat. Indeks bidang tunggal memungkinkan Anda melakukan kueri sederhana berdasarkan nilai bidang dan pembanding < , <= , == , >= , > , dan in . Untuk bidang array, mereka memungkinkan Anda untuk melakukan kueri array-contains dan array-contains-any .

Sebagai ilustrasi, periksa contoh berikut dari sudut pandang pembuatan indeks. Cuplikan berikut membuat beberapa dokumen city dalam kumpulan cities dan menyetel kolom name , state , country , capital , population , dan tags untuk setiap dokumen:

var citiesRef = db.collection("cities");

citiesRef.doc("SF").set({
    name: "San Francisco", state: "CA", country: "USA",
    capital: false, population: 860000,
    regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
    name: "Los Angeles", state: "CA", country: "USA",
    capital: false, population: 3900000,
    regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
    name: "Washington, D.C.", state: null, country: "USA",
    capital: true, population: 680000,
    regions: ["east_coast"] });
citiesRef.doc("TOK").set({
    name: "Tokyo", state: null, country: "Japan",
    capital: true, population: 9000000,
    regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
    name: "Beijing", state: null, country: "China",
    capital: true, population: 21500000,
    regions: ["jingjinji", "hebei"] });
test.firestore.js

Dengan asumsi setelan pengindeksan otomatis default, Cloud Firestore memperbarui satu indeks kolom tunggal naik per kolom non-array, satu indeks kolom tunggal turun per kolom non-array, dan satu indeks kolom tunggal berisi array untuk kolom array. Setiap baris dalam tabel berikut mewakili entri dalam indeks bidang tunggal:

Kueri didukung oleh indeks bidang tunggal

Dengan menggunakan indeks bidang tunggal yang dibuat secara otomatis ini, Anda dapat menjalankan kueri sederhana seperti berikut:

const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
test.firestore.js

Anda juga dapat in dan menggabungkan kueri kesetaraan ( == ):

citiesRef.where('country', 'in', ["USA", "Japan", "China"])

// Compound equality queries
citiesRef.where("state", "==", "CO").where("name", "==", "Denver")
citiesRef.where("country", "==", "USA")
         .where("capital", "==", false)
         .where("state", "==", "CA")
         .where("population", "==", 860000)

Jika Anda perlu menjalankan kueri gabungan yang menggunakan perbandingan rentang ( < , <= , > , atau >= ) atau jika Anda perlu mengurutkan berdasarkan bidang yang berbeda, Anda harus membuat indeks gabungan untuk kueri tersebut.

Indeks array-contains memungkinkan Anda untuk mengkueri bidang larik regions :

citiesRef.where("regions", "array-contains", "west_coast")
// array-contains-any and array-contains use the same indexes
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])

Kueri didukung oleh indeks komposit

Cloud Firestore menggunakan indeks komposit untuk mendukung kueri gabungan yang belum didukung oleh indeks kolom tunggal. Misalnya, Anda memerlukan indeks gabungan untuk kueri berikut:

citiesRef.where("country", "==", "USA").orderBy("population", "asc")
citiesRef.where("country", "==", "USA").where("population", "<", 3800000)
citiesRef.where("country", "==", "USA").where("population", ">", 690000)
// in and == clauses use the same index
citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)

Kueri ini memerlukan indeks komposit di bawah ini. Karena kueri menggunakan persamaan ( == atau in ) untuk bidang country , Anda dapat menggunakan mode indeks naik atau turun untuk bidang ini. Secara default, klausa ketidaksetaraan menerapkan urutan naik berdasarkan bidang dalam klausa ketidaksetaraan.

Untuk menjalankan kueri yang sama tetapi dengan urutan menurun, Anda memerlukan indeks komposit tambahan dalam arah menurun untuk population :

citiesRef.where("country", "==", "USA").orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", "<", 3800000)
         .orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", ">", 690000)
         .orderBy("population", "desc")

citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)
         .orderBy("population", "desc")

Anda juga perlu membuat indeks komposit untuk menggabungkan permintaan array-contains atau array-contains-any dengan klausa tambahan.

citiesRef.where("regions", "array-contains", "east_coast")
         .where("capital", "==", true)

// array-contains-any and array-contains use the same index
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])
         .where("capital", "==", true)

Kueri didukung oleh indeks grup koleksi

Untuk mendemonstrasikan indeks dengan cakupan grup koleksi, bayangkan Anda menambahkan sub-koleksi landmarks ke beberapa dokumen city :

var citiesRef = db.collection("cities");

citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Bridge",
    category : "bridge" });
citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Park",
    category : "park" });

citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Gallery of Art",
    category : "museum" });
citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Mall",
    category : "park" });

Menggunakan indeks bidang tunggal berikut dengan cakupan koleksi, Anda dapat mengkueri koleksi landmarks kota tunggal berdasarkan bidang category :

citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])

Sekarang, bayangkan Anda tertarik untuk menanyakan bangunan terkenal di semua kota. Untuk menjalankan kueri ini pada grup koleksi yang terdiri dari semua koleksi landmarks , Anda harus mengaktifkan indeks bidang tunggal landmarks dengan cakupan grup koleksi:

Dengan mengaktifkan indeks ini, Anda dapat mengkueri grup koleksi landmarks :

var landmarksGroupRef = db.collectionGroup("landmarks");

landmarksGroupRef.where("category", "==", "park")
landmarksGroupRef.where("category", "in", ["park", "museum"])

Untuk menjalankan kueri grup koleksi yang mengembalikan hasil yang difilter atau diurutkan, Anda harus mengaktifkan indeks gabungan atau kolom tunggal yang sesuai dengan cakupan grup koleksi. Kueri grup kumpulan yang tidak memfilter atau mengurutkan hasil, bagaimanapun, tidak memerlukan definisi indeks tambahan apa pun.

Misalnya, Anda dapat menjalankan kueri grup koleksi berikut tanpa mengaktifkan indeks tambahan:

db.collectionGroup("landmarks").get()

Entri indeks

Indeks yang dikonfigurasi proyek Anda dan struktur dokumen menentukan jumlah entri indeks untuk dokumen. Entri indeks dihitung terhadap batas jumlah entri indeks .

Contoh berikut menunjukkan entri indeks dokumen.

Dokumen

/cities/SF

city_name : "San Francisco"
temperatures : {summer: 67, winter: 55}
neighborhoods : ["Mission", "Downtown", "Marina"]

Indeks Bidang Tunggal

• ASC nama_kota
• nama_kota DESC
• suhu.musim panas ASC
• suhu.musim panas DESC
• suhu. musim dingin ASC
• suhu.musim dingin DESC
• Berisi Array lingkungan (ASC dan DESC)

Indeks komposit

• city_name ASC, lingkungan ARRAY
• nama_kota DESC, lingkungan ARRAY

Entri indeks

Konfigurasi pengindeksan ini menghasilkan 18 entri indeks berikut untuk dokumen:

Indeks dan harga

Indeks berkontribusi pada biaya penyimpanan aplikasi Anda. Untuk selengkapnya tentang cara menghitung ukuran penyimpanan untuk indeks, lihat Ukuran entri indeks .

Mengambil keuntungan dari penggabungan indeks

Meskipun Cloud Firestore menggunakan indeks untuk setiap kueri, tidak selalu diperlukan satu indeks per kueri. Untuk kueri dengan beberapa klausa kesetaraan ( == ) dan, secara opsional, klausa orderBy , Cloud Firestore dapat menggunakan kembali indeks yang ada. Cloud Firestore dapat menggabungkan indeks untuk filter kesetaraan sederhana guna membangun indeks gabungan yang diperlukan untuk kueri kesetaraan yang lebih besar.

Anda dapat mengurangi biaya pengindeksan dengan mengidentifikasi situasi di mana Anda dapat memanfaatkan penggabungan indeks. Misalnya, bayangkan koleksi restaurants untuk aplikasi rating restoran:

• collections_bookmark restoran

  • class burgerthyme

    name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
    

Sekarang, bayangkan aplikasi ini menggunakan kueri seperti di bawah ini. Perhatikan bahwa aplikasi menggunakan kombinasi klausa kesetaraan untuk category , city , dan editors_pick sambil selalu mengurutkan berdasarkan star_rating naik :

db.collection("restaurants").where("category", "==", "burgers")
                            .orderBy("star_rating")

db.collection("restaurants").where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==" "San Francisco")
                            .where("editors_pick", "==", true )
                            .orderBy("star_rating")

Anda dapat membuat indeks untuk setiap kueri:

Sebagai solusi yang lebih baik, Anda dapat mengurangi jumlah indeks dengan memanfaatkan kemampuan Cloud Firestore untuk menggabungkan indeks untuk klausa kesetaraan:

Kumpulan indeks ini tidak hanya lebih kecil, tetapi juga mendukung kueri tambahan:

db.collection("restaurants").where("editors_pick", "==", true)
                            .orderBy("star_rating")

Batas pengindeksan

Batasan berikut berlaku untuk indeks. Untuk semua kuota dan batas, lihat Kuota dan Batas .

Mengindeks praktik terbaik

Untuk sebagian besar aplikasi, Anda dapat mengandalkan pengindeksan otomatis dan tautan pesan kesalahan untuk mengelola indeks Anda. Namun, Anda mungkin ingin menambahkan pengecualian kolom tunggal dalam kasus berikut: