Typy indeksów w Cloud Firestore

Indeksy są ważnym czynnikiem wpływającym na wydajność bazy danych. Podobnie jak indeks książki, który mapuje tematy w książce na numery stron, indeks bazy danych mapuje elementy w bazie danych na ich lokalizacje w bazie danych. Gdy wysyłasz zapytanie do bazy danych, może ona użyć indeksu, aby szybko zidentyfikować lokalizacje żądanych elementów.

Na tej stronie opisujemy 2 typy indeksów używanych przez Cloud Firestore: indeksy automatyczne i indeksy ręczne.

Definicja i struktura indeksu

Indeks jest definiowany na liście pól danego dokumentu, z odpowiednim trybem indeksowania dla każdego pola.

Indeks zawiera wpis dla każdego pola wymienionego 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 ustawioną zindeksowaną wartość dla każdego pola używanego w indeksie. Jeśli definicja indeksu odnosi się do pola, dla którego dokument nie ma ustawionej wartości, ten dokument nie pojawi się w indeksie. W takim przypadku dokument nigdy nie zostanie zwrócony jako wynik żadnego zapytania opartego na indeksie.

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

Indeks za każdym zapytaniem

Jeśli dla zapytania nie ma indeksu, większość baz danych przeszukuje zawartość element po elemencie. Jest to powolny proces, który staje się jeszcze wolniejszy w miarę rozrastania się bazy danych. Cloud Firestore zapewnia wysoką wydajność zapytań, używając indeksów w przypadku wszystkich zapytań. W efekcie wydajność zapytania zależy od rozmiaru zbioru wyników, a nie od liczby elementów w bazie danych.

Mniej zarządzania indeksami, więcej tworzenia aplikacji

Cloud Firestore zawiera funkcje, które skracają czas potrzebny na zarządzanie indeksami. Indeksy wymagane do obsługi najbardziej podstawowych zapytań są tworzone automatycznie. Gdy używasz i testujesz aplikację, Cloud Firestore pomaga Ci identyfikować i tworzyć dodatkowe indeksy, których wymaga aplikacja.

Typy indeksów

Cloud Firestore używa 2 rodzajów indeksów: automatycznych i ręcznych. Indeksy ręczne i automatyczne różnią się sposobem zarządzania.

Indeksy automatyczne

Domyślnie Cloud Firestore automatycznie tworzy indeksy dla każdego pola obecnego w dokumentach w kolekcji. Te indeksy pojedynczego pola umożliwiają wykonywanie wielu podstawowych zapytań. Indeksami automatycznymi zarządzasz, konfigurując ustawienia automatycznego indeksowania bazy danych i wykluczenia indeksów.

Domyślne ustawienia indeksu automatycznego

Cloud Firestore używa tych domyślnych ustawień indeksów automatycznych:

• Dla każdego pola, które nie jest tablicą ani mapą, Cloud Firestore definiuje 2 indeksy w zakresie kolekcji – jeden w trybie rosnącym i jeden w trybie malejącym.

• Dla każdego pola mapy Cloud Firestore tworzy:

  • 1 rosnący indeks o zakresie kolekcji dla każdego podpola, które nie jest tablicą ani mapą.
  • 1 indeks malejący o zakresie kolekcji dla każdego podpola, które nie jest tablicą ani mapą.
  • 1 indeks rosnący w zakresie kolekcji dla całej wartości mapy,
  • 1 indeks malejący o zakresie kolekcji dla całej wartości mapy,
  • 1 indeks array-contains o zakresie kolekcji dla każdego podpola tablicy.
  • Cloud Firestore indeksuje rekurencyjnie każde podpole mapy.

• Dla każdego pola tablicy w dokumencie Cloud Firestore tworzy:

  • 1 indeks rosnący o zakresie kolekcji dla całej wartości tablicy,
  • 1 indeks malejący w zakresie kolekcji dla całej wartości tablicy.
  • 1 indeks typu „tablica zawiera” o zakresie kolekcji.

• Indeksy automatyczne z zakresem grupy kolekcji nie są domyślnie utrzymywane.

Wykluczenia indeksów automatycznych

Możesz wykluczyć pole z ustawień automatycznego indeksowania, tworząc wykluczenie indeksowania. Wykluczenie z indeksowania zastępuje ustawienia automatycznego indeksu dotyczące całej bazy danych. Wykluczenie pozwala włączyć indeks, który w innym przypadku zostałby wyłączony przez ustawienia automatycznego indeksowania, lub wyłączyć indeks, który w innym przypadku zostałby włączony przez ustawienia automatycznego indeksowania. Przykłady sytuacji, w których zwolnienia mogą być przydatne, znajdziesz w sprawdzonych metodach indeksowania.

