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 za każdym zapytaniem

Jeśli dla zapytania nie istnieje żaden indeks, większość baz danych przeszukuje ich zawartość element po elemencie, co jest powolnym procesem, który spowalnia jeszcze bardziej w miarę rozrastania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki zastosowaniu indeksów dla wszystkich zapytań. W rezultacie wydajność zapytania 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 skracają czas potrzebny na zarządzanie indeksami. Indeksy wymagane dla najbardziej podstawowych zapytań są tworzone automatycznie. Podczas używania i testowania aplikacji Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy wymagane przez aplikację.

Typy indeksów

Cloud Firestore wykorzystuje dwa rodzaje 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, które zawierają określone pole. Każdy wpis w indeksie jednopolowym rejestruje wartość dokumentu dla określonego pola oraz lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu podstawowych zapytań. Indeksami jednopolowymi zarządza się, konfigurując ustawienia automatycznego indeksowania bazy danych i wykluczenia indeksów.

Automatyczne indeksowanie

Domyślnie Cloud Firestore automatycznie przechowuje indeksy pojedynczych pól dla każdego pola w dokumencie i każdego pola podrzędnego 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:

  • Jeden rosnący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
  • Jeden malejący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i nie będącego mapą.
  • Jeden indeks zawierający tablicę o zakresie kolekcji 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 zasięgu kolekcji.

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

Wyjątki z indeksu pojedynczego pola

Możesz wyłączyć pole z ustawień automatycznego indeksowania , tworząc wykluczenie indeksu pojedynczego pola. Wyjątek indeksowania zastępuje ustawienia automatycznego indeksowania całej bazy danych. Wyjątek może włączyć indeks z jednym polem, który w przeciwnym razie zostałby wyłączony przez ustawienia automatycznego indeksowania, lub wyłączyć indeks z jednym polem, który w przeciwnym razie byłby włączony przez automatyczne indeksowanie. W przypadkach, w których wyłączenia mogą być przydatne, zapoznaj się ze sprawdzonymi metodami indeksowania .

Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, pola podrzędne mapy odziedziczą te ustawienia. Można jednak zdefiniować wykluczenia indeksu pojedynczego pola dla określonych pól podrzędnych. Jeśli usuniesz wykluczenie dla pola podrzędnego, pole podrzędne odziedziczy ustawienia wykluczeń swojego elementu nadrzędnego, jeśli takie istnieją, lub ustawienia całej bazy danych, jeśli nie istnieją żadne wykluczenia nadrzędne.

Aby utworzyć wykluczenia indeksów pojedynczych pól i zarządzać nimi, zobacz Zarządzanie indeksami w Cloud Firestore .

Indeksy złożone

Indeks złożony przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji, w oparciu o uporządkowaną listę pól do indeksowania.

Cloud Firestore używa indeksów złożonych 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 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, który możesz kliknąć, aby utworzyć brakujący indeks. Dzieje się tak za każdym razem, gdy próbujesz wykonać zapytanie nieobsługiwane przez indeks. Indeksy złożone można również definiować i zarządzać nimi ręcznie za pomocą konsoli lub interfejsu wiersza polecenia Firebase . Aby uzyskać więcej informacji na temat tworzenia indeksów złożonych i zarządzania nimi, zobacz Zarządzanie indeksami .

Tryby indeksowania i zakresy zapytań

Inaczej konfiguruje się indeksy jednopolowe i złożone, ale oba wymagają skonfigurowania trybów indeksowania i zakresów zapytań dla indeksów.

Tryby indeksu

Podczas definiowania indeksu wybiera się tryb indeksowania dla każdego indeksowanego pola. Tryb indeksowania każdego pola obsługuje określone klauzule zapytania dotyczące tego pola. Możesz wybrać jeden z następujących trybów indeksowania:

Zakresy zapytań

