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:
- Identyfikuje indeks odpowiadający zbieraniu danych zapytania, właściwościom filtrów, operatorom filtrów i kolejnościom sortowania.
- 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. - 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:
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: |
| 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.