$size operator for array length in MongoDB - Deep Dive

Overview - $size operator for array length

What is it?

The $size operator in MongoDB is used to find the number of elements in an array. It helps you check how many items are inside an array field in your documents. This operator is useful when you want to filter or work with documents based on the length of their arrays.

Why it matters

Without the $size operator, it would be hard to query documents based on how many items they have in an array. For example, if you want to find users with exactly three hobbies, you would have to fetch all data and count manually, which is slow and inefficient. $size makes this fast and easy, improving performance and accuracy.

Where it fits

Before learning $size, you should understand basic MongoDB queries and how arrays are stored in documents. After mastering $size, you can learn about other array operators like $elemMatch and aggregation pipeline stages that manipulate arrays.

Mental Model

Core Idea

$size counts how many items are inside an array field in a MongoDB document.

Think of it like...

Imagine a box filled with toys. $size is like counting how many toys are inside the box without opening it fully.

Document Example:
{
  name: "Alice",
  hobbies: ["reading", "swimming", "coding"]
}

Query with $size:
{ hobbies: { $size: 3 } }

Result: Matches documents where hobbies array has exactly 3 items.

Build-Up - 6 Steps

1

Foundation

Understanding Arrays in MongoDB

Concept: Learn what arrays are and how they are stored in MongoDB documents.

In MongoDB, an array is a list of values stored inside a single field of a document. For example, a user document might have a field called 'hobbies' that holds multiple hobbies as an array: ["reading", "swimming", "coding"]. Arrays can hold any data type, including strings, numbers, or even other documents.

Result

You can store multiple related values together inside one field in a document.

Knowing how arrays are stored helps you understand why counting their length is a common need.

2

Foundation

Basic MongoDB Query Structure

Concept: Understand how to write simple queries to find documents based on field values.

A MongoDB query looks like { field: value } and finds documents where the field matches the value. For example, { name: "Alice" } finds documents where the name is Alice. Queries can also check array contents, but counting array length needs a special operator.

Result

You can find documents by matching exact values or array contents.

Mastering basic queries is essential before using special operators like $size.

3

Intermediate

Using $size to Match Array Length

🤔Before reading on: do you think $size can find arrays with at least a certain length, or only exact length? Commit to your answer.

Concept: $size matches documents where the array has exactly the specified number of elements.

To find documents where an array field has a specific length, use { arrayField: { $size: number } }. For example, { hobbies: { $size: 3 } } finds documents where the hobbies array has exactly 3 items. It does not match arrays with more or fewer items.

Result

Only documents with arrays of the exact length specified are returned.

Understanding that $size matches exact lengths prevents confusion when queries return no results.

4

Intermediate

Combining $size with Other Query Operators

🤔Before reading on: can $size be combined with range queries like $gt or $lt directly? Commit to your answer.

Concept: $size works only for exact length matching and cannot be combined directly with range operators in a query filter.

You cannot write { hobbies: { $size: { $gt: 2 } } } to find arrays longer than 2. Instead, use aggregation with $expr and $size or $where for complex conditions. $size is limited to exact matches in normal queries.

Result

Trying to combine $size with range operators in a query filter causes errors or no matches.

Knowing $size's limitation helps you choose the right tool for array length conditions.

5

Advanced

Using $size in Aggregation Pipelines

🤔Before reading on: do you think $size can be used inside aggregation expressions to compute array lengths? Commit to your answer.

Concept: In aggregation pipelines, $size can be used as an expression to calculate array length dynamically for each document.

Inside aggregation stages like $project or $match with $expr, you can use { $size: "$arrayField" } to get the length of an array. For example, {$project: { hobbyCount: { $size: "$hobbies" } }} adds a field with the number of hobbies. This allows filtering or transforming data based on array length.

Result

You can compute and use array lengths dynamically in aggregation results.

Using $size in aggregation unlocks powerful data transformations beyond simple queries.

6

Expert

Performance Considerations and Indexing

🤔Before reading on: does using $size in queries benefit from indexes on array fields? Commit to your answer.

Concept: Queries using $size do not use indexes efficiently because they require scanning array lengths, which is not indexed directly.

MongoDB indexes do not store array length information, so queries with $size often result in collection scans or index scans without length filtering. For large collections, this can slow queries. To optimize, consider storing array length as a separate field and indexing it for fast queries.

Result

Using $size in queries on large datasets can be slow without additional design.

Knowing $size's performance limits helps design schemas and indexes for scalable applications.

Under the Hood

$size works by checking the internal array length metadata stored with each document's array field. When a query uses $size, MongoDB compares the requested length with the stored length of the array in each document. However, this length is not indexed separately, so MongoDB must scan documents or indexes to evaluate the condition.

Why designed this way?

