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, których używa 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 dla 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 pozwalają skrócić czas przeznaczają środki na zarządzanie indeksami. Indeksy wymagane do najbardziej podstawowych są tworzone automatycznie. Podczas testowania aplikacji Cloud Firestore pomaga identyfikować i utwórz dodatkowe indeksy wymagane przez aplikację.

Typy indeksów

Funkcja Cloud Firestore używa 2 typów indeksów: jednopola oraz kompozyt. 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 konkretnym polu i lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonania 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 pojedynczym 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ą lub mapą, Cloud Firestore określa 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.
    • Funkcja Cloud Firestore indeksuje rekurencyjnie 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.

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.

Cloud Firestore nie tworzy automatycznie indeksów złożonych podobnych do tego 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:

Tryb indeksu Opis
Rosnąco Obsługuje klauzule zapytań <, <=, ==, >=, >, !=, in i not-in w polu oraz obsługuje sortowanie wyników w kolejności rosnącej na podstawie tej wartości pola.
Malejąco Obsługuje klauzule zapytań <, <=, ==, >=, >, !=, in i not-in w polu oraz obsługuje sortowanie wyników w kolejności malejącej na podstawie tej wartości pola.
tablica-zawiera Obsługuje klauzule zapytania array-contains i array-contains-any w tym polu.
Wektor Obsługuje klauzule zapytania FindNearest w tym polu.

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:

Kolekcja Zindeksowane pola Zakres zapytania
miejscowości – imię i nazwisko, __name__ Kolekcja
miejscowości stan, __name__ Kolekcja
miejscowości kraj, populacja: , __name__ Kolekcja

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 dla 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 jednym 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:

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

Przy założeniu, że są to domyślne ustawienia automatycznego indeksowania, Cloud Firestore jest aktualizowany 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:

Kolekcja Zindeksowanie pola Zakres zapytania
miejscowości Nazwa magazynu danych Kolekcja
miejscowości stan Kolekcja
miejscowości kraj Kolekcja
miejscowości Stolica: Kolekcja
miejscowości populacja Kolekcja
miejscowości Nazwa magazynu danych Kolekcja
miejscowości stan Kolekcja
miejscowości kraj Kolekcja
miejscowości Stolica: Kolekcja
miejscowości populacja Kolekcja
miejscowości array-contains regionu Kolekcja

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:

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

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

Sieć
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:

Sieć
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

Funkcja 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ń:

Sieć
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 używa 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.

Kolekcja Zindeksowane pola Zakres zapytania
miejscowości Kraj: (lub ), populacja: Kolekcja

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:

Sieć
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")
Kolekcja Zindeksowane pola Zakres zapytania
miejscowości kraj, populacja: Kolekcja
miasta kraj, liczba ludności Kolekcja

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:

Sieć
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)
Kolekcja Zindeksowane pola Zakres zapytania
miejscowości Tagi array-contains, (lub ) wielka litera Kolekcja

Zapytania obsługiwane przez indeksy grup kolekcji

Aby zademonstrować indeks z zakresem grupy kolekcji, dodaj podkolekcja landmarks do niektórych z city dokumentów:

Sieć
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:

Kolekcja Zindeksowane pola Zakres zapytania
punkty orientacyjne Kategoria (lub ) Kolekcja
Sieć
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:

Kolekcja Zindeksowane pola Zakres zapytania
punkty orientacyjne Kategoria (lub ) Grupa kolekcji

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

Sieć
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:

Sieć
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:

Indeks Zindeksowane dane
Wpisy indeksu pojedynczego pola
nazwa_miasta AS City_name: "Warszawa"
nazwa_miasta DESC City_name: "Warszawa"
temperatury.letnie ASC temperatura.lato: 67
temperatury.lato DESC temperatura.lato: 67
temperatury.zima ASC temperatury.zima: 55
temperatury.zima DESC temperatury.zima: 55
Tablica dzielnic zawiera ASC dzielnice: „Misja”
Dzielnice: Tablica zawiera DESC dzielnice: „Misja”
Tablica dzielnic zawiera ASC dzielnice: „centrum”
Dzielnice: Tablica zawiera DESC dzielnice: „centrum”
Tablica dzielnic zawiera ASC dzielnice: „Marina”
Dzielnice: Tablica zawiera DESC dzielnice: „Marina”
Wpisy indeksu złożonego
nazwa_miasta ASC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "Misja"
nazwa_miasta ASC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "centrum"
nazwa_miasta ASC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "Marina"
nazwa_miasta DESC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "Misja"
nazwa_miasta DESC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "centrum"
nazwa_miasta DESC, dzielnice ARRAY City_name: "Warszawa", dzielnice: "Marina"

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ą (==) i opcjonalnie klauzulę orderBy, Cloud Firestore może pozwalają na ponowne wykorzystanie istniejących indeksów. Cloud Firestore może scalić 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:

  • restauracji

    • Burgerthyme:

      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:

