MongoDB Data Types & BSON Explained : Easy Guide from Beginner to Expert

MongoDB Data Types & BSON Format

A Super Fun, Easy, and Powerful Guide for Beginner to Expert Level

Imagine you are packing a magic backpack for a trip. You can put in toys, books, photos, numbers, maps, and even secret codes — all in one bag! MongoDB does the same with your data using BSON (Binary JSON). This tutorial explains MongoDB data types and BSON format in the simplest way but with deep insights for pros too. We’ll use:

  • Fun examples (like a student diary)
  • Real images (from MongoDB docs)
  • Beginner → Expert tips

Let’s open the magic backpack!


Part 1: What is BSON?

JSON vs BSON : The Magic Difference

JSON (Human-Readable) vs BSON (MongoDB’s Secret Code)

  • Text like a letter → JSON
  • Binary like a robot language → BSON
  • Slow to send → JSON
  • Super fast → BSON
  • No dates, no big numbers → JSON
  • Full support for all types → BSON
Here is the difference in tabular format:
JSON (Human-Readable) BSON (MongoDB’s Secret Code)
Text like a letter
Slow to send
No dates, no big numbers		 Binary like a robot language
Super fast
Full support for all types

Think of it like this:
JSON = Writing a postcard
BSON = Sending a high-speed encrypted video

MongoDB converts your data into BSON behind the scenes so it can store and fetch it super fast.

Why BSON is Awesome (For Experts)

  • Binary → 10x faster than JSON
  • Supports 32 data types (vs JSON’s 6)
  • Stores metadata like field order
  • Enables rich queries (e.g., find all dates in 2025)

Part 2: MongoDB Data Types – The Magic Items in Your Backpack

Let’s meet the 12 most important data types with real-life examples!

1. String – Words, Names, Messages

{
  "name": "Priya",
  "message": "I love coding!"
}

Like: Writing your name on a notebook
Use: Names, emails, comments

💡 Expert Tip: UTF-8 supported. Max 16MB per document.

2. Integer – Whole Numbers (32-bit & 64-bit)

{
  "age": 13,
  "score": 95
}

Like: Counting marbles

  • Int32 → -2.1 billion to 2.1 billion
  • Int64 → Much bigger (use for IDs, counters)
db.students.insertOne({ age: NumberInt(13) })     // 32-bit
db.students.insertOne({ age: NumberLong(9007199254740992) }) // 64-bit

3. Double – Decimal Numbers

{
  "height": 5.5,
  "temperature": 36.6
}

Like: Measuring height in feet
Use: Prices, ratings, GPS

{ "price": 19.99 }

4. Boolean – True or False

{
  "isStudent": true,
  "hasSubmitted": false
}

Like: Light switch: ON or OFF
Use: Flags, settings

5. Date – Time & Date

{ "birthday": ISODate("2012-05-15T00:00:00Z") }

Like: Marking your birthday on a calendar

db.events.insertOne({
  name: "Sports Day",
  date: new Date()  // Current time
})
Expert Insight: Stored as 64-bit integer (milliseconds since 1970). Perfect for sorting!

6. ObjectId – Unique ID (Auto-Generated)

{ "_id": ObjectId("671a3f1d8e4b2c1f9d5e7a2c") }

Like: A special sticker with a unique code on every toy

Structure (12 bytes):

  • Timestamp (4)
  • Machine ID (3)
  • Process ID (2)
  • Counter (3)

Why it’s cool: Globally unique, Time-ordered, No central ID server needed

7. Array – Lists of Anything!

{
  "hobbies": ["cricket", "drawing", "coding"],
  "scores": [95, 88, 100]
}

Like: A lunchbox with multiple snacks

db.students.find({ hobbies: "cricket" })
Expert: Use $all, $size, $elemMatch for advanced array queries.

8. Embedded Document – Data Inside Data

{
  "name": "Amit",
  "address": {
    "street": "MG Road",
    "city": "Delhi",
    "pin": 110001
  }
}

Like: A folder inside a folder

db.students.find({ "address.city": "Delhi" })
Pro Tip: Embedding = Fast reads. Normalize = Less duplication.

Real-World Example:

Using embedded documents is perfect for e-commerce orders:


{
  "orderId": 12345,
  "customer": {
    "name": "Priya",
    "email": "priya@example.com"
  },
  "items": [
    {"product": "Book", "qty": 2},
    {"product": "Pen", "qty": 5}
  ]
}

9. Null – Empty or Missing

{ "middleName": null }

Like: A blank space in a form

10. Binary Data – Photos, Files, Secrets

db.files.insertOne({
  name: "photo.jpg",
  data: BinData(0, "base64string...")
})

Like: Storing a real photo in your diary
Use Case: Thumbnails, encrypted data

11. Regular Expression – Pattern Search

db.users.find({ name: /^A/ })  // Names starting with A
db.users.find({ name: /kumar$/i })  // Ends with "kumar", case-insensitive

Like: Searching with wildcards

12. JavaScript Code – Store Functions (Rare!)

{ "func": { "$code": "function() { return 'Hi'; }" } }
⚠️ Warning: Not for production. Use with caution.

Part 3: BSON in Action – See the Magic!

Let’s insert a student and see how MongoDB stores it:

use school
db.students.insertOne({
  name: "Rohan",
  age: 13,
  height: 5.4,
  isActive: true,
  birthday: ISODate("2012-03-10"),
  hobbies: ["cricket", "music"],
  address: {
    city: "Mumbai",
    pin: 400001
  }
})

Behind the Scenes (BSON View)

MongoDB converts this to binary BSON:

\x16\x00\x00\x00           // Document length
  \x02 name: \x00 ...     // String
  \x10 age: \x0D\x00...   // 32-bit int
  \x01 height: ...        // Double
  \x08 isActive: \x01     // Boolean
  \x09 birthday: ...      // Date
  \x04 hobbies: ...       // Array
  \x03 address: ...       // Sub-document
\x00                       // End


Part 4: Data Type Cheat Sheet (Print & Stick!)

Type Example mongosh Syntax
String "Rohan" "Rohan"
Integer (32) 13 NumberInt(13)
Integer (64) 9007199254740992 NumberLong("...")
Double 5.5 5.5
Boolean true true
Date 2025-10-30 ISODate("2025-10-30")
ObjectId Auto-generated ObjectId()
Array ["a", "b"] ["a", "b"]
Embedded Doc { city: "Delhi" } { city: "Delhi" }
Null null null

Part 5: Common Mistakes & Fixes


Mistake Fix
Using 13 as string "13" Use numbers for math: age: 13
Storing dates as strings Use ISODate() for proper sorting
Forgetting NumberLong() for big nums Use NumberLong(1234567890123)
Arrays with mixed types Avoid! Keep types consistent

Part 6: Mini Project – Build a "Student Card"

db.cards.insertOne({
  _id: ObjectId(),
  name: "Sanya",
  rollNo: NumberInt(25),
  grade: 8.5,
  isPrefect: true,
  joinDate: ISODate("2024-04-01T00:00:00Z"),
  subjects: ["Math", "Science", "English"],
  marks: {
    math: 92,
    science: 88,
    english: 90
  },
  photo: BinData(0, "base64string..."),  // Optional
  notes: null
})

Now Query It!

// Find 8th graders with >90 in Math
db.cards.find({
  "marks.math": { $gt: 90 }
})

// Update grade
db.cards.updateOne(
  { name: "Sanya" },
  { $set: { grade: 8.7 } }
)

Try in Compass! See it as a beautiful card.


Try It Yourself:

Insert a new student with your own hobbies and query only students who like "music".


// Hint:
db.students.find({ hobbies: "music" })

Part 7: Tips for All Levels

For Beginners

  • Use Compass GUI to see types visually
  • Practice with insertOne() and find()
  • Make a "Game Inventory" with arrays

For Medium Learners

Use schema validation to enforce types:

db.createCollection("students", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age"],
      properties: {
        name: { bsonType: "string" },
        age: { bsonType: "int" }
      }
    }
  }
})

For Experts

  • Use BSON type checking in drivers
  • Optimize with partial indexes on specific types
  • Use Decimal128 for money: 
    { price: NumberDecimal("19.99") }

Final Words

You now know:

  • BSON = MongoDB’s super-fast binary format
  • 12+ data types = From strings to photos
  • How to store, query, and master data like a pro!

Fun Learned: Infinite


Your Mission:

use myBackpack
db.items.insertOne({
  name: "Magic Wand",
  power: 9000,
  isLegendary: true,
  discovered: new Date()
})

You’re now a MongoDB Data Wizard!

Frequently Asked Questions (FAQ)

1. What is BSON in MongoDB?

BSON (Binary JSON) is MongoDB’s binary format for storing data. It extends JSON by supporting additional data types like Date, ObjectId, and Binary, making storage and querying faster and more flexible.

2. Why does MongoDB use BSON instead of JSON?

MongoDB uses BSON because it’s faster and more efficient than JSON. It supports rich data types, preserves field order, and allows quick encoding/decoding for large-scale operations.

3. What are the most common MongoDB data types?

The most commonly used MongoDB data types include String, Integer, Double, Boolean, Date, ObjectId, Array, and Embedded Documents.

4. What is the difference between Int32, Int64, and Double in MongoDB?

Int32 and Int64 store whole numbers with 32-bit and 64-bit precision respectively. Double stores floating-point numbers (decimals) using IEEE-754 format. Use Int32 for small counters, Int64 for large IDs, and Double for measurements or prices.

5. How can I view BSON data in human-readable format?

MongoDB automatically converts BSON to JSON when displaying data in tools like mongosh or Compass. You can also use tojson() in the shell to see readable JSON output.

6. What is ObjectId and how is it generated?

ObjectId is a 12-byte unique identifier generated automatically by MongoDB. It includes a timestamp, machine ID, process ID, and a counter — ensuring global uniqueness and time ordering.

7. When should I use Embedded Documents vs References?

Use Embedded Documents when data is frequently read together (e.g., user profile with address). Use References when data is large or shared across documents (e.g., users referencing a separate roles collection).

8. What is Decimal128 and when should I use it?

Decimal128 is a high-precision numeric type used for financial or scientific data. Use it for currency, measurements, or when precision beyond Double is required.

9. What are common mistakes beginners make with MongoDB data types?

  • Storing numbers as strings (e.g., "13" instead of 13).
  • Using string dates instead of ISODate().
  • Mixing data types in arrays.
  • Ignoring NumberLong() for large integers.

10. How can I practice MongoDB data types easily?

Use the MongoDB Atlas free tier or Compass GUI to create collections, insert sample documents, and explore BSON structure visually.

Resources:

Keep packing your magic backpack!

💡 Have questions? Drop a comment below!

← Previous Next →
-
Labels: , , , , , , , , , , , ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)

Featured Post

Creating Your First MongoDB Database and Collection (Step-by-Step Tutorial)

Creating Your First MongoDB Database and Collection A Super Fun, Step-by-Step Adventure for Beginner to Expert Level What is MongoDB? ...

Popular Posts