Conditional expressions ($cond, $switch) in MongoDB - Step-by-Step Execution

Concept Flow - Conditional expressions ($cond, $switch)

Start

↓

$cond or $switch

↓

Evaluate condition

↓

Return ifTrue

↓

Output value

The $cond or $switch expression evaluates conditions and returns values based on which condition is true.

Execution Sample

MongoDB

db.collection.aggregate([
  { $project: {
      status: { $cond: { if: { $gte: ["$score", 60] }, then: "Pass", else: "Fail" } }
    }
  }
])

This query adds a 'status' field that shows 'Pass' if score is 60 or more, otherwise 'Fail'.

Execution Table

Step	Input Document	Condition ($gte score,60)	Condition Result	Value Returned	Output Document
1	{"name":"Alice","score":85}	85 >= 60	True	"Pass"	{"name":"Alice","score":85,"status":"Pass"}
2	{"name":"Bob","score":55}	55 >= 60	False	"Fail"	{"name":"Bob","score":55,"status":"Fail"}
3	{"name":"Carol","score":60}	60 >= 60	True	"Pass"	{"name":"Carol","score":60,"status":"Pass"}
4	No more documents	-	-	-	Aggregation ends

💡 All documents processed, aggregation completes.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
score	-	85	55	60	-
conditionResult	-	True	False	True	-
status	-	"Pass"	"Fail"	"Pass"	-

Key Moments - 3 Insights

Why does the condition use $gte and not just a simple comparison?

MongoDB aggregation expressions require operators like $gte to compare values inside documents, as shown in execution_table rows 1-3.

What happens if the condition is false in $cond?

The 'else' value is returned, as seen in execution_table row 2 where condition is false and 'Fail' is returned.

How does $switch differ from $cond?

$switch can check multiple conditions in order, returning the first true case, unlike $cond which checks only one condition (not shown in this table but conceptually similar).

Visual Quiz - 3 Questions

Look at the execution table, what is the 'status' value for the document with score 55?

A null

B "Pass"

C "Fail"

D "60"

💡 Hint

Check execution_table row 2 under 'Value Returned' and 'Output Document'.

At which step does the condition evaluate to True for the first time?

A Step 1

B Step 2

C Step 3

D No step

💡 Hint

Look at the 'Condition Result' column in execution_table rows 1-3.

If the condition was changed to $gt (greater than) 60, what would be the status for score 60?

A "Pass"

B "Fail"

C null

D Error

💡 Hint

Refer to variable_tracker for score 60 and condition logic; 60 > 60 is false.

Concept Snapshot

$cond syntax: { $cond: { if: <condition>, then: <trueValue>, else: <falseValue> } }
Evaluates condition; returns then if true, else if false.
$switch syntax: { $switch: { branches: [ { case: <cond>, then: <val> }, ... ], default: <val> } }
Checks multiple cases in order; returns first true then value or default.
Used in aggregation pipelines to create conditional fields.

Full Transcript

This visual execution trace shows how MongoDB's conditional expressions $cond and $switch work inside aggregation pipelines. The $cond expression evaluates a condition for each document, such as whether a score is greater than or equal to 60. If true, it returns one value; if false, another. The execution table walks through example documents with scores 85, 55, and 60, showing how the condition is evaluated and what output is produced. Variables like score, conditionResult, and status change as each document is processed. Key moments clarify why MongoDB uses operators like $gte and how $cond returns values based on condition results. The quiz tests understanding by asking about specific steps and outcomes. The snapshot summarizes the syntax and behavior of $cond and $switch for quick reference.

Practice

1. What does the $cond operator do in a MongoDB aggregation pipeline?

easy

A. It chooses a value based on a simple if-else condition.

B. It sorts documents by a field value.

C. It groups documents by a key.

D. It removes duplicate documents.

Solution

1. Step 1: Understand the purpose of $cond

   $cond is used to evaluate a condition and return one value if true, another if false, similar to if-else logic.

2. Step 2: Compare with other options

   Sorting, grouping, and removing duplicates are done by other operators like $sort, $group, and $addToSet, not $cond.

3. Final Answer:

   It chooses a value based on a simple if-else condition. -> Option A

4. Quick Check:

   $cond = if-else logic [OK]

Hint: Remember $cond is like a simple if-else choice [OK]

Common Mistakes:

• Confusing $cond with $group or $sort
• Thinking $cond filters documents
• Assuming $cond handles multiple cases like $switch

2. Which of the following is the correct syntax for using $cond in a MongoDB aggregation pipeline?

easy

A. { $cond: [ <condition>, <trueValue>, <falseValue> ] }

B. { $cond: { if: <condition>, then: <trueValue>, else: <falseValue> } }

C. { $cond: { case: <condition>, then: <trueValue>, else: <falseValue> } }

D. { $cond: { when: <condition>, then: <trueValue>, else: <falseValue> } }

Solution

1. Step 1: Recall $cond syntax

   The $cond operator uses an array with three elements: condition, true value, false value.

2. Step 2: Check options

   { $cond: [ <condition>, <trueValue>, <falseValue> ] } matches the correct array syntax. Options A, C, and D use incorrect keys or object format.

3. Final Answer:

   { $cond: [ <condition>, <trueValue>, <falseValue> ] } -> Option A