Użyj wartości ścieżki pola *, aby dodać wykluczenia indeksu na poziomie kolekcji we wszystkich polach 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łączyć indeksowanie wszystkich pól w tej grupie. Następnie możesz dodać wykluczenia, aby indeksować tylko pola wymagane w zapytaniach. Zmniejszenie liczby indeksowanych pól obniża koszty miejsca na dane i może zwiększyć wydajność zapisu.

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

Informacje o tworzeniu wykluczeń indeksów automatycznych i zarządzaniu nimi znajdziesz w artykule o zarządzaniu indeksami.

Indeksy ręczne

W indeksie ręcznym przechowywane jest posortowane mapowanie wszystkich dokumentów w kolekcji na podstawie uporządkowanej listy pól do zindeksowania.

Cloud Firestore używa indeksów ręcznych do obsługi zapytań, których nie obsługują indeksy automatyczne.

Domyślnie Cloud Firestore automatycznie tworzy indeksy jednopolowe dla każdego pola w kolekcji. Cloud Firestore nie tworzy automatycznie indeksów dla kombinacji pól ze względu na dużą liczbę możliwych kombinacji. Zamiast tego Cloud Firestore pomaga identyfikować i tworzyć wymagane indeksy podczas tworzenia aplikacji.

Za każdym razem, gdy spróbujesz wykonać zapytanie, które nie jest obsługiwane przez istniejący indeks, Cloud Firestore zwróci komunikat o błędzie z linkiem, który możesz kliknąć, aby utworzyć brakujący indeks.

Możesz też definiować indeksy i zarządzać nimi ręcznie za pomocą konsoli lub interfejsu wiersza poleceń Firebase. Więcej informacji o tworzeniu indeksów ręcznych i zarządzaniu nimi znajdziesz w artykule Zarządzanie indeksami.

Tryby indeksowania i zakresy zapytań

Indeksy automatyczne i ręczne konfiguruje się inaczej, ale w obu przypadkach musisz skonfigurować tryby indeksowania i zakresy zapytań.

Tryby indeksowania

Podczas definiowania indeksu wybierasz tryb indeksowania dla każdego indeksowanego pola. Tryb indeksowania każdego pola obsługuje określone klauzule zapytania dotyczące tego pola. Do wyboru masz te tryby 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 obejmuje wszystkie kolekcje o tym samym identyfikatorze. Aby uruchomić zapytanie dotyczące grupy kolekcji, które zwraca przefiltrowane lub uporządkowane wyniki z grupy kolekcji, musisz utworzyć odpowiedni indeks z zakresem grupy kolekcji.

Domyślne sortowanie i pole __name__

Oprócz sortowania dokumentów według trybów indeksowania określonych dla każdego pola (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 z tymi samymi wartościami 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 posortować wyniki według kierunku innego niż domyślny (__name__), musisz utworzyć ten indeks.

Właściwości indeksu

Indeks, który umożliwia najbardziej efektywne wykonywanie zapytania, jest definiowany 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ą jeszcze uwzględnione w kolejności sortowania);
• pola używane w agregacjach (które nie są jeszcze uwzględnione w kolejności sortowania oraz filtrach zakresu i nierówności).

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

1. Identyfikuje indeks odpowiadający kolekcji zapytania, właściwościom filtra, operatorom filtra i kolejności sortowania.
2. Określa pozycję indeksu, od której rozpoczyna się skanowanie. Pozycja początkowa jest poprzedzona filtrami równości zapytania i kończy się filtrami zakresu i nierówności w pierwszym polu orderBy.
3. Rozpoczyna skanowanie indeksu i zwraca każdy dokument, który spełnia wszystkie filtry, dopóki proces skanowania nie wykona jednej z tych czynności:
   • napotka dokument, który nie spełnia warunków filtra, i potwierdzi, że żaden kolejny dokument nigdy nie będzie w pełni spełniać warunków filtra.
   • osiągnie koniec indeksu.
   • Zbiera maksymalną liczbę wyników żądanych przez zapytanie.

Przykład indeksowania

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

Aby to zilustrować, przeanalizuj poniższe przykłady z punktu widzenia tworzenia indeksu. Ten fragment kodu tworzy kilka dokumentów city w kolekcji cities i ustawia pola name, state, country, capital, population i regions dla każdego dokumentu:

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 domyślnych ustawieniach automatycznego indeksowania Cloud Firestore aktualizuje 1 rosnący indeks pojedynczego pola na pole, 1 malejący indeks pojedynczego pola na pole i 1 indeks pojedynczego pola array-contains dla pola tablicy. Każdy wiersz w poniższej tabeli odpowiada wpisowi w indeksie jednopolowym:

