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 kryjący się za każdym zapytaniem
Jeśli dla zapytania nie istnieje żaden indeks, większość baz danych przeszukuje zawartość element po elemencie. Jest to powolny proces, który spowalnia jeszcze bardziej w miarę powiększania się bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań dzięki zastosowaniu indeksów dla wszystkich zapytań. W rezultacie wydajność zapytań 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 zmniejszają ilość czasu potrzebnego na zarządzanie indeksami. Indeksy wymagane dla najbardziej podstawowych zapytań są tworzone automatycznie. Gdy używasz i testujesz aplikację, Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy wymagane przez aplikację.
Typy indeksów
Cloud Firestore wykorzystuje dwa typy 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 zawierających określone pole. Każdy wpis w indeksie jednopolowym rejestruje wartość dokumentu dla określonego pola i lokalizację dokumentu w bazie danych. Cloud Firestore używa tych indeksów do wykonywania wielu podstawowych zapytań. Indeksami jednopolowymi zarządzasz, konfigurując ustawienia automatycznego indeksowania i wykluczenia indeksów w bazie danych.
Automatyczne indeksowanie
Domyślnie Cloud Firestore automatycznie utrzymuje indeksy pojedynczych pól dla każdego pola w dokumencie i każdego podpola 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 następujące elementy:
- Jeden rosnący indeks zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
- Jeden indeks malejący zakresu kolekcji dla każdego podpola niebędącego tablicą i niebędącego mapą.
- Jedna tablica o zasięgu kolekcji zawiera indeks 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 zakresie kolekcji.
Indeksy jednopolowe z zakresem grupy kolekcji nie są domyślnie obsługiwane.
Wyłączenia indeksów jednopolowych
Możesz wyłączyć pole z ustawień automatycznego indeksowania , tworząc wykluczenie indeksu pojedynczego pola. Wyłączenie indeksowania zastępuje ustawienia automatycznego indeksowania obejmujące całą bazę danych. Wyjątek może włączyć indeks jednopolowy, który w przeciwnym razie ustawienia automatycznego indeksowania spowodowałby wyłączenie lub wyłączenie indeksu jednopolowego, który w przeciwnym razie umożliwiłby automatyczne indeksowanie. W przypadkach, w których wyjątki mogą być przydatne, zapoznaj się ze sprawdzonymi metodami indeksowania .
Użyj wartości ścieżki pola * , aby dodać wykluczenia indeksu na poziomie kolekcji dla wszystkich pól w grupie kolekcji. Na przykład w przypadku comments w grupie kolekcji 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 zaindeksować tylko pola wymagane dla Twoich 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żna jednak zdefiniować wyłączenia indeksu pojedynczego pola dla określonych podpól. Jeśli usuniesz wykluczenie dla podpola, podpole odziedziczy ustawienia wykluczeń swojego rodzica, jeśli istnieją, lub ustawienia całej bazy danych, jeśli nie istnieją żadne wykluczenia nadrzędne.
Aby utworzyć i zarządzać wykluczeniami indeksów jednopolowych, zobacz Zarządzanie indeksami w Cloud Firestore .
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.
Cloud Firestore wykorzystuje indeksy złożone 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 ma to miejsce 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, za pomocą którego możesz utworzyć brakujący indeks. Dzieje się tak za każdym razem, gdy próbujesz wykonać zapytanie nieobsługiwane przez indeks. Można także definiować indeksy złożone i zarządzać nimi ręcznie, korzystając z konsoli lub interfejsu wiersza polecenia Firebase . Więcej informacji na temat tworzenia indeksów złożonych i zarządzania nimi można znaleźć w sekcji Zarządzanie indeksami .
Tryby indeksowania i zakresy zapytań
Konfigurujesz indeksy jednopolowe i indeksy złożone w różny sposób, ale oba wymagają skonfigurowania trybów indeksu i zakresów zapytań dla indeksów.
Tryby indeksowania
Definiując indeks, wybierasz tryb indeksowania dla każdego indeksowanego pola. Tryb indeksowania każdego pola obsługuje określone klauzule zapytania dotyczące tego pola. Można wybierać spośród następujących trybów indeksowania:
| Tryb indeksu | Opis |
|---|---|
| górę | Obsługuje < , <= , == , >= , > , != , in i not-in klauzule zapytania dotyczące pola oraz obsługuje sortowanie wyników w kolejności rosnącej na podstawie wartości tego pola. |
| Malejąco | Obsługuje klauzule zapytania < , <= , == , >= , > , != , in i not-in w polu oraz obsługuje sortowanie wyników w kolejności malejącej na podstawie wartości tego pola. |
| Tablica zawiera | Obsługuje klauzule zapytania array-contains i array-contains-any w polu. |
Zakresy zapytań
Każdy indeks ma zakres do kolekcji lub grupy kolekcji. Nazywa się to zakresem zapytania indeksu:
- Zakres kolekcji
- Cloud Firestore domyślnie tworzy indeksy z zakresem kolekcji. Te indeksy obsługują zapytania zwracające wyniki z pojedynczej kolekcji.
- Zakres grupy kolekcji
- Grupa kolekcji obejmuje wszystkie kolekcje o tym samym identyfikatorze kolekcji. Aby uruchomić zapytanie o grupę kolekcji , które zwróci przefiltrowane lub uporządkowane wyniki z grupy kolekcji, należy utworzyć odpowiedni indeks o zasięgu grupy kolekcji.
Domyślna kolejność 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 zestawie wynikowym zawierające te same wartości 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 | nazwa, __name__ | Kolekcja |
| miasta | stan , __name__ | Kolekcja |
| miasta | kraj, populacja, __name__ | Kolekcja |
Aby posortować wyniki według innego niż domyślny kierunku __name__ , musisz utworzyć ten indeks.
Przykład indeksowania
Dzięki automatycznemu tworzeniu indeksów jednopolowych Cloud Firestore umożliwia Twojej aplikacji szybką obsługę najbardziej podstawowych zapytań do bazy danych. Indeksy jednopolowe umożliwiają wykonywanie prostych zapytań w oparciu o wartości pól i komparatory < , <= , == , >= , > 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 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 jednopolowy na każde pole niebędące tablicą, jeden malejący indeks jednopolowy na każde pole niebędące tablicą i jeden indeks jednopolowy zawierający tablicę dla pola tablicowego. Każdy wiersz poniższej tabeli reprezentuje wpis w indeksie jednopolowym:
| Kolekcja | Pole indeksowane | Zakres zapytania |
|---|---|---|
| miasta | nazwa | Kolekcja |
| miasta | stan | Kolekcja |
| miasta | kraj | Kolekcja |
| miasta | kapitału | Kolekcja |
| miasta | populacja | Kolekcja |
| miasta | nazwa | Kolekcja |
| miasta | stan | Kolekcja |
| miasta | kraju | Kolekcja |
| miasta | kapitału | Kolekcja |
| miasta | populacja | Kolekcja |
| miasta | regiony array-contains | Kolekcja |
Zapytania obsługiwane przez indeksy jednopolowe
Korzystając z 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 in i składać zapytania 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 zakresów ( < , <= , > lub >= ) lub jeśli chcesz sortować według innego pola, musisz utworzyć indeks złożony dla tego zapytania.
Indeks array-contains umożliwia odpytywanie 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 zapytań złożonych, które nie są jeszcze obsługiwane przez indeksy jednopolowe. Na przykład potrzebujesz indeksu złożonego 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 , dla tego pola można zastosować rosnący lub malejący tryb indeksowania. Domyślnie w klauzulach nierówności stosuje się rosnący porządek sortowania w oparciu o pole w klauzuli nierówności.
| Kolekcja | Pola indeksowane | Zakres zapytania |
|---|---|---|
| miasta | (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 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 także 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, (lub ) kapitał | Kolekcja |
Zapytania obsługiwane przez indeksy grup kolekcji
Aby zademonstrować indeks z zakresem grupy kolekcji, wyobraź sobie, że dodajesz podkolekcję 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 jednopolowego indeksu z zakresem zbioru, możesz przeszukiwać zbiór landmarks pojedynczego miasta na podstawie pola category :
| Kolekcja | Pola indeksowane | 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"])
Teraz wyobraź sobie, że chcesz wyszukać punkty orientacyjne we wszystkich miastach. Aby uruchomić to zapytanie na grupie kolekcji składającej się ze wszystkich kolekcji landmarks , musisz włączyć jednopolowy indeks landmarks o zakresie grupy kolekcji:
| Kolekcja | Pola indeksowane | Zakres zapytania |
|---|---|---|
| punkty orientacyjne | kategoria (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 o grupę kolekcji, które zwróci przefiltrowane lub uporządkowane wyniki, należy włączyć odpowiedni indeks jednopolowy lub złożony z zakresem grupy kolekcji. Zapytania o grupy kolekcji, które nie filtrują ani nie porządkują wyników, nie wymagają jednak żadnych dodatkowych definicji indeksów.
Można na przykład uruchomić następujące zapytanie dotyczące grupy kolekcji bez włączania dodatkowego indeksu:
Sieć
db.collectionGroup("landmarks").get()
Wpisy indeksowe
Indeksy skonfigurowane w projekcie i struktura dokumentu określają liczbę wpisów indeksu w dokumencie. Wpisy indeksu wliczają się do limitu liczby 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
- tablica dzielnic zawiera (ASC i DESC)
Indeksy złożone
- nazwa_miasta ASC, dzielnice ARRAY
- nazwa_miasta DESC, dzielnice ARRAY
Wpisy indeksowe
Ta konfiguracja indeksowania skutkuje następującymi 18 wpisami indeksu dla dokumentu:
| Indeks | Indeksowane dane |
|---|---|
| Jednopolowe wpisy indeksu | |
| nazwa_miasta ASC | city_name: "San Francisco" |
| nazwa_miasta DESC | city_name: "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” |
| dzielnice Tablica zawiera DESC | dzielnice: „Misja” |
| sąsiedztwa Tablica zawiera ASC | dzielnice: "Śródmieście" |
| dzielnice Tablica zawiera DESC | dzielnice: "Śródmieście" |
| sąsiedztwa Tablica zawiera ASC | dzielnice: "Marina" |
| dzielnice Tablica zawiera DESC | dzielnice: "Marina" |
| Złożone wpisy indeksu | |
| nazwa_miasta ASC, dzielnice ARRAY | city_name: „San Francisco”, dzielnice: „Misja” |
| nazwa_miasta ASC, dzielnice ARRAY | nazwa_miasta: „San Francisco”, dzielnice: „Śródmieście” |
| nazwa_miasta ASC, dzielnice ARRAY | nazwa_miasta: „San Francisco”, dzielnice: „Marina” |
| nazwa_miasta DESC, dzielnice ARRAY | city_name: „San Francisco”, dzielnice: „Misja” |
| nazwa_miasta DESC, dzielnice ARRAY | nazwa_miasta: „San Francisco”, dzielnice: „Śródmieście” |
| nazwa_miasta DESC, dzielnice ARRAY | nazwa_miasta: „San Francisco”, dzielnice: „Marina” |
Indeksy i ceny
Indeksy przyczyniają się do kosztów przechowywania Twojej aplikacji. Więcej informacji na temat obliczania rozmiaru magazynu dla indeksów można znaleźć w artykule Rozmiar wpisu indeksu .
Korzystanie z łą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 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 zbudować indeksy złożone potrzebne do większych zapytań o równość.
Koszty indeksowania można obniżyć, identyfikując sytuacje, w których można skorzystać z łączenia indeksów. Wyobraźmy sobie na przykład kolekcję restaurants dla aplikacji do oceniania restauracji:
restauracje
burger 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. Zwróć uwagę, że aplikacja używa kombinacji klauzul równości dla 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 | Pola indeksowane | Zakres zapytania |
|---|---|---|
| restauracje | kategoria , kategoria strzałki | Kolekcja |
| restauracje | miasto, star_rating | Kolekcja |
| restauracje | kategoria, miasto, | Kolekcja |
| restauracje | kategoria, miasto, redaktorzy_wybór, star_rating | Kolekcja |
Lepszym rozwiązaniem jest zmniejszenie liczby indeksów, korzystając z możliwości Cloud Firestore łączenia indeksów w celu uzyskania klauzul równości:
| Kolekcja | Pola indeksowane | Zakres zapytania |
|---|---|---|
| restauracje | kategoria , kategoria strzałki | Kolekcja |
| restauracje | miasto, star_rating | Kolekcja |
| restauracje | redaktorzy_wybór, ocena_gwiazdkowa | Kolekcja |
Ten zestaw indeksów jest nie tylko mniejszy, ale obsługuje także dodatkowe zapytanie:
Sieć
db.collection("restaurants").where("editors_pick", "==", true)
.orderBy("star_rating")
Limity indeksowania
Poniższe ograniczenia dotyczą indeksów. 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 |
|
| Maksymalna liczba konfiguracji jednopolowych dla bazy danych |
Konfiguracja na poziomie jednego pola może zawierać wiele konfiguracji dla tego samego pola. Na przykład zwolnienie z indeksowania pojedynczego pola i zasady TTL dotyczące tego samego pola wliczają się do limitu jako konfiguracja jednego pola. |
Maksymalna liczba wpisów indeksu dla każdego dokumentu | 40 000 Liczba wpisów indeksu jest sumą następujących wartości dla dokumentu:
Aby zobaczyć, jak Cloud Firestore zamienia dokument i zestaw indeksów we wpisy indeksu, zobacz przykład liczby 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 MB Całkowity rozmiar dokumentu jest sumą następujących parametrów: |
| Maksymalny rozmiar wartości pola indeksowanego | 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. |
Najlepsze praktyki indeksowania
W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i łączach komunikatów o błędach do zarządzania indeksami. Można jednak dodać wyjątki jednopolowe w następujących przypadkach:
| Sprawa | Opis |
|---|---|
| Duże pola tekstowe | Jeśli masz pole znakowe, które często przechowuje długie wartości ciągów, których nie używasz do wykonywania zapytań, możesz obniżyć koszty przechowywania, zwalniając 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 zapytań w oparciu o pole z kolejnymi wartościami, możesz wyłączyć 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 sygnatury czasowej może zbliżać się do limitu 500 zapisów na sekundę. |
| Pola TTL | Jeśli korzystasz z zasad TTL (time-to-live) , pamiętaj, że pole TTL musi być znacznikiem czasu. Indeksowanie pól TTL jest domyślnie włączone i może wpływać na wydajność przy większym natężeniu ruchu. Najlepszym rozwiązaniem jest dodanie wyjątków pojedynczych pól dla pól TTL. |
| Duża tablica lub pola mapy | Duże pola tablicowe lub mapy mogą zbliżać się do limitu 40 000 wpisów indeksu na dokument. Jeśli nie odpytujesz w oparciu o dużą tablicę lub pole mapy, powinieneś wyłączyć je z indeksowania. |
Więcej informacji na temat rozwiązywania problemów z indeksowaniem (rozwijanie indeksu, błędy INVALID_ARGUMENT ) znajdziesz na stronie rozwiązywania problemów .