Ringkasan kueri dengan filter rentang dan ketidaksetaraan di beberapa properti

Firestore dalam mode Datastore mendukung penggunaan filter rentang dan ketidaksetaraan di beberapa properti dalam satu kueri. Fitur ini memberi Anda kondisi rentang dan ketidaksetaraan di beberapa properti dan menyederhanakan pengembangan aplikasi dengan mendelegasikan implementasi logika pasca-pemfilteran ke Firestore dalam mode Datastore.

Filter rentang dan ketidaksetaraan di beberapa properti

Kueri berikut menggunakan filter rentang pada prioritas dan hari untuk menampilkan semua tugas dengan prioritas lebih dari empat dan dengan waktu penyelesaian kurang dari tiga hari.

Go

query := datastore.NewQuery("Task").
   FilterField("priority", ">", 4).
   FilterField("days", "<", 3).

GQL

SELECT * FROM /tasks WHERE priority > 4 AND days < 3;

Java

Query<Entity> query =
    Query.newEntityQueryBuilder()
      .setKind("Task")
      .setFilter(
        CompositeFilter.and(
            PropertyFilter.gt("priority", 4), PropertyFilter.lt("days", 3)))
    .build();

Node.js

const query = datastore
  .createQuery('Task')
  .filter(
    and([
      new PropertyFilter('priority', '>', 4),
      new PropertyFilter('days', '<', 3),
    ])
  );

Python

from google.cloud import datastore
client = datastore.Client()
query = client.query(kind="Task")
query.add_filter(filter=PropertyFilter("priority", ">", 4))
query.add_filter(filter=PropertyFilter("days", "<", 3))

PHP

$query = $datastore->query()
    ->kind('Task')
    ->filter('priority', '>', 4)
    ->filter('days', '<', 3)

C#

Query query = new Query("Task")
{
  Filter = Filter.And(Filter.GreaterThan("priority", 4),
    Filter.LessThan("days", 3))
};

Ruby

query = datastore.query("Task")
                 .where("priority", ">", 4)
                 .where("days", "<", 3)

Pertimbangan pengindeksan

Sebelum mulai menjalankan kueri, pastikan Anda telah membaca tentang kueri.

Jika klausa ORDER BY tidak ditentukan, Firestore dalam mode Datastore akan menggunakan indeks apa pun yang dapat memenuhi kondisi filter kueri untuk menayangkan kueri. Pendekatan ini menghasilkan kumpulan hasil yang diurutkan sesuai dengan definisi indeks.

Untuk mengoptimalkan performa dan biaya kueri Firestore dalam mode Datastore, optimalkan urutan properti dalam indeks. Untuk melakukannya, pastikan indeks diurutkan dari kiri ke kanan sehingga kueri disaring ke set data yang mencegah pemindaian entri indeks yang tidak relevan.

Misalnya, Anda ingin menelusuri kumpulan karyawan untuk menemukan karyawan Amerika Serikat yang gajinya lebih dari $100.000 dan jumlah tahun pengalamannya lebih besar dari 0. Berdasarkan pemahaman Anda terhadap set data, Anda tahu bahwa batasan gaji lebih selektif daripada batasan pengalaman. Indeks yang mengurangi jumlah pemindaian indeks adalah indeks (salary [...], experience [...]). Akibatnya, kueri yang cepat dan hemat biaya akan mengurutkan salary sebelum experience, seperti yang ditunjukkan dalam contoh berikut:

GQL

SELECT *
FROM /employees
WHERE salary > 100000 AND experience > 0
ORDER BY salary, experience

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(
        CompositeFilter.and(
            PropertyFilter.gt("salary", 100000), PropertyFilter.gt("experience", 0)))
    .setOrderBy(OrderBy("salary"), OrderBy("experience"))
    .build();

Node.js

const query = datastore
  .createQuery("employees")
  .filter(
    and([
      new PropertyFilter("salary", ">", 100000),
      new PropertyFilter("experience", ">", 0),
       ])
    )
  .order("salary")
  .order("experience");

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.add_filter("experience", ">", 0)
query.order = ["-salary", "-experience"]

Praktik terbaik untuk mengoptimalkan indeks

Saat mengoptimalkan indeks, perhatikan praktik terbaik berikut.

Mengurutkan kueri berdasarkan kesetaraan, diikuti dengan sebagian besar kolom rentang atau ketidaksetaraan selektif

