Mengoptimalkan Indeks

Halaman ini menjelaskan konsep yang perlu dipertimbangkan saat memilih indeks Firestore dalam mode Datastore untuk aplikasi Anda.

Firestore dalam mode Datastore memberikan performa kueri yang tinggi dengan menggunakan indeks untuk semua kueri. Performa untuk sebagian besar kueri bergantung pada ukuran kumpulan hasil, bukan pada total ukuran database.

Firestore dalam mode Datastore menentukan indeks bawaan untuk setiap properti dalam entity. Indeks properti tunggal ini mendukung banyak kueri sederhana. Firestore dalam mode Datastore mendukung fitur penggabungan indeks yang memungkinkan database Anda menggabungkan indeks bawaan untuk mendukung kueri tambahan. Untuk kueri yang lebih kompleks, Anda harus menentukan indeks komposit terlebih dahulu.

Halaman ini berfokus pada fitur penggabungan indeks, karena memengaruhi dua peluang pengoptimalan indeks penting:

  • Mempercepat kueri
  • Mengurangi jumlah indeks komposit

Contoh berikut menunjukkan fitur penggabungan indeks.

Memfilter entity Photo

Pertimbangkan database mode Datastore dengan entity jenis Photo:

Foto
Properti Jenis nilai Deskripsi
owner_id String ID pengguna
tag Array string Kata kunci yang diberi token
size Bilangan bulat Enumerasi:
  • 1 icon
  • 2 medium
  • 3 large
coloration Bilangan bulat Enumerasi:
  • 1 black & white
  • 2 color

Bayangkan Anda memerlukan fitur aplikasi yang memungkinkan pengguna membuat kueri entity Photo berdasarkan AND logis dari hal berikut:

  • Hingga tiga filter berdasarkan properti:

    • owner_id
    • size
    • coloration

  • String penelusuran tag. Aplikasi memberi token pada string penelusuran menjadi tag dan menambahkan filter untuk setiap tag.

    Misalnya, aplikasi mengubah string penelusuran outside, family menjadi filter kueri tag=outside dan tag=family.

Dengan menggunakan indeks bawaan dan fitur penggabungan indeks Firestore dalam mode Datastore, Anda dapat memenuhi persyaratan indeks fitur filter Photo ini tanpa menambahkan indeks komposit tambahan.

Indeks bawaan untuk entity Photo mendukung kueri filter tunggal seperti:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_owner_id = client.query(kind="Photo", filters=[("owner_id", "=", "user1234")])

query_size = client.query(kind="Photo", filters=[("size", "=", 2)])

query_coloration = client.query(kind="Photo", filters=[("coloration", "=", 2)])

Fitur filter Photo juga memerlukan kueri yang menggabungkan beberapa filter kesetaraan dengan AND logis:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_all_properties = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
    ],
)

Firestore dalam mode Datastore dapat mendukung kueri ini dengan menggabungkan indeks bawaan.

Penggabungan indeks

Firestore dalam mode Datastore dapat menggunakan penggabungan indeks jika kueri dan indeks Anda memenuhi semua batasan berikut:

  • Kueri hanya menggunakan filter kesetaraan (=)
  • Tidak ada indeks komposit yang cocok dengan filter dan pengurutan kueri
  • Setiap filter kesetaraan cocok dengan setidaknya satu indeks yang ada dengan pengurutan yang sama dengan kueri

Dalam situasi ini, Firestore dalam mode Datastore dapat menggunakan indeks yang ada untuk mendukung kueri, sehingga Anda tidak perlu mengonfigurasi indeks komposit tambahan.

Jika dua indeks atau lebih diurutkan berdasarkan kriteria yang sama, Firestore dalam mode Datastore dapat menggabungkan hasil beberapa pemindaian indeks untuk menemukan hasil yang sama untuk semua indeks tersebut. Firestore dalam mode Datastore dapat menggabungkan indeks bawaan, karena semuanya mengurutkan nilai berdasarkan kunci entity.

Dengan menggabungkan indeks bawaan, Firestore dalam mode Datastore mendukung kueri dengan filter kesetaraan pada beberapa properti:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_all_properties = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
    ],
)

Firestore dalam mode Datastore juga dapat menggabungkan hasil indeks dari beberapa bagian indeks yang sama. Dengan menggabungkan berbagai bagian indeks bawaan untuk properti tag, Firestore dalam mode Datastore mendukung kueri yang menggabungkan beberapa filter tag dalam AND logis:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_tag = client.query(
    kind="Photo",
    filters=[
        ("tag", "=", "family"),
        ("tag", "=", "outside"),
        ("tag", "=", "camping"),
    ],
)

