Indeksy są ważnym czynnikiem wpływającym na wydajność bazy danych. Podobnie jak indeks książki, który przypisuje tematy do numerów stron, indeks bazy danych przypisuje elementy w bazie danych do ich lokalizacji w bazie danych. Gdy wysyłasz zapytanie do bazy danych, może ona użyć indeksu, aby szybko zidentyfikować lokalizacje żądanych elementów.
Na tej stronie opisujemy 2 rodzaje indeksów używanych przez Cloud Firestore: indeksy jednopola i indeksy złożone.
Definicja i struktura indeksu
Indeks jest zdefiniowany na liście pól danego dokumentu, a każde pole ma odpowiedni tryb indeksowania.
Indeks zawiera wpis dla każdego pola wymienionego w definicji indeksu. Indeks zawiera wszystkie dokumenty, które mogą być wynikami zapytań opartych na tym indeksie. Dokument jest uwzględniany w indeksie tylko wtedy, gdy ma ustawioną wartość indeksowaną dla każdego pola użytego w indeksie. Jeśli definicja indeksu odwołuje się do pola, dla którego dokument nie ma ustawionej wartości, dokument nie pojawi się w indeksie. W takim przypadku dokument nigdy nie będzie zwracany jako wynik żadnego zapytania opartego na indeksie.
Indeks złożony jest sortowany według wartości pól w kolejności określonej w definicji indeksu.
Indeks za każdym zapytaniem
Jeśli dla zapytania nie ma indeksu, większość baz danych przeszukuje zawartość element po elemencie, co jest powolnym procesem, który staje się jeszcze wolniejszy w miarę powiększania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań, ponieważ w każdym zapytaniu używa indeksów. W efekcie wydajność zapytań zależy od rozmiaru zbioru wyników, a nie od liczby elementów w bazie danych.
Mniej zarządzania indeksem, więcej tworzenia aplikacji
Cloud Firestore zawiera funkcje, które skracają czas potrzebny na zarządzanie indeksem. Indeksy wymagane w przypadku najbardziej podstawowych zapytań są tworzone automatycznie. Podczas korzystania z aplikacji i jej testowania usługa Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy, których wymaga aplikacja.
Typy indeksów
Cloud Firestore używa 2 rodzajów indeksów: indeksów pojedynczych pól i złożonych. Oprócz liczby indeksowanych pól indeksy pojedynczego pola i indeksy złożone różnią się sposobem zarządzania nimi.
Indeksy pojedynczego pola
Indeks pojedynczego pola przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji, które zawierają określone pole. Każdy wpis w indeksie z 1 polem 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ń. Indeksami pojedynczego pola zarządzasz, konfigurując automatyczne ustawienia indeksowania bazy danych i wykluczenia indeksu.
Automatyczne indeksowanie
Domyślnie Cloud Firestore automatycznie utrzymuje indeksy pojedynczych pól dla każdego pola w dokumencie i każdego pola podrzędnego w mapie. Cloud Firestore używa tych ustawień domyślnych w przypadku indeksów jednopola:
Dla każdego pola, które nie jest tablicą ani mapą, Cloud Firestore definiuje 2 indeksy pojedynczego pola w zakresie kolekcji: jeden w trybie rosnącym i jeden w trybie malejącym.
W przypadku każdego pola mapy funkcja Cloud Firestore tworzy:
- Po jednym indeksie rosnącym o zakresie kolekcji dla każdego pola podrzędnego, które nie jest tablicą ani mapą.
- Jeden indeks malejący o zakresie kolekcji dla każdego pola podrzędnego, które nie jest tablicą ani mapą.
- Po jednym indeksie array-contains o zakresie kolekcji dla każdego pola podrzędnego tablicy.
- Cloud Firestore rekursywnie indeksuje każde pole podrzędne mapy.
Dla każdego pola tablicy w dokumencie usługa Cloud Firestore tworzy i utrzymuje indeks array-contains w zakresie kolekcji.
Indeksy pojedynczego pola o zakresie grupy kolekcji nie są domyślnie utrzymywane.
Wykluczenie indeksu pojedynczego pola
Możesz wykluczyć pole z ustawień automatycznego indeksowania, tworząc wykluczenie indeksu pojedynczego pola. Wykluczenie z indeksowania zastępuje ustawienia automatycznego indeksu dotyczące całej bazy danych. Wykluczenie może włączyć indeks pojedynczego pola, który w innym przypadku zostałby wyłączony przez ustawienia automatycznego indeksowania, lub wyłączyć indeks pojedynczego pola, który w innym przypadku zostałby włączony przez ustawienia automatycznego indeksowania. W przypadku, gdy wyłączenia mogą być przydatne, zapoznaj się ze sprawdzonymi metodami indeksowania.
Użyj wartości ścieżki pola *, aby dodać wyłączenia indeksu na poziomie kolekcji we wszystkich polach w grupie kolekcji. Na przykład w przypadku grupy kolekcji comments ustaw ścieżkę pola na *, aby dopasować wszystkie pola w grupie kolekcji comments, i wyłącz indeksowanie wszystkich pól w tej grupie. Następnie możesz dodać wykluczenia, aby indeksować tylko pola wymagane w zapytaniach. Zmniejszenie liczby indeksowanych pól obniża koszty przechowywania i może zwiększyć wydajność zapisu.
Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, pola podrzędne mapy odziedziczą te ustawienia. Możesz jednak zdefiniować wykluczenia indeksu pojedynczego pola dla konkretnych pól podrzędnych. Jeśli usuniesz wykluczenie dla pola podrzędnego, odziedziczy ono ustawienia wykluczenia pola nadrzędnego, jeśli takie istnieją, lub ustawienia obowiązujące w całej bazie danych, jeśli nie ma wykluczeń dla pola nadrzędnego.
Informacje o tworzeniu wykluczeń indeksów pojedynczego pola i zarządzaniu nimi znajdziesz w artykule Zarządzanie indeksami.
Indeksy złożone
W indeksie złożonym przechowywane jest posortowane mapowanie wszystkich dokumentów w kolekcji na podstawie uporządkowanej listy pól do zindeksowania.
Cloud Firestore używa indeksów złożonych do obsługi zapytań, których nie obsługują indeksy pojedynczych pól.
Cloud Firestore nie tworzy automatycznie indeksów złożonych, tak jak w przypadku indeksów pojedynczych pól, 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.
Za każdym razem, gdy spróbujesz wykonać zapytanie, które nie jest obsługiwane przez indeks, Cloud Firestorezwróci komunikat o błędzie z linkiem, który możesz kliknąć, aby utworzyć brakujący indeks.
Możesz też ręcznie definiować indeksy złożone i nimi zarządzać za pomocą konsoli lub interfejsu wiersza poleceń Firebase. Więcej informacji o tworzeniu indeksów złożonych i zarządzaniu nimi znajdziesz w artykule Zarządzanie indeksami.
Tryby indeksowania i zakresy zapytań
Indeksy pojedynczego pola i złożone konfiguruje się inaczej, ale w obu przypadkach musisz skonfigurować tryby indeksowania i zakresy zapytań dla indeksów.
Tryby indeksowania
Podczas definiowania indeksu wybierasz tryb indeksowania dla każdego indeksowanego pola. Każdy tryb indeksu pola obsługuje określone klauzule zapytania w tym polu. Możesz wybrać jeden z tych trybów indeksowania:
| Tryb indeksowania | Opis |
|---|---|
| Rosnąco | Obsługuje klauzule zapytań <, <=, ==, >=, >, !=, in i not-in w polu oraz sortowanie wyników w kolejności rosnącej na podstawie wartości tego pola. |
| Malejąco | Obsługuje klauzule zapytań <, <=, ==, >=, >, !=, in i not-in w polu oraz sortowanie wyników w kolejności malejącej na podstawie wartości tego pola. |
| Array‑contains | Obsługuje klauzule zapytań array-contains i array-contains-any w polu. |
| Vector | Obsługuje klauzule zapytania FindNearest w polu. |
Zakresy zapytań
Każdy indeks jest ograniczony do kolekcji lub grupy kolekcji. Jest to tzw. 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 o tym samym identyfikatorze. Aby uruchomić zapytanie dotyczące grupy kolekcji, które zwraca przefiltrowane lub uporządkowane wyniki z grupy kolekcji, musisz utworzyć odpowiedni indeks z zakresem grupy kolekcji.
Domyślne sortowanie 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 zbiorze wyników o tych samych wartościach 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 w kierunku __name__ innym niż domyślny, musisz utworzyć ten indeks.
Właściwości indeksu
Indeks, który umożliwia najwydajniejsze wykonywanie zapytania, jest określany 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 są jeszcze uwzględnione w kolejności sortowania)
- Pola używane w agregacjach (które nie są jeszcze uwzględnione w kolejnościach sortowania oraz filtrach zakresu i nierówności)
Cloud Firestore oblicza wyniki zapytań w ten sposób:
- Określa indeks odpowiadający kolekcji, właściwościom filtra, operatorom filtra i kolejnościom sortowania zapytania.
- Określa pozycję indeksu, od której rozpoczyna się skanowanie. Pozycja początkowa jest poprzedzona filtrami równości zapytania i kończy się filtrami zakresu i nierówności w pierwszym polu
orderBy. - Rozpoczyna skanowanie indeksu, zwracając każdy dokument, który spełnia wszystkie filtry, dopóki proces skanowania nie wykona jednej z tych czynności:
- Wykrywa dokument, który nie spełnia warunków filtra, i potwierdza, że żaden kolejny dokument nigdy nie będzie w pełni spełniać warunków filtra.
- dojdzie do końca indeksu.
- Zbiera maksymalną liczbę wyników żądanych przez zapytanie.
Przykład indeksowania
Automatyczne tworzenie indeksów pojedynczych pól przez Cloud Firestore umożliwia aplikacji szybkie obsługiwanie najbardziej podstawowych zapytań do bazy danych.
Indeksy pojedynczych pól umożliwiają wykonywanie prostych zapytań na podstawie wartości pól i operatorów porównania <, <=, ==, >=, > i in. W przypadku pól tablicowych umożliwiają wykonywanie zapytań array-contains i array-contains-any.
Aby to zilustrować, przyjrzyj się poniższym przykładom z punktu widzenia tworzenia indeksu. Ten fragment kodu tworzy kilka dokumentów city w kolekcji cities i ustawia pola name, state, country, capital, population i tags dla 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 domyślnych ustawień automatycznego indeksowania funkcja Cloud Firestore aktualizuje 1 rosnący indeks pojedynczego pola na każde pole niebędące tablicą, 1 malejący indeks pojedynczego pola na każde pole niebędące tablicą i 1 indeks pojedynczego pola array-contains na pole tablicy. Każdy wiersz w tabeli poniżej reprezentuje wpis w indeksie z 1 polem:
| Kolekcja | Zindeksowane pole | Zakres zapytania |
|---|---|---|
| miejscowości | Nazwa magazynu danych | Kolekcja |
| miejscowości | stan | Kolekcja |
| miejscowości | kraj | Kolekcja |
| miejscowości | kapitał | Kolekcja |
| miejscowości | populacja | Kolekcja |
| miejscowości | Nazwa magazynu danych | Kolekcja |
| miejscowości | stan | Kolekcja |
| miejscowości | kraj | Kolekcja |
| miejscowości | kapitał | Kolekcja |
| miejscowości | populacja | Kolekcja |
| miejscowości | array-contains regionu |
Kolekcja |
Zapytania obsługiwane przez indeksy pojedynczego pola
Za pomocą tych automatycznie utworzonych indeksów jednopola możesz uruchamiać proste zapytania, takie jak:
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 o nierówność in i złożoną równość ==:
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ć złożone zapytanie, które używa porównania zakresu (<, <=, > lub >=) albo posortować wyniki według innego pola, musisz utworzyć dla tego zapytania indeks złożony.
Indeks array-contains umożliwia wysyłanie zapytań do 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
Cloud Firestore używa indeksów złożonych do obsługi złożonych zapytań, których nie obsługują indeksy pojedynczych pól. Na przykład złożony indeks jest potrzebny w przypadku 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ą indeksu złożonego poniżej. Ponieważ zapytanie używa operatora równości (== lub in) w przypadku pola country, możesz użyć w tym polu trybu indeksowania rosnącego lub malejącego. Domyślnie klauzule nierówności stosują porządek sortowania rosnący na podstawie pola w klauzuli nierówności.
| Kolekcja | Zindeksowane pola | Zakres zapytania |
|---|---|---|
| miejscowości | (lub ) kraj, 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 pola 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 | country, population | Kolekcja |
Aby uniknąć spadku wydajności spowodowanego scalaniem indeksów, zalecamy utworzenie indeksu złożonego, który łączy zapytanie 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 ) wielkie litery | Kolekcja |
Zapytania obsługiwane przez indeksy grup kolekcji
Aby zademonstrować indeks z zakresem grupy kolekcji, dodaj podkolekcję do niektórych dokumentów:landmarkscity
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" });
Korzystając z tego indeksu z jednym polem i zakresem kolekcji, możesz wysyłać zapytania do kolekcji landmarks w jednym mieście 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 na przykład chcesz wyszukać punkty orientacyjne we wszystkich miastach, uruchom to zapytanie w grupie kolekcji, która zawiera wszystkie kolekcje landmarks. Musisz też włączyć landmarksindeks pojedynczego pola o zakresie grupy kolekcji:
| Kolekcja | Zindeksowane pola | Zakres zapytania |
|---|---|---|
| punkty orientacyjne, | Kategoria (lub ) | Grupa kolekcji |
Po włączeniu tego indeksu możesz wysyłać zapytania do landmarks grupy kolekcji:
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ądkowane wyniki, musisz włączyć odpowiedni indeks jednopola lub indeks złożony z zakresem grupy kolekcji. Zapytania dotyczące grup kolekcji, które nie filtrują ani nie porządkują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksu.
Możesz na przykład uruchomić to zapytanie dotyczące grupy kolekcji bez włączania dodatkowego indeksu:
Sieć
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 liczby wpisów indeksu.
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 pojedynczego pola
- city_name ASC
- city_name DESC
- temperatures.summer ASC
- temperatures.summer DESC
- temperatures.winter ASC
- temperatures.winter DESC
- neighborhoods Array Contains (ASC i DESC)
Indeksy złożone
- city_name ASC, neighborhoods ARRAY
- city_name DESC, neighborhoods ARRAY
Wpisy indeksu
Ta konfiguracja indeksowania powoduje utworzenie tych wpisów indeksu dla dokumentu:
| Indeks | Zindeksowane dane |
|---|---|
| Wpisy indeksu pojedynczego pola | |
| city_name ASC | city_name: "San Francisco" |
| city_name DESC | city_name: "San Francisco" |
| temperatures.summer ASC | temperatures.summer: 67 |
| temperatures.summer DESC | temperatures.summer: 67 |
| temperatures.winter ASC | temperatures.winter: 55 |
| temperatures.winter DESC | temperatures.winter: 55 |
| neighborhoods Array Contains ASC | dzielnice: „Mission” |
| neighborhoods Array Contains DESC | dzielnice: „Mission” |
| neighborhoods Array Contains ASC | dzielnice: „Downtown” |
| neighborhoods Array Contains DESC | dzielnice: „Downtown” |
| neighborhoods Array Contains ASC | dzielnice: „Marina” |
| neighborhoods Array Contains DESC | dzielnice: „Marina” |
| Wpisy indeksu złożonego | |
| city_name ASC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Mission" |
| city_name ASC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Downtown" |
| city_name ASC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Marina" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Mission" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Downtown" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Marina" |
Indeksy i ceny
Indeksy zwiększają koszty pamięci aplikacji. Więcej informacji o obliczaniu rozmiaru miejsca na dane dla indeksów znajdziesz w sekcji Rozmiar wpisu indeksu.
Używanie scalania indeksów
Chociaż Cloud Firestore używa indeksu w przypadku każdego zapytania, nie musi to być jeden indeks na zapytanie. W przypadku zapytań z wieloma klauzulami równości (==) i opcjonalnie klauzulą orderBy funkcja Cloud Firestore może ponownie wykorzystać istniejące indeksy. Cloud Firestore może łączyć indeksy w przypadku prostych filtrów równości, aby tworzyć indeksy złożone potrzebne do większych zapytań dotyczących równości.
Koszty indeksowania możesz obniżyć, identyfikując sytuacje, w których możesz użyć scalania indeksów. Na przykład w kolekcji restaurants dla aplikacji do oceniania restauracji:
restauracji
burgerthyme
name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
Ta aplikacja używa zapytań takich jak te poniżej. Aplikacja używa kombinacji klauzul równości dla parametrów category, city i editors_pick, a wyniki są zawsze sortowane rosnąco według parametru 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: , ocena: | Kolekcja |
| restauracje | miasto, star_rating | Kolekcja |
| restauracje | category, city, star_rating | Kolekcja |
| restauracje | category, city, editors_pick, star_rating | Kolekcja |
Lepszym rozwiązaniem jest zmniejszenie liczby indeksów przez wykorzystanie możliwości Cloud Firestore do scalania indeksów w przypadku klauzul równości:
| Kolekcja | Zindeksowane pola | Zakres zapytania |
|---|---|---|
| restauracje | Kategoria: , ocena: | Kolekcja |
| restauracje | miasto, star_rating | Kolekcja |
| restauracje | editors_pick, star_rating | Kolekcja |
Ten zestaw indeksów jest nie tylko mniejszy, ale też obsługuje dodatkowe zapytanie:
Sieć
db.collection("restaurants").where("editors_pick", "==", true)
.orderBy("star_rating")Limity indeksowania
Indeksy są objęte tymi ograniczeniami: Więcej informacji o limitach znajdziesz w sekcji Limity.
| Limit | Szczegóły |
|---|---|
| Maksymalna liczba indeksów złożonych w bazie danych |
|
| Maksymalna liczba konfiguracji pojedynczego pola dla bazy danych |
Jedna konfiguracja na poziomie pola może zawierać wiele konfiguracji tego samego pola. Na przykład wykluczenie indeksowania pojedynczego pola i zasady TTL w tym samym polu są liczone jako 1 konfiguracja pola w ramach limitu. |
|
Maksymalna liczba wpisów w indeksie dla każdego dokumentu |
40 000 Liczba wpisów indeksu to suma tych wartości dla dokumentu:
Aby dowiedzieć się, jak Cloud Firestore przekształca dokument i zestaw indeksów w pozycje indeksu, zapoznaj się z tym przykładem liczby pozycji indeksu. |
| Maksymalna liczba pól w indeksie złożonym | 100 |
| Maksymalny rozmiar wpisu indeksu |
7,5 KiB Aby dowiedzieć się, jak Cloud Firestore oblicza rozmiar wpisu w indeksie, zapoznaj się z informacjami o rozmiarze wpisu w indeksie. |
| Maksymalna suma rozmiarów wpisów indeksu dokumentu |
8 MiB Łączny rozmiar dokumentu to suma tych wartości: |
| Maksymalny rozmiar wartości indeksowanego pola |
1500 bajtów Wartości pól przekraczające 1500 bajtów są obcinane. Zapytania dotyczące obciętych 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 linki do komunikatów o błędach pomogą Ci zarządzać indeksami. Wyjątki dotyczące pojedynczych pól warto dodać w tych przypadkach:
| Zgłoszenie | Opis |
|---|---|
| Duże pola ciągów znaków | Jeśli masz pole tekstowe, które często zawiera długie wartości tekstowe, których nie używasz do wysyłania zapytań, możesz obniżyć koszty przechowywania, wyłączając indeksowanie tego pola. |
| Wysokie szybkości zapisu w kolekcji zawierającej dokumenty z wartościami sekwencyjnymi | Jeśli indeksujesz pole, którego wartość rośnie lub maleje sekwencyjnie między dokumentami w kolekcji, np. sygnaturę czasową, maksymalna szybkość zapisu w kolekcji wynosi 500 operacji zapisu na sekundę. Jeśli nie wysyłasz zapytań na podstawie pola z wartościami sekwencyjnymi, możesz wyłączyć indeksowanie tego pola, aby ominąć ten limit. W przypadku zastosowań IoT z wysoką częstotliwością zapisu, np. w kolekcji zawierającej dokumenty z polem sygnatury czasowej, można zbliżyć się do limitu 500 zapisów na sekundę. |
| Pola TTL |
Jeśli używasz zasad TTL (czasu życia), pamiętaj, że pole TTL musi zawierać sygnaturę czasową. Indeksowanie pól TTL jest domyślnie włączone i może wpływać na wydajność przy wyższym natężeniu ruchu. Najlepiej jest dodać wykluczenia pojedynczych pól dla pól TTL. |
| Pola dużych tablic lub map | Duże pola tablicy 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, wyłącz indeksowanie. |
Jeśli używasz zapytań z operatorami zakresu i nierówności w wielu polach, zapoznaj się z uwagami dotyczącymi indeksowania, które pomogą Ci zoptymalizować wydajność i koszt zapytań Cloud Firestore.
Więcej informacji o rozwiązywaniu problemów z indeksowaniem (rozgałęzianie indeksu, błędy INVALID_ARGUMENT) znajdziesz na tej stronie.