Join us in person and online for Firebase Summit on October 18, 2022. Learn how Firebase can help you accelerate app development, release your app with confidence, and scale with ease. Register now

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, z których korzysta Cloud Firestore : indeksy jednopolowe i indeksy złożone .

Indeks za każdym zapytaniem

Jeśli dla zapytania nie istnieje indeks, większość baz danych przeszukuje ich zawartość element po elemencie, co jest powolnym procesem, który spowalnia jeszcze bardziej wraz ze wzrostem bazy danych. Cloud Firestore gwarantuje wysoką wydajność zapytań, wykorzystując indeksy do 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. Gdy używasz i testujesz swoją aplikację, Cloud Firestore pomaga identyfikować i tworzyć dodatkowe indeksy , których wymaga Twoja aplikacja.

Rodzaje indeksów

Cloud Firestore używa dwóch typów indeksów: jednopolowych i złożonych . 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ądzasz, konfigurując ustawienia automatycznego indeksowania bazy danych i wykluczenia indeksów.

Automatyczne indeksowanie

Domyślnie Cloud Firestore automatycznie utrzymuje indeksy jednopolowe 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 niebędącego tablicą ani pola niemapowego 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 indeks rosnący o zakresie kolekcji i jeden indeks malejący dla każdego podpola niebędącego tablicą ani nie będącego mapą na mapie.

  • Dla każdego pola tablicy w dokumencie Cloud Firestore tworzy i utrzymuje indeks tablica o zasięgu kolekcji.

  • Indeksy jednopolowe z zakresem grupy kolekcji nie są domyślnie obsługiwane.

Zwolnienia indeksu jednopolowego

Możesz wykluczyć pole z ustawień automatycznego indeksowania , tworząc wykluczenie indeksu pojedynczego pola. Wykluczenie z indeksowania zastępuje automatyczne ustawienia indeksu dotyczące całej bazy danych. Wyłączenie może włączyć indeks jednopolowy, który w przeciwnym razie ustawienia automatycznego indeksowania wyłączyłyby lub dezaktywowały indeks jednopolowy, który w przeciwnym razie włączyłby 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, podpola mapy odziedziczą te ustawienia. Można jednak zdefiniować wyłączenia indeksu jednopolowego dla określonych podpól. Jeśli usuniesz wykluczenie dla podpola, podpole odziedziczy ustawienia wykluczeń swojego elementu nadrzędnego, jeśli takie istnieją, lub ustawienia dotyczące całej bazy danych, jeśli nie istnieją 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 zindeksowania.

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, za pomocą którego możesz utworzyć brakujący indeks. Dzieje się tak za każdym razem, gdy próbujesz wykonać zapytanie, które nie jest obsługiwane przez indeks. Indeksy złożone można również definiować i zarządzać nimi ręcznie, korzystając z konsoli lub interfejsu wiersza polecenia Firebase . Aby uzyskać więcej informacji na temat tworzenia i zarządzania indeksami złożonymi, 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 indeksowania

Definiując indeks, należy wybrać tryb indeksowania dla każdego indeksowanego pola. Tryb indeksu każdego pola obsługuje określone klauzule zapytania w tym polu. Do wyboru są następujące tryby indeksu:

Tryb indeksu Opis
Rosnąco Obsługuje < , <= , == , >= , > , != , in i not-in , klauzule zapytań w polu i obsługuje sortowanie wyników w kolejności rosnącej na podstawie tej wartości 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 tej wartości pola.
Tablica zawiera Obsługuje array-contains i array-contains-any klauzule zapytania w polu.

Zakresy zapytań

Każdy indeks jest objęty zakresem kolekcji lub grupy 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 jednej kolekcji.

Zakres grupy kolekcji
Grupa kolekcji obejmuje wszystkie kolekcje o tym samym identyfikatorze kolekcji. Aby uruchomić zapytanie grupy kolekcji, które zwraca przefiltrowane lub uporządkowane wyniki z grupy kolekcji, należy utworzyć odpowiedni indeks o zakresie grupy kolekcji.