query_owner_size_color_tags = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "user1234"),
        ("size", "=", 2),
        ("coloration", "=", 2),
        ("tag", "=", "family"),
        ("tag", "=", "outside"),
        ("tag", "=", "camping"),
    ],
)

Kueri yang didukung oleh indeks bawaan gabungan melengkapi kumpulan kueri yang diperlukan oleh fitur pemfilteran Photo. Perhatikan bahwa dukungan untuk fitur pemfilteran Photo tidak memerlukan indeks komposit tambahan.

Saat memilih indeks yang optimal untuk aplikasi Anda, penting untuk memahami fitur penggabungan indeks. Penggabungan indeks memberi Firestore dalam mode Datastore fleksibilitas kueri yang lebih besar, tetapi dengan kemungkinan kompromi terhadap performa. Bagian berikutnya menjelaskan performa penggabungan indeks, dan cara meningkatkan performa dengan menambahkan indeks komposit.

Menemukan indeks yang sempurna

Indeks diurutkan terlebih dahulu berdasarkan ancestor, lalu berdasarkan nilai properti, dalam urutan yang ditentukan dalam definisi indeks. Indeks komposit sempurna untuk kueri, yang memungkinkan kueri dijalankan dengan paling efisien, ditentukan pada properti berikut, secara berurutan:

  1. Properti yang digunakan dalam filter kesetaraan
  2. Properti yang digunakan dalam tata urutan
  3. Properti yang digunakan dalam filter distinctOn
  4. Properti yang digunakan dalam filter rentang &ketidaksetaraan (yang belum disertakan dalam tata urutan)
  5. Properti yang digunakan dalam agregasi dan proyeksi (yang belum disertakan dalam tata urutan serta filter rentang & ketidaksetaraan)

Hal ini memastikan bahwa semua hasil untuk setiap kemungkinan eksekusi kueri dipertanggungjawabkan. Database Firestore dalam mode Datastore menjalankan kueri menggunakan indeks sempurna dengan langkah-langkah berikut:

  1. Mengidentifikasi indeks yang sesuai dengan jenis, properti filter, operator filter, dan tata urutan pada kueri
  2. Memindai dari awal indeks hingga entity pertama yang memenuhi semua atau sebagian kondisi filter kueri
  3. Terus memindai indeks, menampilkan setiap entity yang memenuhi semua kondisi filter, hingga
    • menemukan entity yang tidak memenuhi kondisi filter, atau
    • mencapai akhir indeks, atau
    • telah mengumpulkan jumlah hasil maksimum yang diminta oleh kueri

Misalnya, pertimbangkan kueri berikut:

SELECT * FROM Task
WHERE category = 'Personal'
  AND priority < 3
ORDER BY priority DESC

Indeks komposit sempurna untuk kueri ini adalah indeks kunci untuk entity jenis Task, dengan kolom untuk nilai properti category dan priority. Indeks diurutkan terlebih dahulu dalam urutan menaik berdasarkan category, lalu dalam urutan menurun berdasarkan priority:

indexes:
- kind: Task
  properties:
  - name: category
    direction: asc
  - name: priority
    direction: desc

Dua kueri dengan bentuk yang sama tetapi dengan nilai filter yang berbeda menggunakan indeks yang sama. Misalnya, kueri berikut menggunakan indeks yang sama dengan kueri sebelumnya:

SELECT * FROM Task
WHERE category = 'Work'
  AND priority < 5
ORDER BY priority DESC

Untuk indeks ini

indexes:
- kind: Task
  properties:
  - name: category
    direction: asc
  - name: priority
    direction: asc
  - name: created
    direction: asc

Indeks sebelumnya dapat memenuhi kedua kueri berikut:

SELECT * FROM Task
WHERE category = 'Personal'
  AND priority = 5
ORDER BY created ASC

dan

SELECT * FROM Task
WHERE category = 'Work'
ORDER BY priority ASC, created ASC

Mengoptimalkan pemilihan indeks

Bagian ini menjelaskan karakteristik performa penggabungan indeks dan dua peluang pengoptimalan terkait penggabungan indeks:

  • Menambahkan indeks komposit untuk mempercepat kueri yang mengandalkan indeks gabungan
  • Mengurangi jumlah indeks komposit dengan memanfaatkan indeks gabungan

Performa penggabungan indeks

