Typy indeksów w Cloud Firestore

Indeksy są ważnym czynnikiem wydajności bazy danych. Podobnie jak w przypadku 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 bazy danych, może ona korzystać z indeksu do szybkiej identyfikacji żądane elementy.

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

Definicja i struktura indeksu

Indeks jest zdefiniowany na liście pól danego dokumentu, przy czym odpowiedni tryb indeksowania dla każdego pola.

Indeks zawiera wpis dotyczący każdego pola nazwanego w definicji indeksu. indeksu obejmuje wszystkie dokumenty, które są potencjalnymi wynikami dla zapytań na podstawie indeksu. Dokument jest uwzględniany w indeksie tylko wtedy, gdy ma zindeksowaną wartość ustawiany dla każdego pola używanego w indeksie. Jeśli definicja indeksu odnosi się do pola dla których dokument nie ma ustawionej wartości, 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 funkcji definicji indeksu.

Indeks za każdym zapytaniem

Jeśli dla zapytania nie ma indeksu, większość baz danych indeksuje za pomocą elementu zawartości według elementów, jest to powolny proces, który spowalnia pracę jeszcze bardziej w miarę rozrastania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki użyciu indeksów wszystkich zapytań. W efekcie wydajność zapytań zależy od rozmiaru zbioru wyników, a nie liczby elementów w bazie danych.

Mniej zarządzania indeksami, więcej możliwości tworzenia aplikacji

Cloud Firestore obejmuje funkcje, które ograniczają ilość czasu przeznaczają środki na zarządzanie indeksami. Indeksy wymagane do najbardziej podstawowych są tworzone automatycznie. Podczas testowania aplikacji Cloud Firestore pomaga identyfikować utworzyć dodatkowe indeksy wymagane przez aplikację.

Typy indeksów

Cloud Firestore używa 2 typów indeksów: pojedynczego pola oraz kompozytem. Oprócz liczby zindeksowanych pól, indeksami złożonymi różnią się sposobem zarządzania nimi.

Indeksy z jednym polem

Indeks z pojedynczym polem przechowuje posortowane mapowanie wszystkich dokumentów w które zawierają określone pole. Każda pozycja w indeksie pojedynczego pola rejestruje wartość dokumentu w określonym polu i lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu podstawowych zapytań. Zarządzasz indeksami z pojedynczym polem, konfigurując ustawienia automatycznego indeksowania i wykluczenia z indeksu.

Automatyczne indeksowanie

Domyślnie Cloud Firestore automatycznie przechowuje indeksy z jednym polem dla każdego pola w dokumencie i dla każdego pola podrzędnego na mapie. Cloud Firestore korzysta z tych domyślnych ustawień indeksów z pojedynczym polem:

• Dla każdego pola, które nie jest tablicą i nie jest mapą, Cloud Firestore definiuje 2 pola indeksy z jednym polem collection-scope, jeden w trybie rosnącym a druga w trybie malejącym.

• Dla każdego pola mapy Cloud Firestore tworzy te elementy:

  • 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 malejący o zakresie na poziomie zbioru dla każdego pola podrzędnego innego niż pole tablicy lub pola podrzędnego.
  • Jeden indeks tablicy-contains w zakresie kolekcji dla każdego pola podrzędnego tablicy.
  • Cloud Firestore indeksuje rekursywnie każde podpole mapy.

• Dla każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks tablicy-contains w zakresie kolekcji.

• Indeksy z jednym polem z zakresem grupy kolekcji nie są obsługiwane przez wartość domyślną.

Wykluczenie indeksu pojedynczego pola

Możesz wykluczyć pole z automatycznego indeksowania przez utworzenie wykluczenia indeksu pojedynczego pola. Wykluczenie z indeksowania zastępuje ustawienia automatycznego indeksu dotyczące całej bazy danych. An wykluczenie może włączyć indeks pojedynczego pola, który Twoje ustawienia automatycznego indeksowania w innym przypadku wyłącza lub wyłącza indeks pojedynczego pola, który jest używany automatycznie w innych przypadkach. Przykłady zastosowania wyjątków znajdziesz tutaj: sprawdzonych metodach dotyczących indeksowania.

