Typy indeksów w Cloud Firestore

Indeksy mają duży wpływ na wydajność bazy danych. Podobnie jak indeks książki, który przyporządkowuje tematy do numerów stron, indeks bazy danych przyporządkowuje elementy bazy danych do ich lokalizacji w bazie danych. Gdy wysyłasz zapytanie do bazy danych, może ona użyć indeksu do szybkiej identyfikacji lokalizacji żądanych elementów.

Na tej stronie opisujemy 2 typy indeksów używane przez Cloud Firestore: indeksy z jednym polem i indeksy złożone.

Definicja i struktura indeksu

Indeks jest zdefiniowany na liście pól danego dokumentu, a każdemu z nich odpowiada tryb indeksowania.

Indeks zawiera wpis dla każdego pola określonego w definicji indeksu. Indeks zawiera wszystkie dokumenty, które są potencjalnymi wynikami zapytań opartych na indeksie. Dokument jest uwzględniany w indeksie tylko wtedy, gdy ma zdefiniowaną wartość indeksowaną dla każdego pola użytego w indeksie. Jeśli definicja indeksu odnosi się do pola, dla którego w dokumencie nie ma ustawionej wartości, dokument nie pojawi się w indeksie. W takim przypadku dokument nigdy nie zostanie zwrócony w wyniku dla żadnego zapytania korzystającego z indeksu.

Indeks złożony jest sortowany według wartości pól w kolejności określonej w definicji indeksu.

Indeks za każdym zapytaniem

Jeśli nie istnieje indeks zapytania, większość baz danych indeksuje ich zawartość element po elemencie. Jest to powolny proces, który jeszcze bardziej spowalnia wraz z wzrostem bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki użyciu indeksów dla wszystkich zapytań. W efekcie wydajność zapytań zależy od rozmiaru zbioru wyników, a nie od liczby elementów w bazie danych.

Mniej zarządzania indeksem, więcej czasu na rozwój aplikacji

Cloud Firestore zawiera funkcje, które skracają czas poświęcany na zarządzanie indeksami. Indeksy wymagane do najprostszych zapytań są tworzone automatycznie. Podczas używania i testowania aplikacji Cloud Firestore pomaga Ci zidentyfikować i utworzyć dodatkowe indeksy, których potrzebuje Twoja aplikacja.

Typy indeksów

Cloud Firestore używa 2 typów indeksów: pojedynczego pola i złożonego. Oprócz liczby zindeksowanych pól indeksy z pojedynczym polem i złożone różnią się sposobem zarządzania nimi.

Indeksy pojedynczego pola

W indeksie jednopolowym przechowywane jest posortowane mapowanie wszystkich dokumentów w kolekcji, które zawierają określone pole. Każdy wpis w indeksie jednopolowym zawiera wartość dokumentu w danym polu oraz jego położenie w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu zapytań podstawowych. Aby zarządzać indeksami z pojedynczymi polami, skonfiguruj ustawienia automatycznego indeksowania i wykluczenia indeksów w bazie danych.

Automatyczne indeksowanie

Domyślnie Cloud Firestore automatycznie utrzymuje indeksy pojedynczych pól w przypadku każdego pola w dokumencie i każdego podpola w mapie. Cloud Firestoreużywa tych domyślnych ustawień indeksów jednopolowych:

• W przypadku każdego pola, które nie jest tablicą ani mapą, funkcja Cloud Firestore definiuje 2 indeksy pojedynczego pola o zakresie kolekcji: jeden w trybie rosnącym i jeden w trybie malejącym.

• W przypadku każdego pola mapy Cloud Firestore tworzy:

  • Jeden indeks rosnący o zakresie na poziomie zbioru dla każdego pola podrzędnego niebędącego tablicą i niemającego mapy.
  • Jeden indeks w zakresie kolekcji w porządku malejącym dla każdego podpola, które nie jest tablicą ani mapą.
  • jeden indeks tablicy na poziomie kolekcji dla każdego podpola tablicy;
  • Cloud Firestore rekurencyjnie indeksuje każde podpole mapy.

• W przypadku każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks tablicy zawierającej o zakresie kolekcji.

• Indeksy z jednym polem z zakresem grupy kolekcji nie są domyślnie obsługiwane.

Wykluczenie indeksu pojedynczego pola