Zakres każdego indeksu obejmuje kolekcję lub grupę kolekcji. Jest to znane jako 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 z tym samym identyfikatorem kolekcji. Aby uruchomić zapytanie dotyczące grupy kolekcji , które zwraca przefiltrowane lub uporządkowane wyniki z grupy kolekcji, należy utworzyć odpowiedni indeks z zakresem grupy kolekcji.

Kolejność domyślna 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ą końcowe 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 ostatnio posortowane pole w definicji indeksu. Na przykład:

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

Przykład indeksowania

Dzięki automatycznemu tworzeniu jednopolowych indeksów, Cloud Firestore umożliwia Twojej 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ą 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 kodu 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 pojedynczego pola na pole inne niż tablica, jeden malejący indeks pojedynczego pola na pole inne niż tablica i jeden indeks pojedynczego pola zawierający tablicę dla pola tablicy. Każdy wiersz w poniższej tabeli reprezentuje wpis w indeksie jednopolowym:

Zapytania obsługiwane przez indeksy jednopolowe

Korzystając z tych 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 tworzyć zapytania in i złożone ( == ):

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 musisz uruchomić zapytanie złożone, które używa porównania zakresów ( < , <= , > lub >= ) lub jeśli chcesz posortować według innego pola, musisz utworzyć indeks złożony dla tego zapytania.

Indeks array-contains umożliwia zapytanie 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 złożone indeksy

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 potrzebny byłby indeks złożony 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 , możesz użyć trybu indeksu rosnącego lub malejącego dla tego pola. Domyślnie klauzule nierówności stosują rosnący porządek sortowania na podstawie pola w klauzuli nierówności.

Aby uruchomić te same zapytania, ale z malejącym porządkiem 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 również 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 do niektórych dokumentów city dodajesz podzbiór landmarks :

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 następującego jednopolowego indeksu z zakresem kolekcji, możesz wyszukiwać kolekcję 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 zapytać o punkty orientacyjne we wszystkich miastach. Aby uruchomić to zapytanie w grupie kolekcji składającej się ze wszystkich kolekcji landmarks , należy 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 dotyczące grupy kolekcji, które zwraca przefiltrowane lub uporządkowane wyniki, należy włączyć odpowiedni indeks jednopolowy lub złożony z zakresem grupy kolekcji. Zapytania grup kolekcji, które nie filtrują ani nie porządkują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.

Na przykład można uruchomić następujące zapytanie o grupę kolekcji bez włączania dodatkowego indeksu:

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

Wpisy indeksu

Skonfigurowane indeksy projektu i struktura dokumentu określają liczbę wpisów indeksu dla dokumentu. Wpisy indeksu wliczają się do limitu 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
• sąsiedztwa tablica zawiera (ASC i DESC)

Indeksy złożone

• nazwa_miasta ASC, dzielnice TABLICA
• nazwa_miasta DESC, dzielnice TABLICA

Wpisy indeksu

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

Indeksy i ceny

Indeksy przyczyniają się do kosztów przechowywania aplikacji. Aby uzyskać więcej informacji na temat obliczania rozmiaru magazynu dla indeksów, zobacz Rozmiar wpisu indeksu .

Wykorzystanie łą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 z 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 tworzyć złożone indeksy potrzebne do większych zapytań równości.

Koszty indeksowania można obniżyć, identyfikując sytuacje, w których można skorzystać z połączenia indeksów. Na przykład wyobraź sobie kolekcję restaurants dla aplikacji oceniającej restauracje:

• collections_bookmark restauracje

  • tymianek class

    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. Zauważ, że aplikacja używa kombinacji klauzul równości dla category , city i editors_pick zawsze sortując według rosnącej 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 poprzez wykorzystanie możliwości Cloud Firestore do łączenia indeksów dla klauzul równości:

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

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

Limity indeksowania

Do indeksów mają zastosowanie następujące ograniczenia. Aby zapoznać się ze wszystkimi przydziałami i limitami, zobacz Przydziały i limity .

Indeksowanie najlepszych praktyk

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

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