Indeksy są ważnym czynnikiem wpływającym na wydajność bazy danych. Podobnie jak indeks książki, który odwzorowuje tematy w książce na numery stron, indeks bazy danych odwzorowuje pozycje w bazie danych na ich lokalizacje w bazie danych. Kiedy wysyłasz zapytanie do bazy danych, baza danych może użyć indeksu, aby szybko wyszukać lokalizacje żądanych elementów.
Na tej stronie opisano dwa typy indeksów używanych przez Cloud Firestore: indeksy jednopolowe i indeksy złożone .
Indeks za każdym zapytaniem
Jeśli dla zapytania nie istnieje żaden indeks, większość baz danych przeszukuje ich zawartość element po elemencie, co jest powolnym procesem, który spowalnia jeszcze bardziej w miarę rozrastania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki zastosowaniu indeksów dla wszystkich zapytań. W rezultacie wydajność zapytania zależy od rozmiaru zestawu wyników, a nie od liczby elementów w bazie danych.
Mniej zarządzania indeksami, więcej tworzenia aplikacji
Cloud Firestore zawiera funkcje, które skracają czas potrzebny na zarządzanie indeksami. Indeksy wymagane dla najbardziej podstawowych zapytań są tworzone automatycznie. Podczas używania i testowania aplikacji Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy wymagane przez aplikację.
Typy indeksów
Cloud Firestore wykorzystuje dwa rodzaje indeksów: jednopolowe i złożone . Oprócz liczby indeksowanych pól, indeksy jednopolowe i złożone różnią się sposobem zarządzania nimi.
Indeksy jednopolowe
Indeks jednopolowy przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji, które zawierają określone pole. Każdy wpis w indeksie jednopolowym rejestruje wartość dokumentu dla określonego pola oraz lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu podstawowych zapytań. Indeksami jednopolowymi zarządza się, konfigurując ustawienia automatycznego indeksowania bazy danych i wykluczenia indeksów.
Automatyczne indeksowanie
Domyślnie Cloud Firestore automatycznie przechowuje indeksy pojedynczych pól dla każdego pola w dokumencie i każdego pola podrzędnego na mapie. Cloud Firestore używa następujących ustawień domyślnych dla indeksów jednopolowych:
Dla każdego pola innego niż tablica i mapa Cloud Firestore definiuje dwa indeksy jednopolowe o zakresie kolekcji , jeden w trybie rosnącym i jeden w trybie malejącym.
Dla każdego pola mapy Cloud Firestore tworzy:
- Jeden rosnący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
- Jeden malejący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i nie będącego mapą.
- Jeden indeks zawierający tablicę o zakresie kolekcji dla każdego podpola tablicy.
- Cloud Firestore rekurencyjnie indeksuje każde podpole mapy.
Dla każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks zawierający tablicę o zasięgu kolekcji.
Indeksy jednopolowe z zakresem grupy kolekcji nie są domyślnie obsługiwane.
Wyjątki z indeksu pojedynczego pola
Możesz wyłączyć pole z ustawień automatycznego indeksowania , tworząc wykluczenie indeksu pojedynczego pola. Wyjątek indeksowania zastępuje ustawienia automatycznego indeksowania całej bazy danych. Wyjątek może włączyć indeks z jednym polem, który w przeciwnym razie zostałby wyłączony przez ustawienia automatycznego indeksowania, lub wyłączyć indeks z jednym polem, który w przeciwnym razie byłby włączony przez automatyczne indeksowanie. W przypadkach, w których wyłączenia mogą być przydatne, zapoznaj się ze sprawdzonymi metodami indeksowania .
Jeśli utworzysz wykluczenie indeksu pojedynczego pola dla pola mapy, pola podrzędne mapy odziedziczą te ustawienia. Można jednak zdefiniować wykluczenia indeksu pojedynczego pola dla określonych pól podrzędnych. Jeśli usuniesz wykluczenie dla pola podrzędnego, pole podrzędne odziedziczy ustawienia wykluczeń swojego elementu nadrzędnego, jeśli takie istnieją, lub ustawienia całej bazy danych, jeśli nie istnieją żadne wykluczenia nadrzędne.
Aby utworzyć wykluczenia indeksów pojedynczych pól i zarządzać nimi, zobacz Zarządzanie indeksami w Cloud Firestore .
Indeksy złożone
Indeks złożony przechowuje posortowane mapowanie wszystkich dokumentów w kolekcji, w oparciu o uporządkowaną listę pól do indeksowania.
Cloud Firestore używa indeksów złożonych do obsługi zapytań, które nie są jeszcze obsługiwane przez indeksy jednopolowe.
Cloud Firestore nie tworzy automatycznie indeksów złożonych, tak jak w przypadku indeksów jednopolowych, 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.
Jeśli spróbujesz wykonać powyższe zapytanie bez uprzedniego utworzenia wymaganego indeksu, Cloud Firestore zwróci komunikat o błędzie zawierający link, który możesz kliknąć, aby utworzyć brakujący indeks. Dzieje się tak za każdym razem, gdy próbujesz wykonać zapytanie nieobsługiwane przez indeks. Indeksy złożone można również definiować i zarządzać nimi ręcznie za pomocą konsoli lub interfejsu wiersza polecenia Firebase . Aby uzyskać więcej informacji na temat tworzenia indeksów złożonych i zarządzania nimi, zobacz Zarządzanie indeksami .
Tryby indeksowania i zakresy zapytań
Inaczej konfiguruje się indeksy jednopolowe i złożone, ale oba wymagają skonfigurowania trybów indeksowania i zakresów zapytań dla indeksów.
Tryby indeksu
Podczas definiowania indeksu wybiera się 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 następujących trybów indeksowania:
Tryb indeksu | Opis |
---|---|
górę | Obsługuje < , <= , == , >= , > , != , in i not-in , klauzule zapytania dotyczące pola i obsługuje sortowanie wyników w porządku rosnącym na podstawie wartości tego pola. |
Malejąca | Obsługuje < , <= , == , >= , > , != , in i not-in klauzule zapytania dotyczące pola i 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 polu. |
Zakresy zapytań
Zakres każdego indeksu obejmuje kolekcję lub grupę kolekcji. Jest to 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 pojedynczej kolekcji.
- Zakres grupy kolekcji
- Grupa kolekcji obejmuje wszystkie kolekcje z tym samym identyfikatorem kolekcji. Aby uruchomić zapytanie dotyczące grupy kolekcji , które zwraca przefiltrowane lub uporządkowane wyniki z grupy kolekcji, należy utworzyć odpowiedni indeks z zakresem grupy kolekcji.
Kolejność domyślna 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ńcowe 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 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 ostatnio posortowane pole w definicji indeksu. Na przykład:
Kolekcja | Pola indeksowane | Zakres zapytania |
---|---|---|
miasta | __name__ | nazwa, Kolekcja |
miasta | stan __name__ | , Kolekcja |
miasta | __name__ | kraj, populacja, Kolekcja |
Aby posortować wyniki według kierunku innego niż domyślny __name__
, musisz utworzyć ten indeks.
Przykład indeksowania
Dzięki automatycznemu tworzeniu jednopolowych indeksów, Cloud Firestore umożliwia Twojej aplikacji szybką obsługę najbardziej podstawowych zapytań do bazy danych. Indeksy jednopolowe umożliwiają wykonywanie prostych zapytań na podstawie wartości pól i komparatorów <
, <=
, ==
, >=
, >
i in
. W przypadku pól tablicowych umożliwiają one wykonywanie zapytań array-contains
i array-contains-any
.
Aby to zilustrować, przeanalizuj poniższe przykłady z punktu widzenia tworzenia indeksu. Poniższy 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"] });
Zakładając domyślne ustawienia automatycznego indeksowania, Cloud Firestore aktualizuje jeden rosnący indeks pojedynczego pola na pole inne niż tablica, jeden malejący indeks pojedynczego pola na pole inne niż tablica i jeden indeks pojedynczego pola zawierający tablicę dla pola tablicy. Każdy wiersz w poniższej tabeli reprezentuje wpis w indeksie jednopolowym:
Kolekcja | Pole indeksowane | Zakres zapytania |
---|---|---|
miasta | nazwa_strzałki | Kolekcja |
miasta | stan | Kolekcja |
miasta | kraj | Kolekcja |
miasta | kapitał | Kolekcja |
miasta | populacja | Kolekcja |
miasta | nazwa_strzałki | Kolekcja |
miasta | stan | Kolekcja |
miasta | kraj | Kolekcja |
miasta | kapitału | Kolekcja |
miasta | populacja | Kolekcja |
miasta | regiony array-contains | Kolekcja |
Zapytania obsługiwane przez indeksy jednopolowe
Korzystając z tych automatycznie tworzonych indeksów jednopolowych, możesz uruchamiać proste zapytania, takie jak poniższe:
Sieć
const stateQuery = citiesRef.where("state", "==", "CA"); const populationQuery = citiesRef.where("population", "<", 100000); const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Możesz także tworzyć zapytania in
i 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 musisz uruchomić zapytanie złożone, które używa porównania zakresów ( <
, <=
, >
lub >=
) lub jeśli chcesz posortować według innego pola, musisz utworzyć indeks złożony dla tego zapytania.
Indeks array-contains
umożliwia zapytanie 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 złożone indeksy
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 jednopolowe. Na przykład potrzebny byłby indeks złożony dla następujących 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ą poniższego indeksu złożonego. Ponieważ zapytanie używa równości ( ==
lub in
) dla pola country
, możesz użyć trybu indeksu 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 | Pola indeksowane | Zakres zapytania |
---|---|---|
miasta | (lub ) kraj, populacja | Kolekcja |
Aby uruchomić te same zapytania, ale z malejącym porządkiem sortowania, potrzebujesz dodatkowego indeksu złożonego w kierunku malejącym dla 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 | Pola indeksowane | Zakres zapytania |
---|---|---|
miasta | kraj, populacja | Kolekcja |
miasta | kraj , populacja | Kolekcja |
Należy również utworzyć indeks złożony, aby 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 | Pola indeksowane | Zakres zapytania |
---|---|---|
miasta | tablica zawiera znaczniki, kapitał | (lub ).Kolekcja |
Zapytania obsługiwane przez indeksy grup kolekcji
Aby zademonstrować indeks z zakresem grupy kolekcji, wyobraź sobie, że do niektórych dokumentów city
dodajesz podzbiór landmarks
:
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 następującego jednopolowego indeksu z zakresem kolekcji, możesz wyszukiwać kolekcję landmarks
pojedynczego miasta na podstawie pola category
:
Kolekcja | Pola indeksowane | Zakres zapytania |
---|---|---|
punkty orientacyjne | (lub ). | Kolekcja |
Sieć
citiesRef.doc("SF").collection("landmarks").where("category", "==", "park") citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])
Teraz wyobraź sobie, że chcesz zapytać o punkty orientacyjne we wszystkich miastach. Aby uruchomić to zapytanie w grupie kolekcji składającej się ze wszystkich kolekcji landmarks
, należy włączyć jednopolowy indeks landmarks
o zakresie grupy kolekcji:
Kolekcja | Pola indeksowane | Zakres zapytania |
---|---|---|
punkty orientacyjne | (lub ). | Grupa kolekcjonerska |
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ądkowane wyniki, należy włączyć odpowiedni indeks jednopolowy lub złożony z zakresem grupy kolekcji. Zapytania grup kolekcji, które nie filtrują ani nie porządkują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.
Na przykład można uruchomić następujące zapytanie o grupę 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 wpisów indeksu .
Poniższy przykład ilustruje wpisy indeksu dokumentu.
Dokument
/cities/SF
city_name : "San Francisco"
temperatures : {summer: 67, winter: 55}
neighborhoods : ["Mission", "Downtown", "Marina"]
Indeksy jednopolowe
- nazwa_miasta ASC
- nazwa_miasta DESC
- temperatury.lato ASC
- temperatury.lato DESC
- temperatury.zima ASC
- temperatury.zima DESC
- sąsiedztwa tablica zawiera (ASC i DESC)
Indeksy złożone
- nazwa_miasta ASC, dzielnice TABLICA
- nazwa_miasta DESC, dzielnice TABLICA
Wpisy indeksu
Ta konfiguracja indeksowania skutkuje następującymi 18 wpisami indeksu dla dokumentu:
Indeks | Zindeksowane dane |
---|---|
Wpisy indeksu jednopolowego | |
nazwa_miasta ASC | nazwa_miasta: "San Francisco" |
nazwa_miasta DESC | nazwa_miasta: "San Francisco" |
temperatury.lato ASC | temperatury.lato: 67 |
temperatury.lato DESC | temperatury.lato: 67 |
temperatury.zima ASC | temperatury. zima: 55 |
temperatury.zima DESC | temperatury. zima: 55 |
sąsiedztwa Tablica zawiera ASC | dzielnice: „Misja” |
sąsiedztwa Tablica zawiera DESC | dzielnice: „Misja” |
sąsiedztwa Tablica zawiera ASC | dzielnice: „Śródmieście” |
sąsiedztwa Tablica zawiera DESC | dzielnice: „Śródmieście” |
sąsiedztwa Tablica zawiera ASC | dzielnice: „Marina” |
sąsiedztwa Tablica zawiera DESC | dzielnice: „Marina” |
Wpisy indeksu złożonego | |
nazwa_miasta ASC, dzielnice TABLICA | nazwa_miasta: „San Francisco”, dzielnice: „Misja” |
nazwa_miasta ASC, dzielnice TABLICA | nazwa_miasta: „San Francisco”, dzielnice: „Śródmieście” |
nazwa_miasta ASC, dzielnice TABLICA | city_name: "San Francisco", dzielnice: "Marina" |
nazwa_miasta DESC, dzielnice TABLICA | nazwa_miasta: „San Francisco”, dzielnice: „Misja” |
nazwa_miasta DESC, dzielnice TABLICA | nazwa_miasta: „San Francisco”, dzielnice: „Śródmieście” |
nazwa_miasta DESC, dzielnice TABLICA | city_name: "San Francisco", dzielnice: "Marina" |
Indeksy i ceny
Indeksy przyczyniają się do kosztów przechowywania aplikacji. Aby uzyskać więcej informacji na temat obliczania rozmiaru magazynu dla indeksów, zobacz Rozmiar wpisu indeksu .
Wykorzystanie łączenia indeksów
Chociaż Cloud Firestore używa indeksu dla każdego zapytania, niekoniecznie wymaga jednego indeksu na zapytanie. W przypadku zapytań z wieloma klauzulami równości ( ==
) i opcjonalnie z klauzulą orderBy
Cloud Firestore może ponownie wykorzystać istniejące indeksy. Cloud Firestore może łączyć indeksy dla prostych filtrów równości, aby tworzyć złożone indeksy potrzebne do większych zapytań równości.
Koszty indeksowania można obniżyć, identyfikując sytuacje, w których można skorzystać z połączenia indeksów. Na przykład wyobraź sobie kolekcję restaurants
dla aplikacji oceniającej restauracje:
tymianek
name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
Teraz wyobraź sobie, że ta aplikacja używa zapytań takich jak te poniżej. Zauważ, że aplikacja używa kombinacji klauzul równości dla category
, city
i editors_pick
zawsze sortując według rosnącej 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 | Pola indeksowane | Zakres zapytania |
---|---|---|
restauracje | kategoria | , ocena w gwiazdkachKolekcja |
restauracje | miasto, ocena w gwiazdkach | Kolekcja |
restauracje | kategoria | , miasto , ocena w gwiazdkachKolekcja |
restauracje | kategoria | , miasto , wybór redaktorów, ocena w gwiazdkachKolekcja |
Lepszym rozwiązaniem jest zmniejszenie liczby indeksów poprzez wykorzystanie możliwości Cloud Firestore do łączenia indeksów dla klauzul równości:
Kolekcja | Pola indeksowane | Zakres zapytania |
---|---|---|
restauracje | kategoria | , ocena w gwiazdkachKolekcja |
restauracje | miasto, ocena w gwiazdkach | Kolekcja |
restauracje | wybór redaktorów, ocena w gwiazdkach | Kolekcja |
Ten zestaw indeksów jest nie tylko mniejszy, ale obsługuje również dodatkowe zapytanie:
Sieć
db.collection("restaurants").where("editors_pick", "==", true) .orderBy("star_rating")
Limity indeksowania
Do indeksów mają zastosowanie następujące ograniczenia. Aby zapoznać się ze wszystkimi przydziałami i limitami, zobacz Przydziały i limity .
Limit | Detale |
---|---|
Maksymalna liczba indeksów złożonych dla bazy danych | 200 Możesz skontaktować się z pomocą techniczną , aby poprosić o zwiększenie tego limitu. |
Maksymalna liczba konfiguracji jednopolowych dla bazy danych | 200 W sumie dozwolonych jest 200 konfiguracji na poziomie pola. Jedna konfiguracja pola może zawierać wiele konfiguracji dla tego samego pola. Na przykład wykluczenie z indeksowania pojedynczego pola i zasada TTL dla tego samego pola liczą się jako jedna konfiguracja pola w ramach limitu. |
Maksymalna liczba wpisów indeksu dla każdego dokumentu | 40 000 Liczba wpisów indeksu jest sumą następujących elementów dla dokumentu:
Aby zobaczyć, jak Cloud Firestore zamienia dokument i zestaw indeksów we wpisy indeksu, zobacz ten przykład zliczania wpisów indeksu . |
Maksymalna liczba pól w indeksie złożonym | 100 |
Maksymalny rozmiar wpisu indeksu | 7,5 KiB Aby zobaczyć, jak Cloud Firestore oblicza rozmiar wpisu indeksu, zobacz Rozmiar wpisu indeksu . |
Maksymalna suma rozmiarów wpisów indeksu dokumentu | 8 MiB Całkowity rozmiar jest sumą następujących elementów dla dokumentu: |
Maksymalny rozmiar indeksowanej wartości pola | 1500 bajtów Wartości pól przekraczające 1500 bajtów są obcinane. Zapytania zawierające obcięte wartości pól mogą zwracać niespójne wyniki. |
Indeksowanie najlepszych praktyk
W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i linkach komunikatów o błędach do zarządzania indeksami. Możesz jednak chcieć dodać wyjątki dotyczące jednego pola w następujących przypadkach:
Sprawa | Opis |
---|---|
Duże pola ciągów | Jeśli masz pole znakowe, które często zawiera długie wartości ciągów, których nie używasz do wykonywania zapytań, możesz obniżyć koszty magazynowania, wykluczając to pole z indeksowania. |
Wysokie współczynniki zapisu do kolekcji zawierającej dokumenty z kolejnymi wartościami | Jeśli indeksujesz pole, które zwiększa się lub zmniejsza sekwencyjnie między dokumentami w kolekcji, na przykład znacznik czasu, maksymalna szybkość zapisu do kolekcji wynosi 500 zapisów na sekundę. Jeśli nie wykonujesz zapytania na podstawie pola z wartościami sekwencyjnymi, możesz wyłączyć to pole z indeksowania, aby ominąć ten limit. Na przykład w przypadku użycia IoT z dużą szybkością zapisu kolekcja zawierająca dokumenty z polem znacznika czasu może zbliżyć się do limitu 500 zapisów na sekundę. |
pola TTL | Jeśli używasz zasad TTL (time-to-live) , pamiętaj, że pole TTL musi zawierać sygnaturę czasową. Indeksowanie w polach TTL jest domyślnie włączone i może wpływać na wydajność przy wyższym natężeniu ruchu. Jako sprawdzoną praktykę dodaj wyjątki dotyczące pojedynczych pól dla pól TTL. |
Duże pola tablicy lub mapy | Duże pola tablicy lub mapy mogą zbliżyć się do limitu 40 000 wpisów indeksu na dokument. Jeśli nie wykonujesz zapytań na podstawie dużej tablicy lub pola mapy, powinieneś wyłączyć je z indeksowania. |
Więcej informacji o rozwiązywaniu problemów z indeksowaniem (rozwijanie indeksu, błędy INVALID_ARGUMENT
) znajdziesz na stronie rozwiązywania problemów .