Dalam penggabungan indeks, Firestore dalam mode Datastore secara efisien menggabungkan indeks menggunakan algoritma gabungan zig-zag. Dengan menggunakan algoritma ini, mode Datastore menggabungkan potensi kecocokan dari beberapa pemindaian indeks untuk menghasilkan kumpulan hasil yang cocok dengan kueri. Penggabungan indeks menggabungkan komponen filter pada waktu baca, bukan waktu tulis. Tidak seperti sebagian besar kueri Firestore dalam mode Datastore yang performanya hanya bergantung pada ukuran kumpulan hasil, performa untuk kueri penggabungan indeks bergantung pada filter dalam kueri dan berapa banyak potensi kecocokan yang dipertimbangkan database.

Performa terbaik penggabungan indeks terjadi saat setiap potensi kecocokan dalam indeks memenuhi filter kueri. Dalam hal ini, performanya adalah O(R * I) dengan R adalah ukuran kumpulan hasil dan I adalah jumlah indeks yang dipindai.

Performa terburuk terjadi saat database harus mempertimbangkan banyak potensi kecocokan, tetapi hanya sedikit yang memenuhi filter kueri. Dalam hal ini, performanya adalah O(S) dengan S adalah ukuran kumpulan entity potensial terkecil dari satu pemindaian indeks.

Performa sebenarnya bergantung pada bentuk data. Jumlah rata-rata entity yang dipertimbangkan untuk setiap hasil yang ditampilkan adalah O(S/(R * I)). Kueri berperforma lebih buruk saat banyak entity cocok dengan setiap pemindaian indeks, tetapi hanya sedikit entity yang cocok dengan kueri secara keseluruhan, yang berarti R kecil dan S besar.

Empat hal yang mengurangi risiko ini:

  • Perencana kueri tidak mencari entity hingga mengetahui bahwa entity tersebut cocok dengan seluruh kueri.

  • Algoritma zig-zag tidak perlu menemukan semua hasil untuk menampilkan hasil berikutnya. Jika Anda meminta 10 hasil pertama, Anda hanya membayar latensi untuk menemukan 10 hasil tersebut.

  • Algoritma zig-zag melewati bagian besar hasil positif palsu. Performa terburuk hanya terjadi jika hasil positif palsu terjalin sempurna (dalam urutan pengurutan) di antara pemindaian.

  • Latensi bergantung pada jumlah entity yang ditemukan di setiap pemindaian indeks, bukan jumlah entity yang cocok dengan setiap filter. Seperti yang ditunjukkan di bagian berikutnya, Anda dapat menambahkan indeks komposit untuk meningkatkan performa penggabungan indeks.

Mempercepat kueri penggabungan indeks

Saat Firestore dalam mode Datastore menggabungkan indeks, setiap pemindaian indeks sering kali dipetakan ke satu filter dalam kueri. Anda dapat meningkatkan performa kueri dengan menambahkan indeks komposit yang cocok dengan beberapa filter dalam kueri.

Pertimbangkan kueri ini:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_owner_size_tag = client.query(
    kind="Photo",
    filters=[
        ("owner_id", "=", "username"),
        ("size", "=", 2),
        ("tag", "=", "family"),
    ],
)

Setiap filter dipetakan ke satu pemindaian indeks dalam indeks bawaan berikut:

Index(Photo, owner_id)
Index(Photo, size)
Index(Photo, tag)

Jika Anda menambahkan indeks komposit Index(Photo, owner_id, size), kueri akan dipetakan ke dua pemindaian indeks, bukan tiga:

#  Satisfies both 'owner_id=username' and 'size=2'
Index(Photo, owner_id, size)
Index(Photo, tag)

Pertimbangkan skenario dengan banyak gambar besar, banyak gambar hitam putih, tetapi hanya sedikit gambar panorama besar. Kueri yang memfilter gambar panorama dan hitam putih akan lambat jika menggabungkan indeks bawaan:

Python

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

query_size_coloration = client.query(
    kind="Photo", filters=[("size", "=", 2), ("coloration", "=", 1)]
)

Untuk meningkatkan performa kueri, Anda dapat menurunkan nilai S (kumpulan entity terkecil dalam satu pemindaian indeks) di O(S/(R * I)) dengan menambahkan indeks komposit berikut:

Index(Photo, size, coloration)

Dibandingkan dengan menggunakan dua indeks bawaan, indeks komposit ini menghasilkan lebih sedikit potensi hasil untuk dua filter kueri yang sama. Pendekatan ini meningkatkan performa secara substansial dengan biaya satu indeks lagi.

Mengurangi jumlah indeks komposit dengan penggabungan indeks

