Learning MongoDB - Core Concepts & MongoDB Data Structure

#Introduction

In episode 1 you understood why MongoDB exists and when exactly to use it. Now it's time to go to the heart of the system: how MongoDB organizes and stores data. Without understanding this structure, you'll write queries that happen to work but never really understand what's happening behind the scenes.

Episode 2 is the most important technical foundation in the entire series. The roadmap: first we map the data hierarchy from database to field, second we dissect the BSON format along with the rich data types it supports, and third we unravel the mystery of _id and the ObjectId — the identity marker of every document. By the end of the episode, you'll be able to clearly imagine how a single document takes shape inside a MongoDB server.

#MongoDB Data Structure Hierarchy

If you're used to RDBMS, the easiest way to understand MongoDB is through analogy. MongoDB has four hierarchy levels:

The big difference is at the Document vs Row level: a row in an RDBMS must have a column structure identical to other rows, while a document in MongoDB may have a different structure. And more importantly — a Collection doesn't need to be declared in advance. You can write directly to a new collection and MongoDB will create it automatically.

#Database

A database is the top-level container. One MongoDB server can hold many databases. You can see the list with show dbs, and switch to or enter a database with use:

use belajar
show dbs
db

db displays the name of the currently active database. An important note: a new database won't appear in show dbs until the first document is written to it — this is MongoDB's signature "lazy creation" behavior.

#Collection and Document

A Collection is a group of documents, analogous to a table. But unlike a table, a collection has no fixed schema. A Document is the smallest data unit actually stored — analogous to a row, but in the form of a flexible JSON structure. To see the existing collections:

show collections
db.users.countDocuments()

The countDocuments function counts the number of documents in a collection. You'll use this function often for quick checks.

#The BSON Data Format

#What Is BSON?

MongoDB doesn't store documents as JSON text, but as BSON (Binary JSON) — an encoded binary representation of JSON. Why binary? There are three main reasons:

• Storage efficiency and speed: binary data is smaller and faster to process than text.
• Rich data types: pure JSON only knows strings, numbers, booleans, null, arrays, and objects. BSON adds types like Date, Decimal128, Binary, ObjectId, and UUID.
• Traversal speed: BSON can be "skipped" field by field without having to parse the entire document, making cross-field queries very fast.

When you write queries in mongosh, you're indeed typing JSON-like syntax — but behind the scenes, everything is converted to BSON before being stored. Here are the main BSON data types you need to know:

#Types Needing Special Attention

Two BSON types most often cause bugs in the field:

NumberDecimal — for money, never use Double. The floating-point calculation 0.1 + 0.2 yields 0.30000000000000004. For monetary values, use NumberDecimal:

db.products.insertOne({ name: "Tas", price: NumberDecimal("99.99") })
db.products.findOne()

ISODate — dates in MongoDB are always stored in UTC. When you insert ISODate("2026-08-03T00:00:00Z"), MongoDB stores it in UTC; conversion to local time zones happens on the application side.

#The _id Field and ObjectId

#The Golden Rule: Every Document Has an _id

Every MongoDB document must have a _id field that is unique within the collection. Two important rules:

• If you don't provide an _id at insert time, MongoDB automatically creates one as an ObjectId.
• If you provide your own _id, its value can be anything (string, integer, UUID) as long as it's unique in the collection.

db.users.insertOne({ _id: "user-001", name: "Arman" })
db.users.insertOne({ name: "Budi" })
db.users.find()

Result: the first document has _id: "user-001" as you set it, and the second document gets an automatic ObjectId _id.

#Anatomy of the 12-Byte ObjectId

ObjectId is the default type for _id. It's 12 bytes long, composed of three parts, each with its own meaning:

Because it contains a timestamp, you can extract the document's creation time directly from the _id without storing a separate createdAt field:

db.users.findOne()._id.getTimestamp()

The timestamp + random + counter combination makes the ObjectId unique without needing server-to-server communication — this is important for distributed systems where many servers can create documents simultaneously without collisions.

#Practice: Building Your First Data Structure

Now let's apply all the concepts in one real example. We'll create a users collection with a document that leverages rich BSON types:

db.users.insertOne({
  name: "Arman Dwi Pangestu",
  age: NumberInt(27),
  email: "arman@example.com",
  balance: NumberDecimal("2500.50"),
  isActive: true,
  registeredAt: ISODate("2026-08-03T08:30:00Z"),
  tags: ["backend", "mongodb"],
  address: {
    city: "Jakarta",
    country: "Indonesia"
  }
})

Notice the combination of types inside a single document: string, Int32, Decimal128, boolean, Date, array, and embedded document — all coexisting naturally. This is something that isn't nearly as easy to do in an RDBMS.

#Conclusion

In episode 2 you understood MongoDB's data hierarchy: a Database contains Collections (analogous to tables), which contain Documents (analogous to rows) that hold Fields (analogous to columns). You also got to know the BSON format and the rich data types within it — including NumberDecimal for money and ISODate for time — and understood _id as the mandatory identity of every document, with the 12-byte ObjectId composed of a timestamp, random value, and counter.

Key takeaways:

• MongoDB hierarchy: Database > Collection > Document > Field.
• Collections are created automatically when the first document is written; no declaration needed.
• BSON is the binary format that gives MongoDB rich data types.
• Use NumberDecimal for money, Double for ordinary calculations.
• Every document must have a unique _id; the default 12-byte ObjectId carries a timestamp.

In the next episode, episode 3, we start touching real operations: Create & Read Operations. You'll write insertOne, insertMany, and bulkWrite to store data, then retrieve it back with find, findOne, and projection to control which fields are returned. See you in episode 3, and get ready to write your first data to MongoDB!