Przykład indeksowania

Dzięki automatycznemu tworzeniu dla Ciebie 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ń na podstawie wartości pól i komparatorów < , <= , == , >= , > i in . W przypadku pól tablicowych umożliwiają wykonywanie zapytań array-contains tablicę i array-contains-any zapytania.

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 jednopolowy na każde pole nietablicowe, jeden malejący indeks jednopolowy na każde pole nietablicowe i jeden indeks jednopolowy zawiera tablicę dla pola tablicowego. Każdy wiersz w poniższej tabeli reprezentuje wpis w indeksie jednopolowym:

Kolekcja Pole indeksowane Zakres zapytania
miasta nazwa Kolekcja
miasta stan Kolekcja
miasta kraj Kolekcja
miasta capital Kolekcja
miasta populacja Kolekcja
miasta nazwa Kolekcja
miasta stan w dół Kolekcja
miasta kraj Kolekcja
miasta kapitał 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:

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 równości ( == ):

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 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 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żna użyć dla tego pola trybu indeksu rosnącego lub malejącego. Domyślnie klauzule nierówności stosują rosnąco porządek sortowania na podstawie pola w klauzuli nierówności.

Kolekcja Zindeksowane pola 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 Zindeksowane pola Zakres zapytania
miasta kraj, populacja Kolekcja
miasta country , populacja Kolekcja

Należy również utworzyć indeks złożony, aby połączyć zapytanie array-contains tablicę lub array-contains-any zapytanie 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
miasta array-contains tags, (lub ) capital Kolekcja

Zapytania obsługiwane przez indeksy grup kolekcji

Aby zademonstrować indeks z zakresem grupy kolekcji, wyobraź sobie, że dodajesz 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" });

Używając następującego indeksu jednopolowego z zakresem kolekcji, możesz wykonać zapytanie do kolekcji landmarks jednego miasta na podstawie pola category :

Kolekcja Zindeksowane pola Zakres zapytania
punkty orientacyjne (lub ) kategoria Kolekcja
Sieć
citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])

Teraz wyobraź sobie, że interesuje Cię wyszukiwanie punktów orientacyjnych we wszystkich miastach. Aby uruchomić to zapytanie w grupie kolekcji składającej się ze wszystkich kolekcji landmarks , należy włączyć indeks landmarks o zakresie grupy kolekcji:

Kolekcja Zindeksowane pola Zakres zapytania
punkty orientacyjne (lub ) kategoria 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 uruchomić zapytanie 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żesz uruchomić następującą kwerendę grupy kolekcji bez włączania dodatkowego indeksu:

Sieć
db.collectionGroup("landmarks").get()

Wpisy indeksu

Skonfigurowane indeksy projektu i struktura dokumentu określają liczbę wpisów indeksu dla dokumentu. Wpisy indeksu wliczają się do limitu liczby wpisów indeksu .

Poniższy przykład 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 ARRAY
  • nazwa_miasta DESC, dzielnice ARRAY

Wpisy indeksu

Ta konfiguracja indeksowania skutkuje następującymi 18 wpisami indeksu dla dokumentu:

Indeks Zindeksowane dane
Wpisy indeksu jednopolowego
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”
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 ARRAY city_name: "San Francisco", dzielnice: "Misja"
nazwa_miasta ASC, dzielnice ARRAY city_name: "San Francisco", dzielnice: "Śródmieście"
nazwa_miasta ASC, dzielnice ARRAY city_name: "San Francisco", dzielnice: "Marina"
nazwa_miasta DESC, dzielnice ARRAY city_name: "San Francisco", dzielnice: "Misja"
nazwa_miasta DESC, dzielnice ARRAY city_name: "San Francisco", dzielnice: "Śródmieście"
nazwa_miasta DESC, dzielnice ARRAY 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 Index entry size .