Sieć
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:

Kolekcja Zindeksowane pola Zakres zapytania
restauracje Kategoria: , liczba gwiazdek: Kolekcja
restauracje miasto, gwiazdki Kolekcja
restauracje Kategoria: , miasto: , liczba gwiazdek: Kolekcja
restauracje Kategoria: , miasto, editor_pick, star_rating Kolekcja

Lepszym rozwiązaniem jest zmniejszenie liczby indeksów dzięki możliwości scalania w usłudze Cloud Firestore indeksy klauzul równości:

Kolekcja Zindeksowane pola Zakres zapytania
restauracje Kategoria: , liczba gwiazdek: Kolekcja
restauracje miasto, gwiazdki Kolekcja
restauracje redaktor_pick, star_rating Kolekcja

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

Sieć
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.

Limit Szczegóły
Maksymalna liczba indeksów złożonych dla bazy danych
Maksymalna liczba konfiguracji z jednym polem dla bazy danych

Konfiguracja na poziomie 1 pola może zawierać wiele konfiguracji tego samego pola. Przykład: wykluczenie z indeksowania pojedynczego pola i zasada TTL dla tego samego pola; są uwzględniane jako konfiguracja jednego pola w ramach limitu.

Maksymalna liczba wpisów w indeksie dla każdego dokumentu

40 000

Liczba wpisów w indeksie to suma następujących wartości dokumentu:

  • Liczba wpisów indeksu z jednym polem
  • Liczba wpisów indeksu złożonego

Aby zobaczyć, jak Cloud Firestore zmienia dokument i zbiór elementów indeksy we wpisach indeksu, zobacz tym przykładem liczby wpisów w indeksie.

Maksymalna liczba pól w indeksie złożonym 100
Maksymalny rozmiar wpisu w indeksie

7,5 KiB

Aby dowiedzieć się, jak Cloud Firestore oblicza rozmiar wpisu w indeksie, zobacz rozmiar wpisu indeksu.

Maksymalna suma rozmiarów wpisów w indeksie dokumentu

8 MiB

Łączny rozmiar dokumentu to suma następujących elementów:

  • Suma rozmiaru wpisów indeksu z jednym polem w dokumencie
  • Suma rozmiaru wpisów indeksu złożonego dokumentu
  • Maksymalny rozmiar wartości zindeksowanego pola

    1500 bajtów

    Wartości pól większe niż 1500 bajtów są obcinane. Zapytania obejmujące przycięte wartości pól mogą zwracać niespójne wyniki.

    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:

    Zgłoszenie Opis
    Duże pola ciągów

    Jeśli masz pole z ciągami znaków, które często zawierają wartości długich ciągów, nie używasz do wysyłania zapytań, możesz obniżyć koszty przechowywania, wykluczając to pole przed indeksowaniem.

    Duża szybkość zapisu w kolekcji zawierającej dokumenty z wartościami sekwencyjnymi

    Jeśli indeksujesz pole, które rośnie lub maleje kolejno między dokumentów w kolekcji, takich jak sygnatura czasowa, a potem maksymalna szybkość zapisu to 500 zapisów na sekundę. Jeśli nie wysyłasz zapytania na podstawie pola z wartościami sekwencyjnymi, możesz je wykluczyć przed indeksowaniem, aby ominąć ten limit.

    Na przykład w przypadku użycia IoT z dużą częstotliwością zapisu kolekcja zawierająca dokumenty z polem sygnatury czasowej może zbliżyć się do limitu 500 zapisów na sekundę.

    Pola TTL

    Jeśli używasz zasad (TTL), pamiętaj, że wartość TTL musi zawierać sygnaturę czasową. Indeksowanie po polach TTL jest domyślnie włączone i może które wpływają na skuteczność kampanii. Zalecamy dodanie wykluczenia pojedynczego pola dla pól TTL.

    Duże pola tablicowe lub mapowania

    Duże pola tablic lub mapy mogą zbliżać się do limitu 40 000 wpisów indeksu na dokument. Jeśli nie wysyłasz zapytań na podstawie dużej tablicy lub pola mapy, wyklucz je z indeksowania.

    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 Cloud Firestore zapytań

    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.