Możesz wykluczyć pole z ustawień automatycznego indeksowania, tworząc wykluczenie indeksu pojedynczego pola. Wykluczenie z indeksowania zastępuje ustawienia automatycznego indeksu dotyczące całej bazy danych. Wykluczenie pozwala włączyć indeks pojedynczego pola, który w innym przypadku zostałby wyłączony przez ustawienia automatycznego indeksowania, lub wyłączyć indeks pojedynczego pola, który w innym przypadku zostałby włączony przez ustawienia automatycznego indeksowania. Aby dowiedzieć się, kiedy możesz skorzystać z wyjątków, zapoznaj się ze sprawdzonymi metodami indeksowania.

Użyj wartości ścieżki pola *, aby dodać wyłączenia indeksowania na poziomie kolekcji dla wszystkich pól w grupie kolekcji. Na przykład w przypadku grupy kolekcji comments ustaw ścieżkę pola na *, aby dopasować wszystkie pola w grupie kolekcji comments, i wyłącz indeksowanie wszystkich pól w grupie kolekcji. Następnie możesz dodać wykluczenia, aby indeksować tylko pola wymagane do zapytań. Zmniejszenie liczby indeksowanych pól zmniejsza koszty przechowywania i może poprawić wydajność zapisu.

Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, pola podrzędne mapy odziedziczą te ustawienia. Możesz jednak zdefiniować wykluczenia indeksu pojedynczego pola dla konkretnych pól podrzędnych. Jeśli usuniesz wykluczenie dla podpola, odziedziczy ono ustawienia wykluczenia elementu nadrzędnego (jeśli takie istnieją) lub ustawienia ogólne bazy danych (jeśli nie ma wykluczeń nadrzędnych).

Informacje o tym, jak tworzyć wykluczenia indeksów pojedynczych pól i nimi zarządzać, znajdziesz w artykule Zarządzanie indeksami.

Indeksy złożone

Indeks złożony przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji na podstawie uporządkowanej listy pól do indeksowania.

Funkcja Cloud Firestore używa indeksów złożonych do obsługi zapytań, które nie są jeszcze obsługiwane przez indeksy z pojedynczym polem.

Ze względu na dużą liczbę możliwych kombinacji pól Cloud Firestore nie tworzy automatycznie indeksów złożonych tak jak w przypadku indeksów z pojedynczym polem. Zamiast tego Cloud Firestore pomaga identyfikować i tworzyć wymagane indeksy złożone podczas tworzenia aplikacji.

Za każdym razem, gdy próbujesz wykonać zapytanie, które nie jest obsługiwane przez indeks, Cloud Firestorezwraca komunikat o błędzie z linkiem, który umożliwia utworzenie brakującego indeksu.

Indeksy złożone można też definiować i zarządzać nimi ręcznie za pomocą konsoli lub interfejsu wiersza poleceń Firebase. Więcej informacji o tworzeniu indeksów złożonych i zarządzaniu nimi znajdziesz w artykule Zarządzanie indeksami.

Tryby indeksowania i zakresy zapytań

Indeksy z jednym polem i złożonymi konfigurujesz inaczej, ale oba wymagają skonfigurowania trybów indeksów i zakresów zapytań.

Tryby indeksowania

Podczas definiowania indeksu możesz wybrać tryb indeksowania dla każdego indeksowanego pola. Tryb indeksu każdego pola obsługuje określone klauzule zapytania w tym polu. Możesz wybrać jeden z tych trybów indeksowania:

Zakresy zapytań

Każdy indeks jest ograniczony do kolekcji lub grupy kolekcji. Jest to tzw. zakres zapytania indeksu:

Zakres kolekcji

Cloud Firestore domyślnie tworzy indeksy z zakresem kolekcji. Te indeksy obsługują zapytania, które zwracają wyniki z pojedynczej kolekcji.

Zakres grupy kolekcji

Grupa kolekcji zawiera wszystkie kolekcje z tym samym identyfikatorem. Aby uruchomić zapytanie dotyczące grupy kolekcji, które zwróci przefiltrowane lub uporządkowane wyniki z grupy kolekcji, musisz utworzyć odpowiedni indeks z zakresem grupy kolekcji.

Domyślna kolejność i pole __name__

Oprócz sortowania dokumentów według trybów indeksowania określonych dla poszczególnych pól (rosnąco lub malejąco) indeksy stosują ostateczne sortowanie według pola __name__ każdego dokumentu. Wartość pola __name__ jest ustawiona na pełną ścieżkę dokumentu. Oznacza to, że dokumenty w zbiorze wyników o tych samych wartościach pól są sortowane według ścieżki dokumentu.