Korzystanie ze scalania 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 użyć istniejących indeksów. Cloud Firestore może scalać indeksy w celu uzyskania prostych filtrów równości, aby zbudować indeksy złożone potrzebne do większych zapytań o równość.

Koszty indeksowania można zmniejszyć, identyfikując sytuacje, w których można skorzystać ze scalania indeksów. Na przykład wyobraź sobie kolekcję restaurants dla aplikacji do oceniania restauracji:

  • restauracje

    • burgerthyme

      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 rosnąco według star_rating :

Sieć
db.collection("restaurants").where("category", "==", "burgers")
                            .orderBy("star_rating")

db.collection("restaurants").where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==" "San Francisco")
                            .where("editors_pick", "==", true )
                            .orderBy("star_rating")

Możesz utworzyć indeks dla każdego zapytania:

Kolekcja Zindeksowane pola Zakres zapytania
restauracje kategoria, Kolekcja
restauracje city, Kolekcja
restauracje category, city, Kolekcja
restauracje kategoria, miasto, editors_pick, Kolekcja

Lepszym rozwiązaniem jest zmniejszenie liczby indeksów, korzystając z możliwości łączenia przez Cloud Firestore indeksów pod kątem klauzul równości:

Kolekcja Zindeksowane pola Zakres zapytania
restauracje kategoria, Kolekcja
restauracje city, Kolekcja
restauracje editors_pick, 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

W przypadku indeksów obowiązują następujące ograniczenia. Aby zapoznać się z wszystkimi przydziałami i limitami, zobacz Przydziały i limity .

Limit Detale
Maksymalna liczba indeksów złożonych dla bazy danych 200
Maksymalna liczba konfiguracji jednopolowych dla bazy danych

200

Dozwolonych jest łącznie 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 w tym samym polu liczą się jako konfiguracja jednego pola w ramach limitu.

Maksymalna liczba wpisów indeksu dla każdego dokumentu

40 000

Liczba wpisów w indeksie jest sumą następujących wartości dla dokumentu:

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

Aby zobaczyć, jak Cloud Firestore przekształca dokument i zestaw indeksów we wpisy indeksu, zobacz ten 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 to suma następujących elementów dla dokumentu:

  • Suma wielkości jednopolowych wpisów indeksu dokumentu
  • Suma rozmiaru złożonych wpisów indeksu dokumentu
  • Maksymalny rozmiar indeksowanej wartości pola

    1500 bajtów

    Wartości pól powyżej 1500 bajtów są obcinane. Zapytania zawierające obcięte wartości pól mogą zwracać niespójne wyniki.

    Najlepsze praktyki w zakresie indeksowania

    W przypadku większości aplikacji możesz polegać na automatycznym indeksowaniu i linkach do komunikatów o błędach, aby zarządzać indeksami. Możesz jednak chcieć dodać wyjątki jednopolowe w następujących przypadkach:

    Sprawa Opis
    Duże pola tekstowe

    Jeśli masz pole ciągu, które często zawiera długie wartości ciągu, 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 wartościami sekwencyjnymi

    W przypadku indeksowania pola, które sekwencyjnie zwiększa się lub zmniejsza między dokumentami w kolekcji, na przykład znacznik czasu, maksymalna szybkość zapisu w kolekcji wynosi 500 zapisów na sekundę. Jeśli nie wykonujesz zapytania na podstawie pola z wartościami sekwencyjnymi, możesz wykluczyć 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 (czasu wygaśnięcia) , pamiętaj, że pole TTL musi być sygnaturą czasową. Indeksowanie w polach TTL jest domyślnie włączone i może wpływać na wydajność przy wyższych natężeniach ruchu. Najlepszym rozwiązaniem jest dodanie wyjątków jednopolowych dla pól TTL.

    Duża tablica lub pola 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, należy wyłączyć je z indeksowania.