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 odwzorowuje tematy w książce na numery stron, indeks bazy danych odwzorowuje pozycje w bazie danych na ich lokalizacje w bazie danych. Kiedy wysyłasz zapytanie do bazy danych, baza danych może użyć indeksu, aby szybko wyszukać lokalizacje żądanych elementów.

Na tej stronie opisano dwa typy indeksów używanych przez Cloud Firestore: indeksy jednopolowe i indeksy złożone .

Indeks kryjący się za każdym zapytaniem

Jeśli dla zapytania nie istnieje indeks, większość baz danych przeszukuje zawartość element po elemencie. Jest to powolny proces, który spowalnia jeszcze bardziej w miarę powiększania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki zastosowaniu indeksów dla wszystkich zapytań. W rezultacie wydajność zapytań zależy od rozmiaru zestawu 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 zmniejszają ilość czasu potrzebnego na zarządzanie indeksami. Indeksy wymagane dla najbardziej podstawowych zapytań są tworzone automatycznie. Gdy używasz i testujesz aplikację, Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy wymagane przez aplikację.

Typy indeksów

Cloud Firestore wykorzystuje dwa typy indeksów: jednopolowe i złożone . Oprócz liczby indeksowanych pól indeksy jednopolowe i złożone różnią się sposobem zarządzania nimi.

Indeksy jednopolowe

Indeks jednopolowy przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji zawierających określone pole. Każdy wpis w indeksie jednopolowym rejestruje wartość dokumentu dla określonego pola i lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu podstawowych zapytań. Indeksami jednopolowymi zarządzasz, konfigurując ustawienia automatycznego indeksowania i wykluczenia indeksów w bazie danych.

Automatyczne indeksowanie

Domyślnie Cloud Firestore automatycznie utrzymuje indeksy pojedynczych pól dla każdego pola w dokumencie i każdego podpola na mapie. Cloud Firestore używa następujących ustawień domyślnych dla indeksów jednopolowych:

• Dla każdego pola innego niż tablica i mapa Cloud Firestore definiuje dwa indeksy jednopolowe o zakresie kolekcji , jeden w trybie rosnącym i jeden w trybie malejącym.

• Dla każdego pola mapy Cloud Firestore tworzy następujące elementy:

  • Jeden rosnący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
  • Jeden indeks malejący zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
  • Jedna tablica o zasięgu kolekcji zawiera indeks dla każdego podpola tablicy.
  • Cloud Firestore rekurencyjnie indeksuje każde podpole mapy.

• Dla każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks zawierający tablicę o zakresie kolekcji.

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

Wyłączenia indeksów jednopolowych

Możesz wyłączyć pole z ustawień automatycznego indeksowania , tworząc wykluczenie indeksu pojedynczego pola. Wyłączenie indeksowania zastępuje ustawienia automatycznego indeksowania obejmujące całą bazę danych. Wyjątek może włączyć indeks jednopolowy, który w przeciwnym razie ustawienia automatycznego indeksowania spowodowałby wyłączenie lub wyłączenie indeksu jednopolowego, który w przeciwnym razie umożliwiłby automatyczne indeksowanie. W przypadkach, w których wyjątki mogą być przydatne, zapoznaj się ze sprawdzonymi metodami indeksowania .

Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, podpola mapy odziedziczą te ustawienia. Można jednak zdefiniować wyłączenia indeksu pojedynczego pola dla określonych podpól. Jeśli usuniesz wykluczenie dla podpola, podpole odziedziczy ustawienia wykluczeń swojego rodzica, jeśli istnieją, lub ustawienia całej bazy danych, jeśli nie istnieją żadne wykluczenia nadrzędne.

Aby utworzyć i zarządzać wykluczeniami indeksów jednopolowych, zobacz Zarządzanie indeksami w Cloud Firestore .

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.

Cloud Firestore wykorzystuje indeksy złożone do obsługi zapytań, które nie są jeszcze obsługiwane przez indeksy jednopolowe.

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

Jeśli spróbujesz wykonać powyższe zapytanie bez uprzedniego utworzenia wymaganego indeksu, Cloud Firestore zwróci komunikat o błędzie zawierający link, za pomocą którego możesz utworzyć brakujący indeks. Dzieje się tak za każdym razem, gdy próbujesz wykonać zapytanie nieobsługiwane przez indeks. Można także definiować indeksy złożone i zarządzać nimi ręcznie, korzystając z konsoli lub interfejsu wiersza polecenia Firebase . Więcej informacji na temat tworzenia indeksów złożonych i zarządzania nimi można znaleźć w sekcji Zarządzanie indeksami .

Tryby indeksowania i zakresy zapytań

Konfigurujesz indeksy jednopolowe i indeksy złożone w różny sposób, ale oba wymagają skonfigurowania trybów indeksu i zakresów zapytań dla indeksów.

Tryby indeksowania

Definiując indeks, wybierasz tryb indeksowania dla każdego indeksowanego pola. Tryb indeksowania każdego pola obsługuje określone klauzule zapytania dotyczące tego pola. Można wybierać spośród następujących trybów indeksowania:

Zakresy zapytań

Każdy indeks ma zakres do kolekcji lub grupy kolekcji. Nazywa się to zakresem zapytania indeksu:

Zakres kolekcji

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

Zakres grupy kolekcji

Grupa kolekcji obejmuje wszystkie kolekcje o tym samym identyfikatorze kolekcji. Aby uruchomić zapytanie o grupę kolekcji , które zwróci przefiltrowane lub uporządkowane wyniki z grupy kolekcji, należy utworzyć odpowiedni indeks o zasięgu grupy kolekcji.