Domyślnie pole __name__ jest sortowane w tym samym kierunku co ostatnie posortowane pole w definicji indeksu. Przykład:

Aby sortować wyniki w innej niż domyślna __name__kierunku, musisz utworzyć indeks.

Właściwości indeksu

Indeks, który umożliwia najbardziej efektywne wykonanie zapytania, jest zdefiniowany przez te właściwości:

• Pola używane w filtrach równości
• Pola używane w kolejności sortowania
• Pola używane w filtrach zakresu i nierówności (które nie są już uwzględnione w porządku sortowania)
• Pola używane w agregacjach (które nie są jeszcze uwzględnione w kolejności sortowania ani filtrach zakresu i nierówności)

Cloud Firestore oblicza wyniki zapytań w ten sposób:

1. Określa indeks odpowiadający kolekcji zapytania, właściwościom filtra, operatorom filtra i porządkowaniu.
2. Określa pozycję indeksu, od której rozpoczyna się skanowanie. Pozycja początkowa jest poprzedzona filtrami równości zapytania, a kończy filtrami zakresu i nierówności w pierwszym polu orderBy.
3. Rozpoczyna skanowanie indeksu i zwraca każdy dokument zgodny ze wszystkimi filtrami, dopóki proces skanowania nie wykona jednej z tych czynności:
   • Napotyka dokument, który nie spełnia warunków filtra, i potwierdza, że każdy kolejny dokument nigdy nie będzie w pełni spełniał warunków filtra.
   • Dociera do końca indeksu.
   • Zbiera maksymalną liczbę wyników zwróconych przez zapytanie.

Przykład indeksowania

Dzięki automatycznemu tworzeniu indeksów jednopolowych Cloud Firestoreumożliwia aplikacji szybkie obsługiwanie najbardziej podstawowych zapytań do bazy danych. Indeksy jednopolowe umożliwiają wykonywanie prostych zapytań na podstawie wartości pól i porównań <, <=, ==, >=, > i in. W przypadku pól tablicowych umożliwiają one wykonywanie zapytań array-contains i array-contains-any.

Aby to zilustrować, spójrz na poniższe przykłady z perspektywy tworzenia indeksu. Ten fragment kodu tworzy kilka dokumentów city w zbiorze cities i ustawia w każdym z nich pola name, state, country, capital, population i tags:

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

Przy założeniu domyślnych ustawień automatycznego indeksowania Cloud Firestore aktualizuje jeden indeks pojedynczego pola w porządku rosnącym na każde pole niebędące tablicą, jeden indeks pojedynczego pola w porządku malejącym na każde pole niebędące tablicą oraz jeden indeks pojedynczego pola zawierającego tablicę na pole tablicowe. Każdy wiersz w poniższej tabeli odpowiada wpisowi w indeksie z jednym polem:

Zapytania obsługiwane przez indeksy z jednym polem

Za pomocą tych automatycznie utworzonych indeksów jednopolowych możesz wykonywać proste zapytania, takie jak:

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

Możesz też tworzyć zapytania in i zapytania złożone o równość (==):

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)

Jeśli chcesz uruchomić zapytanie złożone, które używa porównania zakresu (<, <=, > lub >=), lub jeśli chcesz posortować dane według innego pola, musisz utworzyć dla tego zapytania indeks złożony.

Indeks array-contains umożliwia wysyłanie zapytań dotyczących pola tablicy 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"])

Zapytania obsługiwane przez indeksy złożone

Cloud Firestore używa indeksów złożonych do obsługi złożonych zapytań, których nie obsługują indeksy pojedynczych pól. Indeks złożony będzie na przykład potrzebny w przypadku tych zapytań:

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)

Te zapytania wymagają indeksu złożonego poniżej. Ponieważ zapytanie używa równości (== lub in) w przypadku pola country, możesz użyć w tym polu trybu indeksu rosnącego lub malejącego. Domyślnie klauzule nierówności stosują sortowanie rosnące według pola w klauzuli nierówności.

Aby wykonać te same zapytania, ale w kolejności malejącej, potrzebujesz dodatkowego indeksu złożonego w kierunku malejącym dla kolumny 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")

Aby uniknąć utraty wydajności spowodowanej przez scalanie indeksów, zalecamy utworzenie indeksu złożonego w celu połączenia zapytania array-contains lub array-contains-any z dodatkowymi klauzulami:

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)

Zapytania obsługiwane przez indeksy grup kolekcji

