MongoDB字段顺序是否影响集合扫描（Collscan）查询耗时？字段名拼写错误引发查询变慢的底层机制问询

Great catch on the performance impact of typos in field names—this is a really interesting edge case that ties into how MongoDB handles document storage and query execution. Let’s break down each of your questions:

1. How does MongoDB store documents in memory? #

MongoDB parses BSON documents into an in-memory structure that acts like a hash table (or more accurately, a dictionary/associative array) rather than a linked list. Each field name maps directly to its value via a hash-based lookup, which allows for O(1) average time complexity to access specific fields. Linked lists would be far too slow for frequent field lookups, so this hash-table-like structure is critical for efficient document manipulation and querying.

2. Does MongoDB read the entire BSON document when querying only specific fields (without indexes)? #

Unfortunately, no—when you run a query like col.find({some_field: "asdf"}, {some_field: 1}) without any indexes, MongoDB has to perform a collection scan (Collscan). During a Collscan, MongoDB reads entire documents from disk into memory first. Once the document is in memory, it parses the BSON and extracts only the fields specified in your projection.

The reason it can’t skip straight to the target field on disk is that BSON documents are stored as contiguous binary blobs. There’s no built-in offset table for individual fields in the on-disk storage, so MongoDB can’t jump directly to some_field without reading the full document first. The projection happens after the document is loaded and parsed.

3. Do typos in field names force MongoDB to read the entire document and increase Collscan time? #

Yes, and here’s why:

• When your query uses a correct field name, MongoDB can parse the in-memory document, look up the field via its hash table structure, and quickly confirm if it matches the query condition (or extract it for projection). Once it finds the field, it doesn’t need to process the rest of the document’s fields for that check.
• When you use a misspelled field name, MongoDB has to scan through all fields in the document to confirm that the misspelled field doesn’t exist. Since it never finds the field, it ends up parsing every single field in every document during the Collscan. This extra work per document adds up, leading to noticeably longer query times compared to using the correct field name.

Even though MongoDB reads the full document from disk in both cases, the in-memory parsing work is significantly higher when dealing with a non-existent field (due to a typo), which is why you see that performance hit.

内容的提问来源于stack exchange，提问作者Robert