Meskipun indeks komposit yang cocok dengan filter dalam kueri berperforma terbaik, tidak selalu terbaik atau memungkinkan untuk menambahkan indeks komposit untuk setiap kombinasi filter. Anda harus menyeimbangkan indeks komposit dengan hal berikut:

  • Batas indeks komposit:

    Batas Jumlah
    Jumlah maksimum indeks komposit untuk database
    Jumlah maksimum ukuran entri indeks komposit entity 2 MiB
    Jumlah maksimum hal berikut untuk entity:
    • jumlah nilai properti yang diindeks
    • jumlah entri indeks komposit
    		 20.000
  • Biaya penyimpanan setiap indeks tambahan.
  • Efek pada latensi tulis.

Masalah pengindeksan sering kali muncul dengan kolom multi-nilai seperti properti tag entity Photo.

Misalnya, bayangkan fitur pemfilteran Photo kini perlu mendukung klausa pengurutan menurun berdasarkan empat properti tambahan:

Foto
Properti Jenis nilai Deskripsi
date_added Bilangan bulat Tanggal/waktu
rating Float Rating pengguna gabungan
comment_count Bilangan bulat Jumlah komentar
download_count Bilangan bulat Jumlah download

Jika Anda mengabaikan kolom tag, Anda dapat memilih indeks komposit yang cocok dengan setiap kombinasi filter Photo:

Index(Photo, owner_id, -date_added)
Index(Photo, owner_id, -comments)
Index(Photo, size, -date_added)
Index(Photo, size, -comments)
...
Index(Photo, owner_id, size, -date_added)
Index(Photo, owner_id, size, -comments)
...
Index(Photo, owner_id, size, coloration, -date_added)
Index(Photo, owner_id, size, coloration, -comments)

Jumlah total indeks komposit adalah:

2^(number of filters) * (number of different orders) = 2 ^ 3 * 4 = 32 composite indexes

Jika Anda mencoba mendukung hingga 3 filter tag, jumlah total indeks komposit adalah:

2 ^ (3 + 3 tag filters) * 4 = 256 indexes.

Indeks yang menyertakan properti multi-nilai seperti tag juga menyebabkan masalah exploding index yang meningkatkan biaya penyimpanan dan latensi tulis.

Untuk mendukung filter pada kolom tag untuk fitur ini, Anda dapat mengurangi jumlah total indeks dengan mengandalkan indeks gabungan. Kumpulan indeks komposit berikut adalah minimum yang diperlukan untuk mendukung fitur pemfilteran Photo dengan pengurutan:

Index(Photo, owner_id, -date_added)
Index(Photo, owner_id, -rating)
Index(Photo, owner_id, -comments)
Index(Photo, owner_id, -downloads)
Index(Photo, size, -date_added)
Index(Photo, size, -rating)
Index(Photo, size, -comments)
Index(Photo, size, -downloads)
...
Index(Photo, tag, -date_added)
Index(Photo, tag, -rating)
Index(Photo, tag, -comments)
Index(Photo, tag, -downloads)

Jumlah indeks komposit yang ditentukan adalah:

(number of filters + 1) * (number of orders) = 7 * 4 = 28

Penggabungan indeks juga memberikan manfaat berikut:

  • Memungkinkan entity Photo mendukung hingga 1.000 tag tanpa batasan jumlah filter tag per kueri.
  • Mengurangi jumlah total indeks yang mengurangi biaya penyimpanan dan latensi tulis.

Memilih indeks untuk aplikasi Anda

Anda dapat memilih indeks yang optimal untuk database mode Datastore menggunakan dua pendekatan:

  • Menggunakan penggabungan indeks untuk mendukung kueri tambahan

    • Memerlukan lebih sedikit indeks komposit
    • Mengurangi biaya penyimpanan per entity
    • Meningkatkan latensi tulis
    • Menghindari exploding index
    • Performa bergantung pada bentuk data

  • Menentukan indeks komposit yang cocok dengan beberapa filter dalam kueri

    • Meningkatkan performa kueri
    • Performa kueri yang konsisten dan tidak bergantung pada bentuk data
    • Harus tetap berada di bawah batas indeks komposit
    • Meningkatkan biaya penyimpanan per entity
    • Meningkatkan latensi tulis

Saat menentukan indeks yang optimal untuk aplikasi Anda, jawabannya dapat berubah seiring perubahan bentuk data Anda. Performa kueri sampling memberi Anda gambaran yang baik tentang kueri umum aplikasi dan kueri lambatnya. Dengan informasi ini, Anda dapat menambahkan indeks untuk meningkatkan performa kueri yang umum dan lambat.