MongoDB stores arrays as BSON arrays inside documents with length metadata for quick access. $size was designed to leverage this metadata for exact length matching. Range queries on array length were not included in basic queries to keep query execution simple and efficient. More complex length conditions are handled in aggregation pipelines.

┌─────────────┐
│ MongoDB Doc │
│ {          │
│  hobbies:  │
│  [a,b,c]   │
│  length=3 │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Query:      │
│ { hobbies:  │
│   { $size:3 }}
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Compare doc │
│ length=3 ?  │
│ size=3      │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Match or    │
│ skip doc    │
└─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does $size match arrays with length greater than the number specified? Commit to yes or no.

Common Belief: Many think $size matches arrays with length greater than or equal to the number given.

Reality: $size matches only arrays with exactly the specified length, not greater or smaller.

Why it matters: Assuming $size matches ranges causes queries to return no results or wrong results, leading to confusion and wasted debugging time.

Quick: Can $size be used with $gt or $lt directly in a query filter? Commit to yes or no.

Common Belief: Some believe you can combine $size with range operators like $gt in a normal query filter.

Reality: $size cannot be combined with range operators directly; it only accepts a number for exact matching.

Why it matters: Trying to combine them causes query errors or unexpected behavior, blocking complex array length queries.

Quick: Does using $size in queries automatically use indexes on array fields? Commit to yes or no.

Common Belief: Many assume $size queries benefit from indexes on the array field for fast lookup.

Reality: $size queries do not use indexes efficiently because array length is not indexed separately.

Why it matters: Ignoring this leads to slow queries on large collections and poor application performance.

Quick: Is $size available only in queries, or also in aggregation pipelines? Commit to your answer.

Common Belief: Some think $size is only for queries and cannot be used in aggregation pipelines.

Reality: $size is available as an expression in aggregation pipelines to compute array lengths dynamically.

Why it matters: Missing this limits the ability to perform advanced data transformations and filtering based on array length.

Expert Zone

1

Using $size in aggregation pipelines allows dynamic computation of array lengths, enabling complex filtering and projections not possible in simple queries.

2

Storing array length as a separate field and indexing it can dramatically improve performance for length-based queries on large datasets.

3

$size does not work with sparse arrays or arrays with null elements differently; it counts all elements regardless of content.

When NOT to use

Avoid using $size for range-based array length queries in normal filters; instead, use aggregation with $expr and $size or store array length in a separate field for indexing. Also, do not rely on $size for performance-critical queries on large collections without proper indexing strategies.

Production Patterns

In production, developers often store array lengths in separate fields updated by application logic or database triggers to enable fast queries. $size is used in aggregation pipelines for reporting and analytics to compute array sizes on the fly. It is also combined with $match and $project stages to filter and reshape data based on array length.

Connections

Array Length in Programming Languages

Similar concept of counting elements in an array or list.

Understanding how arrays work in programming helps grasp why counting elements is a common operation in databases too.

SQL COUNT() Function

Both count elements, but SQL counts rows or grouped items, while $size counts elements inside a single document's array.

Knowing SQL aggregation helps understand MongoDB's approach to counting within documents versus across rows.

Inventory Management Systems

Counting items in stock is like counting array elements in a document field.

Real-world inventory counting parallels how $size counts items, showing the practical need for such operations.

Common Pitfalls

#1 Trying to find documents with arrays longer than a number using $size directly.

Wrong approach:

{ hobbies: { $size: { $gt: 2 } } }

Correct approach:

{ $expr: { $gt: [ { $size: "$hobbies" }, 2 ] } }

Root cause:

Misunderstanding that $size accepts only a number for exact matching, not an expression or operator.

#2 Expecting $size queries to be fast on large collections without indexing.

Wrong approach:

db.collection.find({ hobbies: { $size: 5 } }) on a large unindexed collection expecting quick results.

Correct approach:

Store array length in a separate field, index it, and query that field for performance.

Root cause:

Assuming $size uses indexes on arrays, ignoring MongoDB's indexing limitations.

#3 Using $size to find arrays with at least a certain length in a normal query.

Wrong approach:

{ hobbies: { $size: 3 } } expecting to match arrays with 3 or more elements.

Correct approach:

Use aggregation with $expr and $size to filter arrays by length ranges.

Root cause:

Confusing exact match behavior of $size with range queries.

Key Takeaways

$size counts the exact number of elements in an array field in MongoDB documents.

It only matches arrays with the exact length specified, not ranges or minimum lengths.

$size cannot be combined with range operators in normal queries but can be used in aggregation pipelines for dynamic length calculations.

Queries using $size do not benefit from indexes on array fields, so performance can suffer on large datasets without schema design adjustments.

Storing array length separately and using aggregation pipelines are common patterns to overcome $size limitations in production.