Firestore dalam mode Datastore menggunakan properti paling kiri dari indeks komposit untuk memenuhi batasan kesetaraan dan batasan rentang dan ketidaksetaraan, jika ada, di kolom pertama kueri orderBy(). Batasan ini dapat mengurangi jumlah entri indeks yang dipindai Firestore dalam mode Datastore. Firestore dalam mode Datastore menggunakan properti indeks yang tersisa untuk memenuhi batasan rentang dan ketidaksetaraan lainnya dari kueri. Batasan ini tidak mengurangi jumlah entri indeks yang dipindai Firestore dalam mode Datastore, tetapi memfilter entitas yang tidak cocok sehingga jumlah entitas yang ditampilkan kepada klien akan berkurang.

Untuk mengetahui informasi selengkapnya tentang cara membuat indeks yang efisien, lihat struktur dan definisi indeks serta mengoptimalkan indeks.

Mengurutkan properti dalam urutan menurun dari selektivitas batasan kueri

Untuk memastikan Firestore dalam mode Datastore memilih indeks yang optimal untuk kueri Anda, tentukan klausa orderBy() yang mengurutkan properti rentang dan ketidaksetaraan berdasarkan selektivitas batasan dalam kueri Anda, mulai dari yang paling selektif. Selektivitas yang lebih tinggi cocok dengan lebih sedikit entitas, sedangkan selektivitas yang lebih rendah cocok dengan lebih banyak entitas. Dalam pengurutan indeks, tempatkan properti rentang dan ketidaksetaraan dengan selektivitas lebih tinggi sebelum properti dengan selektivitas lebih rendah.

Untuk meminimalkan jumlah entity yang dipindai dan ditampilkan oleh Firestore dalam mode Datastore melalui jaringan, Anda harus selalu mengurutkan properti dalam urutan menurun dari selektivitas batasan kueri. Jika set hasil tidak dalam urutan yang diperlukan dan set hasil tersebut diharapkan kecil, Anda bisa menerapkan logika sisi klien untuk mengurutkan ulang sesuai ekspektasi pengurutan Anda.

Misalnya, Anda ingin menelusuri kumpulan karyawan untuk menemukan karyawan Amerika Serikat yang gajinya lebih dari $100.000 dan mengurutkan hasilnya berdasarkan tahun pengalaman karyawan. Jika Anda memperkirakan hanya sejumlah kecil karyawan yang akan menerima gaji lebih tinggi dari $100.000, cara yang efisien untuk menulis kueri adalah sebagai berikut:

Java

Query<Entity> query =
  Query.newEntityQueryBuilder()
    .setKind("employees")
    .setFilter(PropertyFilter.gt("salary", 100000))
    .setOrderBy(OrderBy("salary"))
    .build();
QueryResults<Entity> results = datastore.run(query);
// Order results by `experience`

Node.js

const query = datastore
  .createQuery("employees")
  .filter(new PropertyFilter("salary", ">", 100000))
  .order("salary");
const [entities] = await datastore.runQuery(query);
// Order results by `experience`

Python

query = client.query(kind="employees")
query.add_filter("salary", ">", 100000)
query.order = ["salary"]
results = query.fetch()
// Order results by `experience`

Meskipun menambahkan pengurutan pada experience ke kueri akan menghasilkan kumpulan entity yang sama dan meniadakan pengaturan ulang hasil pada klien, kueri mungkin membaca banyak entri indeks yang lebih tidak relevan daripada kueri sebelumnya. Hal ini karena Firestore dalam mode Datastore selalu memilih indeks yang awalan properti indeksnya cocok dengan urutan berdasarkan klausa kueri. Jika experience ditambahkan ke urutan berdasarkan klausa, Firestore dalam mode Datastore akan memilih indeks (experience [...], salary [...]) untuk menghitung hasil kueri. Karena tidak ada batasan lain pada experience, Firestore dalam mode Datastore akan membaca semua entri indeks koleksi employees sebelum menerapkan filter salary untuk menemukan set hasil akhirnya. Ini berarti entri indeks yang tidak memenuhi filter salary akan tetap dibaca, sehingga meningkatkan latensi dan biaya kueri.

Harga

Kueri dengan filter rentang dan ketidaksetaraan di beberapa properti ditagih berdasarkan entity yang dibaca dan entri indeks yang dibaca.

Untuk mengetahui informasi mendetail, lihat halaman Harga.

Batasan

Selain batasan kueri, perhatikan batasan berikut sebelum menggunakan kueri dengan filter rentang dan ketidaksetaraan di beberapa properti:

  • Agar kueri tidak menjadi terlalu mahal untuk dijalankan, Firestore dalam mode Datastore membatasi jumlah operator rentang atau ketidaksetaraan hingga 10.

Langkah Berikutnya