Indeksy mają duży wpływ na wydajność bazy danych. Podobnie jak indeks książki, który przyporządkowuje tematy do numerów stron, indeks bazy danych przyporządkowuje elementy bazy danych do ich lokalizacji w bazie danych. Gdy wysyłasz zapytanie do bazy danych, może ona użyć indeksu, aby szybko zidentyfikować żądane elementy.
Na tej stronie opisujemy 2 typy indeksów używanych przez Cloud Firestore: indeksy pojedynczych pól i indeksy złożone.
Definicja i struktura indeksu
Indeks jest definiowany na podstawie listy pól danego dokumentu z odpowiednim trybem indeksowania dla każdego pola.
Indeks zawiera wpis dla każdego pola określonego w definicji indeksu. Indeks zawiera wszystkie dokumenty, które są potencjalnymi wynikami zapytań opartych na indeksie. Dokument jest uwzględniany w indeksie tylko wtedy, gdy ma zdefiniowaną wartość indeksowaną dla każdego pola użytego w indeksie. Jeśli definicja indeksu odnosi się do pola, dla którego w dokumencie nie ma ustawionej wartości, dokument nie pojawi się w indeksie. W takim przypadku dokument nigdy nie zostanie zwrócony 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 nie istnieje indeks zapytania, większość baz danych indeksuje ich zawartość element po elemencie. Jest to powolny proces, który jeszcze bardziej spowalnia wraz z wzrostem 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 od liczby elementów w bazie danych.
Mniej zarządzania indeksem, więcej czasu na rozwój aplikacji
Cloud Firestore zawiera funkcje, które skracają czas potrzebny na zarządzanie indeksem. Indeksy wymagane do najprostszych zapytań są tworzone automatycznie. Podczas używania i testowania aplikacji Cloud Firestore pomaga Ci zidentyfikować i utworzyć dodatkowe indeksy, których potrzebuje Twoja aplikacja.
Typy indeksów
Cloud Firestore używa 2 typów indeksów: jednopolowego i złożonego. Oprócz liczby indeksowanych pól indeksy pojedynczego pola i kompleksowe różnią się sposobem zarządzania.
Indeksy pojedynczego pola
Indeks z 1 polem przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji, które zawierają określone pole. Każdy wpis w indeksie jednopolowym zawiera wartość dokumentu w danym polu oraz jego położenie w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu zapytań podstawowych. Indeksami pojedynczych pól możesz zarządzać, konfigurując ustawienia automatycznego indeksowania bazy danych i wykluczenia indeksu.
Automatyczne indeksowanie
Domyślnie Cloud Firestore automatycznie utrzymuje indeksy z jednym polem dla każdego pola w dokumencie i każdego pola podrzędnego na mapie. Cloud Firestoreużywa tych domyślnych ustawień indeksów jednopolowych:
W przypadku każdego pola, które nie jest tablicą ani mapą, funkcja Cloud Firestore definiuje 2 indeksy pojedynczego pola o zakresie kolekcji: jeden w trybie rosnącym i jeden w trybie malejącym.
W przypadku każdego pola mapy Cloud Firestore tworzy:
- Jeden indeks w kolejności rosnącej na poziomie kolekcji dla każdego podpola, które nie jest tablicą ani mapą.
- 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 na poziomie kolekcji dla każdego podpola tablicy;
- Cloud Firestore rekurencyjnie indeksuje każde podpole mapy.
W przypadku każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks tablicy zawierającej o zakresie kolekcji.
Indeksy pojedynczego pola o zakresie grupy kolekcji nie są domyślnie aktualizowane.
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 pozwala 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. Informacje o sytuacjach, w których wykluczenia mogą być przydatne, znajdziesz w artykule ze sprawdzonymi metodami indeksowania.
Użyj wartości ścieżki pola *
, aby dodać wyłączenia indeksowania na poziomie kolekcji dla wszystkich pól w grupie kolekcji. Na przykład dla grupy kolekcji comments
ustaw ścieżkę pola na *
, aby dopasować wszystkie pola w grupie kolekcji comments
, i wyłącz indeksowanie wszystkich pól w grupie kolekcji. Następnie możesz dodać wykluczenia, aby indeksować tylko pola wymagane do zapytań. Zmniejszenie liczby indeksowanych pól zmniejsza koszty przechowywania i może poprawić wydajność zapisu.
Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, podpola 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, pole podrzędne odziedziczy ustawienia wykluczenia z pola nadrzędnego (jeśli istnieją) lub ustawienia dotyczące całej bazy danych, jeśli nie istnieją wykluczenia nadrzędne.
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, 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 próbujesz wykonać zapytanie, które nie jest obsługiwane przez indeks, Cloud Firestorezwraca komunikat o błędzie z linkiem, który umożliwia utworzenie brakującego indeksu.
Możesz też definiować indeksy złożone ręcznie i zarządzać nimi 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 z jednym polem i złożonymi konfigurujesz inaczej, ale oba wymagają skonfigurowania trybów indeksów i zakresów zapytań.
Tryby indeksowania
Podczas definiowania indeksu możesz wybrać tryb indeksowania dla każdego indeksowanego pola. Tryb indeksowania każdego pola obsługuje określone klauzule zapytania dotyczące tego pola. Możesz wybrać jeden z tych trybów indeksowania:
Tryb indeksowania | Opis |
---|---|
Rosnąco | Obsługuje klauzule zapytania < , <= , == , >= , > , != , in i not-in w przypadku tego pola oraz umożliwia sortowanie wyników w kolejności rosnącej na podstawie wartości tego pola. |
Malejąco | Obsługuje w tym polu klauzule zapytania < , <= , == , >= , > , != , in i not-in oraz umożliwia sortowanie wyników w kolejności malejącej według tej wartości pola. |
Tablica – zawiera | Obsługuje w tym polu klauzule zapytania array-contains i array-contains-any . |
Wektor | Obsługuje klauzule zapytania FindNearest dotyczące tego pola. |
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 1 kolekcji.
- Zakres grupy kolekcji
- Grupa kolekcji obejmuje wszystkie kolekcje o tym samym identyfikatorze. Aby wykonać zapytanie dotyczące grupy kolekcji, które zwraca zfiltrowane lub posortowane 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 indeksowania określonych dla poszczególnych pól (rosnąco lub malejąco) indeksy stosują ostateczne sortowanie według pola __name__
każdego dokumentu. Wartość pola __name__
jest ustawiona na pełna ścieżka do 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 pole sortowane w definicji indeksu. Przykład:
Kolekcja | Zindeksowane pola | Zakres zapytania |
---|---|---|
miejscowości | __name__ |
name, Kolekcja |
miejscowości | __name__ |
stan, Kolekcja |
miejscowości | __name__ |
kraj, populacja: , Kolekcja |
Aby posortować wyniki według innego niż domyślny kierunek __name__
, musisz utworzyć ten indeks.
Właściwości indeksu
Indeks, który umożliwia najbardziej efektywne wykonanie 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 są już uwzględnione w porządku sortowania)
- Pola używane w zbiorach (które nie są już uwzględnione w porządkach sortowania oraz filtrach zakresu i nierówności)
Cloud Firestore oblicza wyniki zapytań w ten sposób:
- Określa indeks odpowiadający kolekcji zapytania, właściwościom filtra, operatorom filtra i porządkowaniu.
- Określa pozycję indeksu, od której rozpoczyna się skanowanie. Pozycja początkowa jest poprzedzona filtrami równości zapytania, a kończy się 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.
- Dociera do końca indeksu.
- Zbiera maksymalną liczbę wyników zwróconych przez zapytanie.
Przykład indeksowania
Dzięki automatycznemu tworzeniu indeksów jednopolowych Cloud Firestoreumożliwia aplikacji szybkie obsługiwanie najbardziej podstawowych zapytań do bazy danych.
Indeksy jednopolowe umożliwiają wykonywanie prostych zapytań na podstawie wartości pól i porównań <
, <=
, ==
, >=
, >
i in
. W przypadku pól tablicowych umożliwiają one wykonywanie zapytań array-contains
i array-contains-any
.
Aby to zilustrować, przyjrzyj się poniższym przykładom z perspektywy tworzenia indeksu. Ten fragment kodu tworzy kilka dokumentów city
w zbiorze cities
i ustawia w każdym z nich pola name
, state
, country
, capital
, population
i tags
:
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 Cloud Firestore aktualizuje 1 rosnący indeks pojedynczego pola na pole niebędące tablicą, 1 malejący indeks pojedynczego pola dla pola niebędącego tablicą i 1 indeks zawierający 1 pole tablicy. Każdy wiersz w tabeli poniżej odpowiada wpisowi w indeksie jednopolowym:
Kolekcja | Pole zindeksowane | 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 pojedynczego pola
Korzystając z tych automatycznie utworzonych indeksów z pojedynczym polem, możesz wykonywać 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 in
i zapytania złożone o 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ć zapytanie złożone, które używa porównania zakresu (<
, <=
,
>
lub >=
), lub jeśli chcesz posortować dane według innego pola, musisz utworzyć dla tego zapytania indeks złożony.
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
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. Indeks złożony będzie na przykład 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. W przypadku pola country
w zapytaniu stosowana jest równość (==
lub in
), więc możesz w tym polu użyć trybu indeksu rosnącego lub malejącego. Domyślnie klauzule nierówności stosują rosnącą kolejność sortowania na podstawie pola w klauzuli nierówności.
Kolekcja | Zindeksowane pola | Zakres zapytania |
---|---|---|
miejscowości | (lub ) kraj, liczba ludności | Kolekcja |
Aby wykonać te same zapytania, ale w kolejności malejącej, 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 | country, population | Kolekcja |
Aby uniknąć spadku wydajności spowodowanego scalaniem indeksów, zalecamy utworzenie indeksu złożonego, który połą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 ) z wielką literyKolekcja |
Zapytania obsługiwane przez indeksy grup kolekcji
Aby zademonstrować indeks z zakresem grup kolekcji, dodaj kolekcję podrzędną landmarks
do niektórych dokumentów city
:
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 poniższego indeksu pojedynczego pola z zakresem kolekcji, możesz wysyłać zapytania do kolekcji landmarks
z pojedynczego 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 na przykład chcesz wysyłać zapytania o punkty orientacyjne we wszystkich miastach, uruchamiasz to zapytanie w grupie kolekcji złożonej ze wszystkich kolekcji landmarks
. Musisz też włączyć landmarks
indeks pojedynczego pola z zakresem 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 wykonać zapytanie dotyczące grupy kolekcji, które zwraca przefiltrowane lub posortowane wyniki, musisz włączyć odpowiedni indeks pojedynczego pola lub złożony z zakresem grup kolekcji. Zapytania dotyczące grup kolekcji, które nie filtrują ani nie sortują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.
Możesz na przykład uruchomić to zapytanie dotyczące grupy kolekcji bez włączania dodatkowego indeksu:
Sieć
db.collectionGroup("landmarks").get()
Wpisy indeksu
Liczba wpisów indeksu dla dokumentu zależy od skonfigurowanych indeksów projektu i struktury 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
- Tablica neighborhoods zawiera (ASC i DESC)
Indeksy złożone
- city_name ASC, neighborhoods ARRAY
- city_name DESC, neighborhoods ARRAY
Wpisy indeksu
Ta konfiguracja indeksowania powoduje, że w przypadku dokumentu występują następujące wpisy indeksu:
Indeks | Dane indeksowane |
---|---|
Wpisy w indeksie pojedynczego pola | |
nazwa_miasta AS | city_name: "San Francisco" |
city_name DESC | city_name: "San Francisco" |
temperatury.letnie ASC | temperatura.lato: 67 |
temperatures.summer DESC | temperatures.summer: 67 |
temperatury.zima ASC | temperatury.zima: 55 |
temperatury.zima DESC | temperatury.zima: 55 |
Tablica neighborhoods zawiera ASC | dzielnice: „Misja” |
Tablica neighborhoods zawiera DESC | dzielnice: „Mission”; |
Tablica dzielnic zawiera ASC | dzielnice: „Downtown”. |
Dzielnice – Tablica zawiera DESC | dzielnice: „Downtown”. |
Tablica neighborhoods zawiera ASC | dzielnice: „Marina”. |
Tablica neighborhoods zawiera DESC | dzielnice: „Marina”. |
Wpisy indeksu złożonego | |
nazwa_miasta ASC, dzielnice ARRAY | city_name: "San Francisco", neighborhoods: "Mission" |
nazwa_miasta ASC, dzielnice ARRAY | city_name: "San Francisco", neighborhoods: "Downtown" |
city_name ASC, neighborhoods ARRAY | City_name: "Warszawa", dzielnice: "Marina" |
nazwa_miasta DESC, dzielnice 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: "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 w indeksie.
Użyj scalania indeksu
Chociaż Cloud Firestore używa indeksu dla 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 używać istniejących indeksów. Cloud Firestore może scalić indeksy na potrzeby prostych filtrów równości, aby utworzyć indeksy złożone potrzebne do obsługi większych zapytań o równość.
Możesz obniżyć koszty indeksowania, identyfikując sytuacje, w których możesz użyć scalania indeksów. Na przykład w zbiorze restaurants
w aplikacji oceniającej restauracje:
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 klauzul równości dla funkcji category
, city
i editors_pick
, zawsze sortując 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 | category, star_rating | Kolekcja |
restauracje | city, star_rating | Kolekcja |
restauracje | category, city, star_rating | Kolekcja |
restauracje | Kategoria: | , miasto, editor_pick, star_ratingKolekcja |
Lepszym rozwiązaniem jest zmniejszenie liczby indeksów przez wykorzystanie możliwości Cloud Firestore do łączenia indeksów w przypadku klauzul równości:
Kolekcja | Zindeksowane pola | Zakres zapytania |
---|---|---|
restauracje | category, star_rating | Kolekcja |
restauracje | city, 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
W przypadku indeksów obowiązują podane niżej limity. Więcej informacji o limitach znajdziesz w artykule Limity i limity.
Limit | Szczegóły |
---|---|
Maksymalna liczba indeksów złożonych w bazie danych |
|
Maksymalna liczba konfiguracji z jednym polem dla bazy danych |
Jedna konfiguracja na poziomie pola może zawierać wiele konfiguracji tego samego pola. Na przykład wykluczenie indeksowania pojedynczego pola i zasada TTL w tym samym polu są wliczane jako 1 konfiguracja pola i zbliżają się do limitu. |
Maksymalna liczba wpisów indeksu w przypadku każdego dokumentu |
40 000 Liczba wpisów w indeksie to suma następujących wartości dokumentu:
Aby dowiedzieć się, jak Cloud Firestore przekształca dokument i zestaw indeksów w rekordy indeksu, zapoznaj się z tym przykładem zliczania rekordów indeksu. |
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, zapoznaj się z artykułem Rozmiar wpisu w indeksie. |
Maksymalna suma rozmiarów wpisów w indeksie dokumentu |
8 MiB Łączny rozmiar to suma tych elementów w dokumentach: |
Maksymalny rozmiar wartości pola indeksowanego |
1500 bajtów Wartości pól dłuższe niż 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 do zarządzania indeksami służy automatyczne indeksowanie i linki z komunikatami o błędach. Możesz jednak dodać wykluczenia jednego pola w tych przypadkach:
Zgłoszenie | Opis |
---|---|
Duże pola ciągów | Jeśli masz pole ciągu znaków, które często zawiera długie ciągi znaków, których nie używasz do wykonywania zapytań, możesz obniżyć koszty przechowywania, wykluczając to pole z indeksowania. |
Duża szybkość zapisu w kolekcji zawierającej dokumenty z wartościami sekwencyjnymi | Jeśli indeksujesz pole, które wzrasta lub maleje sekwencyjnie między dokumentami w kolekcji, np. sygnaturę czasową, maksymalna szybkość zapisu do kolekcji wynosi 500 operacji na sekundę. Jeśli nie wysyłasz zapytań na podstawie pola o wartościach sekwencyjnych, możesz wyłączyć indeksowanie tego pola, aby ominąć ten limit. W przypadku IoT o wysokiej szybkości zapisu kolekcja zawierająca dokumenty z polem z polem sygnatury czasowej może 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 w przypadku pól TTL jest domyślnie włączone i może wpływać na wydajność przy większych natężeniach ruchu. Najlepiej jest dodać wykluczenia pojedynczych pól dla pól TTL. |
Duże tablice lub pola mapowania | Duże pola tablic lub map mogą zbliżać się do limitu 40 tys. 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 uwagami dotyczącymi indeksowania, które warto wziąć pod uwagę, aby zoptymalizować wydajność i koszt zapytań 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.