Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Typy indeksów w Cloud Firestore

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

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 pojedynczego pola o zakresie kolekcji , jeden w trybie rosnącym i jeden w trybie malejącym.

  • Dla każdego pola mapy Cloud Firestore tworzy jeden indeks rosnący zakresu kolekcji i jeden indeks malejący dla każdego podpola niebędącego tablicą i niebędącego mapą na mapie.

  • 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
Rosnąco 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 nazwa, __name__ Kolekcja
miasta stan , __name__ Kolekcja
miasta kraj, populacja, __name__ 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 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 Kolekcja
miasta stan Kolekcja
miasta kraj Kolekcja
miasta kapitał Kolekcja
miasta populacja Kolekcja
miasta 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 in tworzyć zapytania równościowe 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 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 ). 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 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ć zbiór landmarks jednego 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:

  • 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 oceny 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 , w gwiazdkach Kolekcja
restauracje miasto, w gwiazdkach Kolekcja
restauracje kategoria , miasto , w gwiazdkach Kolekcja
restauracje kategoria , miasto , wybór redaktorów, arrow_upward ocena w Kolekcja

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 , w gwiazdkach Kolekcja
restauracje miasto, w gwiazdkach Kolekcja
restauracje w górę wybór redaktorów, w górę 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:

  • Liczba wpisów indeksu jednopolowego
  • Liczba wpisów indeksu złożonego

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:

  • Suma wielkości wpisów indeksu pojedynczego pola dokumentu
  • Suma wielkości złożonych pozycji indeksu 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.