Domyślna kolejność i pole __name__

Oprócz sortowania dokumentów według trybów indeksu 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 zestawie wynikowym zawierające te same wartości pól są sortowane według ścieżki dokumentu.

Domyślnie pole __name__ jest sortowane w tym samym kierunku co ostatnio posortowane pole w definicji indeksu. Na przykład:

Aby posortować wyniki według innego niż domyślny kierunku __name__ , musisz utworzyć ten indeks.

Przykład indeksowania

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

Aby to zilustrować, przeanalizuj poniższe przykłady z punktu widzenia tworzenia indeksu. Poniższy fragment tworzy kilka dokumentów city w kolekcji cities i ustawia pola name , state , country , capital , population i tags 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

Zakładając domyślne ustawienia automatycznego indeksowania, Cloud Firestore aktualizuje jeden rosnący indeks jednopolowy na każde pole niebędące tablicą, jeden malejący indeks jednopolowy na każde pole niebędące tablicą i jeden indeks jednopolowy zawierający tablicę dla pola tablicowego. Każdy wiersz poniższej tabeli reprezentuje wpis w indeksie jednopolowym:

Zapytania obsługiwane przez indeksy jednopolowe

Korzystając z automatycznie tworzonych indeksów jednopolowych, możesz uruchamiać proste zapytania, takie jak poniższe:

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

Możesz także in i składać zapytania 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 zakresów ( < , <= , > lub >= ) lub jeśli chcesz sortować według innego pola, musisz utworzyć indeks złożony dla tego zapytania.

Indeks array-contains umożliwia odpytywanie 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 zapytań złożonych, które nie są jeszcze obsługiwane przez indeksy jednopolowe. Na przykład potrzebujesz indeksu złożonego dla następujących 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ą poniższego indeksu złożonego. Ponieważ zapytanie używa równości ( == lub in ) dla pola country , dla tego pola można zastosować rosnący lub malejący tryb indeksowania. Domyślnie w klauzulach nierówności stosuje się rosnący porządek sortowania w oparciu o pole w klauzuli nierówności.

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

Należy także utworzyć indeks złożony, aby 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, wyobraź sobie, że dodajesz 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 jednopolowego indeksu z zakresem zbioru, możesz przeszukiwać zbiór 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"])

Teraz wyobraź sobie, że chcesz wyszukać punkty orientacyjne we wszystkich miastach. Aby uruchomić to zapytanie na grupie kolekcji składającej się ze wszystkich kolekcji landmarks , musisz włączyć jednopolowy indeks landmarks o zakresie 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 o grupę kolekcji, które zwróci przefiltrowane lub uporządkowane wyniki, należy włączyć odpowiedni indeks jednopolowy lub złożony z zakresem grupy kolekcji. Zapytania o grupy kolekcji, które nie filtrują ani nie porządkują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.

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

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

Wpisy indeksu

Indeksy skonfigurowane w projekcie i struktura dokumentu określają liczbę wpisów indeksu w dokumencie. Wpisy indeksu wliczają się do limitu liczby wpisów indeksu .

Poniższy przykład ilustruje wpisy indeksu dokumentu.

Dokument

/cities/SF

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

Indeksy jednopolowe

• nazwa_miasta ASC
• nazwa_miasta DESC
• temperatury.lato ASC
• temperatury.lato DESC
• temperatury.zima ASC
• temperatury.zima DESC
• tablica dzielnic zawiera (ASC i DESC)

Indeksy złożone

• nazwa_miasta ASC, dzielnice ARRAY
• nazwa_miasta DESC, dzielnice ARRAY

Wpisy indeksu

Ta konfiguracja indeksowania skutkuje następującymi 18 wpisami indeksu dla dokumentu:

Indeksy i ceny

Indeksy przyczyniają się do kosztów przechowywania Twojej aplikacji. Więcej informacji na temat obliczania rozmiaru magazynu dla indeksów można znaleźć w artykule Rozmiar wpisu indeksu .

Korzystanie z łączenia indeksów

Chociaż Cloud Firestore używa indeksu dla każdego zapytania, niekoniecznie wymaga jednego indeksu na zapytanie. W przypadku zapytań z wieloma klauzulami równości ( == ) i opcjonalnie klauzulą orderBy , Cloud Firestore może ponownie wykorzystać istniejące indeksy. Cloud Firestore może łączyć indeksy dla prostych filtrów równości, aby zbudować indeksy złożone potrzebne do większych zapytań o równość.

Koszty indeksowania można obniżyć, identyfikując sytuacje, w których można skorzystać z łączenia indeksów. Wyobraźmy sobie na przykład kolekcję restaurants dla aplikacji do oceniania restauracji:

• collections_bookmark restauracje

  • class burger tymianek

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

Teraz wyobraź sobie, że ta aplikacja używa zapytań takich jak te poniżej. Zwróć uwagę, że aplikacja używa kombinacji klauzul równości dla category , city i editors_pick , zawsze sortując rosnąco 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, korzystając z możliwości Cloud Firestore łączenia indeksów w celu uzyskania klauzul równości:

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

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

Limity indeksowania

Poniższe ograniczenia dotyczą indeksów. Aby zapoznać się ze wszystkimi przydziałami i limitami, zobacz Przydziały i limity .

Najlepsze praktyki indeksowania

W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i łączach komunikatów o błędach do zarządzania indeksami. Można jednak dodać wyjątki jednopolowe w następujących przypadkach:

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