Aby zademonstrować indeks z zakresem grup kolekcji, dodaj kolekcję podrzędną landmarks do niektórych dokumentów 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" });

Korzystając z tego indeksu z jednym polem o zakresie kolekcji, możesz wysłać zapytanie do kolekcji landmarks z jednego miasta na podstawie pola category:

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

Jeśli na przykład chcesz wysyłać zapytania o punkty orientacyjne we wszystkich miastach, uruchamiasz to zapytanie w grupie kolekcji złożonej ze wszystkich kolekcji landmarks. Musisz też włączyć indeks z pojedynczym polem (landmarks) z zakresem grupy kolekcji:

Po włączeniu tego indeksu możesz wysyłać zapytania do grupy kolekcji landmarks:

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

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

Aby wykonać zapytanie dotyczące grupy kolekcji, które zwraca przefiltrowane lub posortowane wyniki, musisz włączyć odpowiedni indeks pojedynczego pola lub złożony z zakresem grup kolekcji. Zapytania dotyczące grup kolekcji, które nie filtrują ani nie sortują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.

Możesz na przykład uruchomić to zapytanie dotyczące grupy kolekcji bez włączania dodatkowego indeksu:

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

Wpisy indeksu

Liczba wpisów indeksu dla dokumentu zależy od skonfigurowanych indeksów projektu i struktury dokumentu. Wpisy indeksu są wliczane do limitu liczby wpisów indeksu.

Na przykładzie poniżej przedstawiono wpisy indeksu dokumentu.

Dokument

/cities/SF

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

Indeksy pojedynczego pola

• nazwa_miasta AS
• nazwa_miasta DESC
• temperatury.letnie ASC
• temperatures.summer DESC
• temperatures.winter ASC
• temperatury.zima DESC
• Dzielnice tablica zawiera (ASC i DESC)

Indeksy złożone

• city_name ASC, neighborhoods ARRAY
• nazwa_miasta DESC, dzielnice ARRAY

Wpisy indeksu

Ta konfiguracja indeksowania powoduje, że w przypadku dokumentu występują następujące wpisy indeksu:

Indeksy i ceny

Indeksy zwiększają koszty miejsca na dane aplikacji. Więcej informacji o sposobie obliczania rozmiaru miejsca na dane dla indeksów znajdziesz w sekcji Rozmiar wpisu indeksu.

Użyj scalania indeksu

Chociaż Cloud Firestore używa indeksu dla każdego zapytania, nie musi to być jeden indeks na zapytanie. W przypadku zapytań z wieloma klauzulami równości (==) i opcjonalnie klauzulą orderBy Cloud Firestore może ponownie używać istniejących indeksów. Cloud Firestore może scalać indeksy prostych filtrów równości, aby tworzyć indeksy złożone potrzebne do obsługi większych zapytań równościowych.

Możesz obniżyć koszty indeksowania, identyfikując sytuacje, w których możesz użyć scalania indeksów. Na przykład w kolekcji restaurants dotyczącej oceny restauracji:

• collections_bookmark restauracji

  • Burgerthyme: class

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

Ta aplikacja używa zapytań takich jak te: Aplikacja używa kombinacji klauzul równości dla category, city i editors_pick, zawsze sortując rosnąco według kolumny star_rating:

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")

Możesz utworzyć indeks dla każdego zapytania:

Lepszym rozwiązaniem jest zmniejszenie liczby indeksów przez wykorzystanie funkcji Cloud Firestore do łączenia indeksów klauzul równości:

Ten zbiór indeksów jest nie tylko mniejszy, ale obsługuje też dodatkowe zapytanie:

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

Limity indeksowania

Do indeksów obowiązują następujące limity. Więcej informacji o limitach znajdziesz w artykule Limity i limity.

Sprawdzone metody indeksowania

W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i linkach w wiadomościach o błędzie, aby zarządzać indeksami. Możesz jednak dodać wykluczenia dotyczące pojedynczego pola w tych przypadkach:

Jeśli używasz zapytań z operatorami zakresu i nierówności w wielu polach, zapoznaj się z uwagami dotyczącymi indeksowania, które warto wziąć pod uwagę, aby zoptymalizować wydajność i koszt zapytań Cloud Firestore.

Więcej informacji o rozwiązywaniu problemów z indeksowaniem (zwielokrotnienia indeksowania i błędów INVALID_ARGUMENT) znajdziesz na stronie rozwiązywania problemów.