Jak działają indeksy B-tree w MongoDB
Prześledzą Państwo sposób przechowywania wpisów indeksu w strukturze B-tree przez MongoDB oraz sposób, w jaki optymalizator zapytań przemierza drzewo, aby spełnić warunek filtrowania.
Jak działają indeksy B-tree w MongoDB to bezpłatna lekcja MongoDB Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej MongoDB Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs MongoDB Academy zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Why Indexes Exist
Without an index, MongoDB must scan every document in a collection to satisfy a query—this is called a collection scan (COLLSCAN). On a collection with millions of documents, a COLLSCAN can take seconds or even minutes. An index is a separate, ordered data structure that lets MongoDB jump directly to the matching documents in microseconds.
The B-Tree Data Structure
MongoDB uses a B-tree (balanced tree) to store index entries. A B-tree is organised as a hierarchy of nodes: a root node at the top, internal nodes in the middle, and leaf nodes at the bottom. Every node holds multiple key-value pairs and pointers to child nodes. The tree stays balanced—all leaf nodes are at the same depth—so lookups always take the same number of steps regardless of which value you search for.
How Index Entries Are Stored
When you create an index on a field like age, MongoDB builds a B-tree where each leaf node entry contains the indexed field value paired with a pointer (the RecordId) to the actual document on disk. The entries are sorted in ascending or descending order based on how you define the index. Because the tree is sorted, MongoDB can satisfy equality lookups, range queries, and sort operations all from the same structure.
// Index on 'age' field
db.users.createIndex({ age: 1 });
// MongoDB now has a sorted B-tree:
// 18 -> RecordId(doc1)
// 25 -> RecordId(doc4)
// 31 -> RecordId(doc2)
// 47 -> RecordId(doc7)The Query Planner and IXSCAN
Every query passes through MongoDB's query planner, which evaluates available indexes and chooses the most efficient execution plan. When the planner finds a suitable index, it uses an IXSCAN (index scan) stage instead of a COLLSCAN. An IXSCAN traverses the B-tree from root to the matching leaf nodes, then fetches only the relevant documents from disk using their RecordId pointers.
// See which plan MongoDB chose
db.users.find({ age: { $gt: 30 } }).explain('executionStats');Equality, Range, and Sort Index Use
A B-tree index supports three types of access patterns: equality lookups (find the exact key), range scans (traverse contiguous leaf nodes between two bounds), and sort operations (the tree is already ordered, so no in-memory sort is needed). This triple capability makes a well-placed index dramatically more useful than it might first appear.
// Equality - single leaf node lookup
db.users.find({ username: 'alice' });
// Range - scan contiguous leaf nodes
db.users.find({ age: { $gte: 20, $lte: 30 } });
// Sort - traverses tree in order, no sort stage
db.users.find({}).sort({ age: 1 });Index Direction: Ascending vs Descending
When you create an index with 1 the entries are stored in ascending order; -1 stores them in descending order. For a single-field index, direction doesn't matter much because MongoDB can traverse the B-tree in either direction. Direction becomes critical in compound indexes where the combination of directions must match the sort order your queries use.
// Ascending index
db.orders.createIndex({ createdAt: 1 });
// Descending index (useful for 'newest first' sorts)
db.orders.createIndex({ createdAt: -1 });Index Size and Memory
MongoDB tries to keep the working set of indexes in RAM (the WiredTiger cache). When an index fits entirely in memory, lookups are essentially free I/O operations. When an index is too large for RAM, MongoDB must page index nodes in from disk, which causes latency spikes. This is why you should keep indexes lean—only index the fields you actually query, and use projection to avoid returning unused data.
// Check index sizes in bytes
db.users.stats().indexSizes;
// Example output:
// { '_id_': 856064, 'age_1': 442368 }Covered Queries
A covered query is one where all the fields in the filter and projection are present in the index. MongoDB can answer such a query using only the index B-tree—it never has to fetch the actual document from disk. Covered queries are extremely fast and are worth designing for on your hottest read paths.
// Index on email and name
db.users.createIndex({ email: 1, name: 1 });
// Covered query: filter on email, project email+name only
// MongoDB only reads the index, never the document
db.users.find(
{ email: 'a@b.com' },
{ _id: 0, email: 1, name: 1 }
);The _id Index Is Always Present
Every MongoDB collection automatically has a unique B-tree index on _id. This default index is why lookups by _id are always fast, even on enormous collections. You cannot drop the _id index. All other indexes are optional and must be created explicitly by the developer or DBA.
// MongoDB creates this automatically:
// { '_id': 1 } (unique)
// Fast because _id is always indexed:
db.orders.findOne({ _id: ObjectId('64a1f...') });Write Overhead of Indexes
Indexes speed up reads but slow down writes. Every insert, update, or delete must update not only the document on disk but also every B-tree that indexes a field on that document. A collection with 10 indexes incurs 10 extra B-tree writes per insert. This trade-off means you should only create indexes that serve real query patterns—zombie indexes that nobody uses still pay the write tax.
// List all indexes and their sizes
db.users.getIndexes();
// Identify unused indexes (MongoDB 4.4+)
// $indexStats shows usage counts since last restart
db.users.aggregate([{ $indexStats: {} }]);Multikey Indexes for Arrays
When you index a field that contains an array, MongoDB creates a multikey index—it inserts one B-tree entry per array element. This allows queries like { tags: 'mongodb' } to use the index even though tags is an array. MongoDB detects array fields automatically and sets the multikey flag; you don't need to do anything special when creating the index.
// Document with array field
// { title: 'Guide', tags: ['mongodb', 'nosql', 'database'] }
// Single index creation
db.articles.createIndex({ tags: 1 });
// MongoDB creates THREE B-tree entries:
// 'database' -> RecordId
// 'mongodb' -> RecordId
// 'nosql' -> RecordId
// This query now uses IXSCAN
db.articles.find({ tags: 'mongodb' });Quick Check
Test your understanding of MongoDB B-Tree indexes from this lesson.
Lesson Recap
In this lesson you learned: MongoDB uses B-tree structures where sorted leaf entries point to document RecordIds, the query planner chooses IXSCAN over COLLSCAN when a suitable index exists, and indexes accelerate reads but add write overhead. Next up we explore creating single-field and compound indexes.
Często zadawane pytania
Czy lekcja „Jak działają indeksy B-tree w MongoDB” jest bezpłatna?
Tak — pełny tekst „Jak działają indeksy B-tree w MongoDB” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu MongoDB Academy, przejdź na CoddyKit PRO. Kurs MongoDB Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Jak działają indeksy B-tree w MongoDB”?
Prześledzą Państwo sposób przechowywania wpisów indeksu w strukturze B-tree przez MongoDB oraz sposób, w jaki optymalizator zapytań przemierza drzewo, aby spełnić warunek filtrowania. Ćwiczysz MongoDB Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć MongoDB Academy?
Nie wymagamy żadnego doświadczenia. MongoDB Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Jak działają indeksy B-tree w MongoDB”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji MongoDB Academy?
Tak. Każda lekcja MongoDB Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Jak działają indeksy B-tree w MongoDB
- Tworzenie indeksów jedno- i wielopolowych
- Właściwości indeksów: unikalne, rzadkie, częściowe, TTL
- Odczytywanie danych wyjściowych explain() w celu diagnozowania zapytań