Użyj wartości ścieżki pola *, aby dodać wykluczenia indeksu na poziomie kolekcji do wszystkich pól w grupie kolekcji. Na przykład w przypadku grupy kolekcji comments ustaw wartość ścieżkę pola do *, aby dopasować wszystkie pola w grupie kolekcji comments oraz wyłączyć indeksowanie wszystkich pól w grupie kolekcji. Następnie możesz dodać wykluczenia pozwalające na indeksowanie tylko pól wymaganych na potrzeby zapytań. Zmniejszanie liczba zindeksowanych pól zmniejsza koszty przechowywania i może poprawić zapis skuteczność reklam.

Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, definicja mapy pola podrzędne dziedziczą te ustawienia. Możesz jednak zdefiniować indeks pojedynczego pola dla określonych pól podrzędnych. Jeśli usuniesz wykluczenie dla pola podrzędnego, pole podrzędne odziedziczy ustawienia wykluczenia z elementu nadrzędnego (jeśli istnieją) lub ustawień całej bazy danych, jeśli nie istnieją wykluczenia nadrzędne.

Aby utworzyć wykluczenia indeksu pojedynczego pola i nimi zarządzać, zapoznaj się z artykułem 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.

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.

Cloud Firestore nie tworzy automatycznie indeksów złożonych, takich jak ten dla indeksów z jednym polem ze względu na dużą liczbę możliwych pól kombinacji. Zamiast tego Cloud Firestore pomaga identyfikować i tworzyć wymagane indeksy złożone podczas tworzenia aplikacji.

Za każdym razem, gdy spróbujesz wykonać zapytanie, które nie jest obsługiwane przez indeks, Cloud Firestore zwraca komunikat o błędzie z linkiem, którego można użyć do utworzenia brakującego elementu. indeksu.

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

Tryby indeksowania i zakresy zapytań

Indeksy z jednym polem i złożonymi konfigurujesz inaczej, ale oba wymagają skonfigurować tryby indeksów i zakresy zapytań dla indeksów.

Tryby indeksowania

Podczas definiowania indeksu wybierasz tryb indeksowania dla każdego zindeksowanego pola. Każdy tryb indeksu pola obsługuje określone klauzule zapytania w tym polu. Ty dostępne są te tryby indeksowania:

Zakresy zapytań

Każdy indeks jest ograniczony do kolekcji lub grupy kolekcji. To jest 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 1 kolekcji.

Zakres grupy kolekcji

Grupa kolekcji zawiera wszystkie kolekcje z tym samym identyfikatorem. Do uruchomić zapytanie dotyczące grupy kolekcji, które zwróci przefiltrowane lub uporządkowanych wyników z grupy kolekcji, musisz utworzyć indeksu z zakresem grupy kolekcji.

Domyślna kolejność 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ńcowy posortowanie według pola __name__ każdego dokumentu. Wartość atrybutu __name__ jest ustawiona na pełną ścieżkę dokumentu. Oznacza to, że dokumenty w zestawie 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 innego kierunku (__name__), musisz: utworzyć indeks.

Właściwości indeksu

Indeks, który umożliwia najefektywniejsze wykonywanie 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 zostały jeszcze uwzględnione w kolejności 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. Identyfikuje indeks odpowiadający zbieraniu danych zapytania, właściwościom filtrów, operatorom filtrów i kolejnościom sortowania.
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.
   • Osiąga koniec indeksu.
   • Zbiera maksymalną liczbę wyników żądanych przez zapytanie.

Przykład indeksowania

Dzięki automatycznemu tworzeniu indeksów z pojedynczym polem, Cloud Firestore umożliwia aplikacji szybką obsługę najbardziej podstawowych zapytań do bazy danych. Indeksy z jednym polem umożliwiają wykonywanie prostych zapytań na podstawie wartości pól oraz komparatory <, <=, ==, >=, > i in. W przypadku pól tablicy pozwalają one ma wykonać zapytania array-contains i array-contains-any.