4. Quick Check:

   $cond syntax = array with 3 elements [OK]

Hint: Use array syntax: condition, true, false for $cond [OK]

Common Mistakes:

• Using object keys like if/then/else instead of array
• Confusing $cond with $switch syntax
• Missing one of the three required elements

3. Given the following aggregation stage, what will be the value of the field status for a document with score: 75?

{
  $addFields: {
    status: {
      $switch: {
        branches: [
          { case: { $gte: ["$score", 90] }, then: "Excellent" },
          { case: { $gte: ["$score", 70] }, then: "Good" },
          { case: { $gte: ["$score", 50] }, then: "Average" }
        ],
        default: "Poor"
      }
    }
  }
}

medium

A. "Poor"

B. "Excellent"

C. "Average"

D. "Good"

Solution

1. Step 1: Evaluate $switch branches in order

   The first branch checks if score >= 90 (75 >= 90? No). The second checks if score >= 70 (75 >= 70? Yes).

2. Step 2: Determine matching branch and output

   Since the second branch matches, the status is set to "Good". Later branches are ignored.

3. Final Answer:

   "Good" -> Option D

4. Quick Check:

   $switch picks first true case = "Good" [OK]

Hint: Check $switch branches top to bottom, pick first true [OK]

Common Mistakes:

• Ignoring order of branches in $switch
• Choosing default instead of matching branch
• Confusing $gte logic

4. Identify the issue in this aggregation expression using $switch:

{
  $project: {
    grade: {
      $switch: {
        branches: [
          { case: { $gt: ["$score", 90] }, then: "A" },
          { case: { $gt: ["$score", 80] }, then: "B" }
        ]
      }
    }
  }
}

medium

A. Branches array must be outside $switch object.

B. Missing default value in $switch returns null for unmatched cases.

C. Using $gt instead of $gte is invalid syntax.

D. The $project stage cannot use $switch.

Solution

1. Step 1: Check $switch structure

   $switch requires branches; default is optional but without it returns null when no branch matches.

2. Step 2: Identify missing default

   The expression lacks a default field, so if score <= 80, grade is null.

3. Final Answer:

   Missing default value in $switch returns null for unmatched cases. -> Option B

4. Quick Check:

   $switch missing default = null [OK]

Hint: Always include default in $switch to avoid errors [OK]

Common Mistakes:

• Omitting default field in $switch
• Thinking $gt is invalid syntax
• Misplacing branches array

5. You want to categorize products by price using $switch in an aggregation pipeline. Prices below 20 are "Cheap", 20 to 50 are "Moderate", above 50 are "Expensive". Which of the following $switch expressions correctly implements this?

hard

A. { $switch: { branches: [ { case: { $gte: ["$price", 50] }, then: "Expensive" }, { case: { $gte: ["$price", 20] }, then: "Moderate" }, { case: { $lt: ["$price", 20] }, then: "Cheap" } ], default: "Unknown" } }

B. { $switch: { branches: [ { case: { $lte: ["$price", 20] }, then: "Cheap" }, { case: { $lt: ["$price", 50] }, then: "Moderate" }, { case: { $gte: ["$price", 50] }, then: "Expensive" } ], default: "Unknown" } }

C. { $switch: { branches: [ { case: { $lt: ["$price", 20] }, then: "Cheap" }, { case: { $and: [ { $gte: ["$price", 20] }, { $lte: ["$price", 50] } ] }, then: "Moderate" }, { case: { $gt: ["$price", 50] }, then: "Expensive" } ], default: "Unknown" } }

D. { $switch: { branches: [ { case: { $gte: ["$price", 50] }, then: "Expensive" }, { case: { $lte: ["$price", 20] }, then: "Cheap" }, { case: { $and: [ { $gt: ["$price", 20] }, { $lt: ["$price", 50] } ] }, then: "Moderate" } ], default: "Unknown" } }

Solution

1. Step 1: Analyze price ranges and conditions

   Prices below 20 are "Cheap", 20 to 50 inclusive are "Moderate", above 50 are "Expensive". Conditions must be mutually exclusive and cover all cases.

2. Step 2: Check each option's logic

   { $switch: { branches: [ { case: { $lt: ["$price", 20] }, then: "Cheap" }, { case: { $and: [ { $gte: ["$price", 20] }, { $lte: ["$price", 50] } ] }, then: "Moderate" }, { case: { $gt: ["$price", 50] }, then: "Expensive" } ], default: "Unknown" } } correctly uses $lt for below 20, $and with $gte and $lte for 20 to 50, and $gt for above 50. Others have overlapping or incorrect ranges.

3. Final Answer:

   { $switch: { branches: [ { case: { $lt: ["$price", 20] }, then: "Cheap" }, { case: { $and: [ { $gte: ["$price", 20] }, { $lte: ["$price", 50] } ] }, then: "Moderate" }, { case: { $gt: ["$price", 50] }, then: "Expensive" } ], default: "Unknown" } } -> Option C

4. Quick Check:

   Use clear, non-overlapping conditions in $switch branches [OK]

Hint: Use clear, non-overlapping conditions with $and for ranges [OK]

Common Mistakes:

• Overlapping ranges causing wrong category
• Using incorrect comparison operators
• Not covering all price values