Boolean and null types in MongoDB - Step-by-Step Execution

Concept Flow - Boolean and null types

Start with a document

↓

Add Boolean field

↓

Add null field

↓

Insert document into collection

↓

Query documents

↓

Check Boolean and null values

↓

Return matching documents

This flow shows how a MongoDB document with Boolean and null fields is created, inserted, and queried to check their values.

Execution Sample

MongoDB

db.users.insertOne({"active": true, "lastLogin": null});
db.users.find({"active": true});

Insert a document with Boolean and null fields, then query documents where active is true.

Execution Table

Step	Action	Document State	Query Condition	Result
1	Create document	{"active": true, "lastLogin": null}
2	Insert document into users collection	{"active": true, "lastLogin": null}		Document inserted
3	Query documents where active is true		{"active": true}	Returns document with active:true, lastLogin:null
4	Query documents where lastLogin is null		{"lastLogin": null}	Returns document with active:true, lastLogin:null
5	Query documents where active is false		{"active": false}	Returns no documents
6	Query documents where lastLogin is not null		{"lastLogin": {"$ne": null}}	Returns no documents

💡 No more queries; all relevant documents returned

Variable Tracker

Variable	Start	After Insert	After Query 1	After Query 2	Final
Document	{}	{"active": true, "lastLogin": null}	{"active": true, "lastLogin": null}	{"active": true, "lastLogin": null}	No change
Query Result	[]	[]	[{"active": true, "lastLogin": null}]	[{"active": true, "lastLogin": null}]	[{"active": true, "lastLogin": null}]

Key Moments - 3 Insights

Why does querying with {"lastLogin": null} return documents where lastLogin is explicitly null?

Because in MongoDB, querying with a field equal to null matches documents where the field value is null or the field does not exist. Here, the field exists and is null, so it matches (see execution_table row 4).

Why does querying with {"active": false} return no documents?

Because the inserted document has active set to true, so no documents match active false (see execution_table row 5).

What is the difference between querying {"lastLogin": null} and {"lastLogin": {"$ne": null}}?

The first matches documents where lastLogin is null or missing; the second matches documents where lastLogin is not null. Since lastLogin is null in the document, the first query returns it, the second does not (see execution_table rows 4 and 6).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does the query {"active": true} return?

A Documents where active is false

B Documents where active is true

C Documents where active is null

D No documents

💡 Hint

Check the Result column at step 3 in execution_table

At which step does the query return no documents because the condition is false?

A Step 5

B Step 4

C Step 3

D Step 2

💡 Hint

Look for 'Returns no documents' in the Result column

If the document had "active": false, how would the result at step 3 change?

A It would return the document

B It would return documents with lastLogin null

C It would return no documents

D It would cause an error

💡 Hint

Refer to variable_tracker and execution_table step 3 and 5 for active field values

Concept Snapshot

Boolean and null types in MongoDB:
- Boolean fields store true or false values.
- Null fields explicitly store no value.
- Querying {field: null} matches documents where field is null or missing.
- Querying {field: {$ne: null}} matches documents where field is not null.
- Use Boolean fields to track true/false states clearly.

Full Transcript

This visual execution shows how MongoDB handles Boolean and null types in documents. We start by creating a document with a Boolean field 'active' set to true and a null field 'lastLogin'. We insert this document into the 'users' collection. Then, we run queries to find documents where 'active' is true, which returns our document, and where 'lastLogin' is null, which also returns it. Queries for 'active' false or 'lastLogin' not null return no documents because our document does not match those conditions. The key points are that Boolean fields store true or false, null fields store no value, and querying with null matches fields that are null or missing. This helps beginners understand how to store and query Boolean and null values in MongoDB.

Practice

1. What does the Boolean type represent in MongoDB?

easy

A. Text strings

B. Numbers only

C. True or false values

D. Dates and times

Solution

1. Step 1: Understand Boolean type meaning

   Boolean type stores only two possible values: true or false.

2. Step 2: Compare with other data types

   Numbers, strings, and dates are different types, not Boolean.

3. Final Answer:

   True or false values -> Option C

4. Quick Check:

   Boolean = true/false [OK]

Hint: Boolean means true or false only [OK]

Common Mistakes:

• Confusing Boolean with numbers
• Thinking Boolean stores text
• Mixing Boolean with date types

2. Which of the following is the correct way to store a null value in a MongoDB document?

easy

A. { "field": "null" }

B. { "field": false }

C. { "field": 0 }

D. { "field": null }

Solution

1. Step 1: Identify null value syntax

   In MongoDB, null is stored as the keyword null without quotes.

2. Step 2: Check other options

   "null" is a string, 0 is a number, false is Boolean, so they are incorrect.

3. Final Answer:

   { "field": null } -> Option D

4. Quick Check:

   Null stored as null keyword [OK]

Hint: Use null without quotes for null values [OK]

Common Mistakes:

• Using "null" as a string instead of null
• Confusing 0 or false with null
• Putting null in quotes

3. Given the MongoDB collection documents:

{ "active": true }, { "active": false }, { "active": null }

What will the query db.collection.find({ "active": { $eq: null } }) return?

medium

A. Documents where active is true

B. Documents where active is null

C. Documents where active is false

D. No documents

Solution

1. Step 1: Understand $eq: null behavior

   In MongoDB, querying with { field: { $eq: null } } matches documents where field exists and is exactly null. It does not match missing fields.

2. Step 2: Apply to given documents

   Only the document with "active": null matches; documents with true or false do not.

3. Final Answer:

   Documents where active is null -> Option B

4. Quick Check:

   $eq: null matches existing null [OK]

Hint: $eq: null matches existing null fields [OK]

Common Mistakes:

• Thinking $eq: null matches missing fields
• Confusing false or true as null
• Expecting no results

4. You wrote this MongoDB query to find documents where isActive is false:

db.users.find({ isActive: False })

But it returns an error. What is the problem?

medium

A. Boolean false must be lowercase: false

B. Field name should be in quotes

C. Use $eq operator for Boolean

D. MongoDB does not support Boolean queries

Solution

1. Step 1: Check Boolean syntax in MongoDB queries

   Boolean values in MongoDB queries must be lowercase: true or false.

2. Step 2: Identify error cause

   Using capitalized False causes a syntax error because it's not recognized.

3. Final Answer:

   Boolean false must be lowercase: false -> Option A

4. Quick Check:

   Boolean literals are lowercase in queries [OK]

Hint: Use lowercase true/false in queries [OK]

Common Mistakes:

• Using capitalized True or False
• Omitting quotes on field names (allowed but not error)
• Thinking $eq is required for Boolean

5. You want to find documents where the field verified is either false or null. Which MongoDB query correctly finds these documents?

hard

A. { verified: { $in: [false, null] } }

B. { verified: false }

C. { verified: { $ne: true } }

D. { verified: { $exists: false } }

Solution

1. Step 1: Understand the requirement

   We want documents where verified is false OR null.

2. Step 2: Analyze each option

   { verified: false } matches only false, not null. { verified: { $ne: true } } matches existing fields != true (false, null, other values), but not missing fields and includes unwanted values. { verified: { $exists: false } } matches only missing, not false. { verified: { $in: [false, null] } } uses $in to match false or null exactly.

3. Final Answer:

   { verified: { $in: [false, null] } } -> Option A

4. Quick Check:

   $in matches multiple values including null [OK]

Hint: Use $in with false and null to match both [OK]

Common Mistakes:

• Using only false without null
• Using $exists which misses false
• Using $ne: true which matches unwanted values