Aby to zilustrować, przyjrzyjmy się poniższym przykładom z perspektywy tworzenia indeksu. Ten fragment kodu tworzy kilka dokumentów typu city w kolekcji cities i zestawy name, state, Pola country, capital, population i tags w przypadku 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 założeniu, że są to domyślne ustawienia automatycznego indeksowania, Cloud Firestore aktualizuje się jeden rosnący indeks pojedynczego pola na pole niebędące tablicą, jedno malejące indeks pola na pole niebędące tablicą oraz jeden indeks jednego pola zawierający tablicę dla polu tablicy. Każdy wiersz w poniższej tabeli odpowiada wpisowi w indeks pojedynczego pola:

Zapytania obsługiwane przez indeksy z jednym polem

Przy użyciu tych automatycznie tworzonych indeksów pojedynczych pól możesz uruchamiać proste zapytania podobne do tych:

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 (==):

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 wykorzystujące porównanie zakresów (<, <=, > lub >=), a jeśli chcesz posortować dane według innego pola, musisz utworzyć indeksu złożonego dla tego zapytania.

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 zapytań złożonych, które nie są jeszcze obsługiwane przez indeksy z pojedynczym polem. Na przykład: potrzebny jest indeks złożony dla 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ą podanego niżej indeksu złożonego. Ponieważ zapytanie korzysta równości (== lub in) w polu country, możesz użyć trybu indeksowania 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ącą kolejnością sortowania, 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 skuteczności spowodowanej przez scalanie indeksu, zalecamy utworzenie indeks złożony do 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 grupy kolekcji, dodaj podkolekcja landmarks do niektórych z city dokumentów:

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

Za pomocą poniższego indeksu pojedynczego pola z zakresem kolekcji możesz wykonywać zapytania kolekcja landmarks dla 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 chcesz na przykład wysyłać zapytania o punkty orientacyjne we wszystkich miastach, uruchomisz to zapytanie w grupie kolekcji, która składa się ze wszystkich elementów landmarks kolekcji. Musisz też włączyć indeks pojedynczego pola landmarks z zakres 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ądkowanych wyników, musisz włączyć odpowiedni indeksu z zakresem grupy kolekcji. Zapytania dotyczące grup kolekcji, które nie są filtrowane nie wymagają jednak żadnych dodatkowych definicji indeksów.

Możesz na przykład wykonać to zapytanie dotyczące grupy kolekcji bez włączania dodatkowy indeks:

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

Wpisy indeksu

Skonfigurowane indeksy projektu i struktura dokumentu określają liczbę wpisów w indeksie dla dokumentu. Wpisy indeksu są wliczane do limit liczby wpisów w indeksie.

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 jednopolowe

• nazwa_miasta AS
• nazwa_miasta DESC
• temperatury.letnie ASC
• temperatury.lato DESC
• temperatury.zima ASC
• temperatury.zima DESC
• Dzielnice tablica zawiera (ASC i DESC)

Indeksy złożone

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

Wpisy indeksu

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

Indeksy i ceny

Indeksy są uwzględniane w kosztach miejsca na dane aplikacji. Więcej informacji o sposobie obliczania rozmiaru miejsca na dane dla indeksów znajdziesz w artykule Rozmiar wpisu indeksu.

Użyj scalania indeksu

Chociaż Cloud Firestore używa indeksu dla każdego zapytania, nie wymaga 1 indeksu na zapytanie. W przypadku zapytań z wieloma równością (==) oraz opcjonalnie klauzulę orderBy, Cloud Firestore może pozwalają na ponowne wykorzystanie istniejących indeksów. Cloud Firestore może scalać indeksy w prosty sposób filtry równości do tworzenia indeksów złożonych potrzebnych do uzyskania większej równości zapytań.

Koszty indeksowania można zmniejszyć, identyfikując sytuacje, w których można scalanie. 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ń podobnych do podanych poniżej. Aplikacja używa kombinacji równości klauzule category, city i editors_pick z zawsze sortowanym według 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 z wykorzystaniem możliwości scalania w Cloud Firestore. indeksy 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.

Sprawdzone metody indeksowania

W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu, a komunikaty o błędach będą prowadzić do i zarządzać indeksami. Możesz jednak dodać wykluczenia jednego pola w w następujących przypadkach:

Jeśli używasz zapytań z operatorami zakresu i nierówności w wielu polach, zapoznaj się z sekcją o indeksowaniu które warto rozważyć, wydajność i koszt zapytań do 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.