Zapytania obsługiwane przez indeksy pojedynczego pola

Korzystając z tych automatycznie utworzonych indeksów jednopolowych, możesz uruchamiać 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 o równość złożoną (==):

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ć według innego pola, musisz utworzyć indeks ręczny dla tego zapytania.

Indeks array-contains umożliwia wysyłanie zapytań do 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 ręczne

Utwórz indeksy ręczne, aby obsługiwać zapytania złożone, które nie są jeszcze obsługiwane przez automatyczne indeksy pojedynczego pola. Na przykład indeks ręczny jest 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ą tego indeksu. Ponieważ zapytanie używa równości (== lub in) w polu country, możesz użyć w tym polu trybu indeksu rosnącego lub malejącego. Domyślnie klauzule nierówności stosują kolejność sortowania rosnąco na podstawie pola w klauzuli nierówności.

Aby uruchomić te same zapytania, ale z kolejnością sortowania malejąco, potrzebujesz dodatkowego indeksu w kierunku malejącym dla właściwości 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ąć spadku wydajności spowodowanego scalaniem indeksów, zalecamy utworzenie indeksu, który połączy zapytanie 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 grupy kolekcji, dodaj podkolekcję 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 poniższego indeksu z jednym polem i zakresem kolekcji, możesz wysłać zapytanie do kolekcji landmarks pojedynczego 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 chcesz na przykład wysłać zapytanie o punkty orientacyjne we wszystkich miastach, uruchom to zapytanie w grupie kolekcji, która składa się ze wszystkich kolekcji landmarks. Musisz też włączyć landmarks indeks pojedynczego pola 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 uruchomić zapytanie dotyczące grupy kolekcji, które zwraca przefiltrowane lub uporządkowane wyniki, musisz włączyć odpowiedni indeks z zakresem grupy kolekcji. Zapytania dotyczące grup kolekcji, które nie filtrują ani nie porządkują 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 wliczają się do limitu liczby wpisów indeksu.

Poniższy przykład pokazuje wpisy indeksu dokumentu.

Dokument

/cities/SF

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

Indeksy automatyczne

• city_name ASC
• city_name DESC
• dzielnice rosnąco
• dzielnice MALEJĄCO
• temperatury rosnąco
• temperatures DESC
• temperatures.summer ASC
• temperatures.summer DESC
• temperatures.winter ASC
• temperatures.winter DESC
• neighborhoods Array Contains

Indeksy ręczne

• city_name ASC, neighborhoods ARRAY
• city_name DESC, neighborhoods ARRAY

Wpisy indeksu

Ta konfiguracja indeksowania powoduje utworzenie tych wpisów indeksu dla dokumentu:

Indeksy i ceny

Indeksy wpływają na koszty miejsca na dane aplikacji. Więcej informacji o obliczaniu rozmiaru miejsca na dane dla indeksów znajdziesz w artykule Rozmiar wpisu indeksu.

Używanie scalania indeksów

Chociaż Cloud Firestore używa indeksu w każdym zapytaniu, niekoniecznie wymaga jednego indeksu na zapytanie. W przypadku zapytań z wieloma klauzulami równości (==) i opcjonalnie klauzulą orderBy Cloud Firestore może ponownie użyć istniejących indeksów. Cloud Firestore może scalać indeksy prostych filtrów równości, aby tworzyć indeksy potrzebne do obsługi większych zapytań równości.

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 aplikacji do oceniania restauracji:

• collections_bookmark restauracja

  • class burgerthyme

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

Ta aplikacja używa zapytań takich jak poniższe. Aplikacja używa kombinacji klauzul równości dla pól category, city i editors_pick, zawsze sortując według pola star_rating w porządku rosnącym:

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 możliwości Cloud Firestore do scalania indeksów w przypadku klauzul równości:

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

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

Limity indeksowania

W przypadku indeksów obowiązują podane niżej limity. Więcej informacji o limitach znajdziesz w artykule Limity.

Sprawdzone metody dotyczące indeksowania

W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i linkach w komunikatach o błędach, aby zarządzać indeksami. Możesz jednak dodać wykluczenia automatycznego indeksowania 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 należy wziąć pod uwagę, aby zoptymalizować wydajność i koszt zapytań Cloud Firestore.

Więcej informacji o rozwiązywaniu problemów z indeksowaniem (fanout indeksu, błędy INVALID_ARGUMENT) znajdziesz na stronie rozwiązywania problemów.