MongoDB is a document-oriented NoSQL database that stores data in flexible, JSON-like documents called BSON (Binary JSON). Key features include:

• Document-based storage: Data is stored in documents rather than rows and columns
• Schema flexibility: Documents in a collection can have different structures
• Horizontal scalability: Built-in support for sharding across multiple servers
• Rich query language: Supports complex queries, indexing, and aggregation
• High availability: Replica sets provide automatic failover
• GridFS: For storing large files
• ACID transactions: Support for multi-document transactions

SQL Databases:

• Structured data with predefined schema
• ACID compliance
• Vertical scaling
• Complex joins
• Mature ecosystem

NoSQL Databases (MongoDB):

• Flexible schema design
• Horizontal scaling
• Better performance for certain use cases
• Document-based storage matches application objects
• Easier development for modern applications

Choose MongoDB when:

• You need flexible schema
• Rapid development cycles
• Horizontal scaling requirements
• Working with semi-structured data
• Building modern web applications

BSON (Binary JSON) is the binary representation of JSON-like documents that MongoDB uses internally.

Key differences:

• Storage: BSON is binary, JSON is text
• Data types: BSON supports additional types like ObjectId, Date, Binary
• Performance: BSON is faster to parse and process
• Size: BSON can be larger due to additional metadata
• Traversal: BSON allows efficient traversal of documents

Example BSON types not in JSON:

{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  created: ISODate("2023-01-01T12:00:00Z"),
  data: BinData(0, "SGVsbG8gV29ybGQ=")
}

MongoDB organizes data in a three-level hierarchy:

Database: Top-level container for collections

• Contains multiple collections
• Each database has its own files on disk
• Default databases: admin, local, config

Collection: Group of MongoDB documents

• Equivalent to a table in RDBMS
• Documents in a collection can have different schemas
• Collections are created automatically when first document is inserted

Document: Individual record in a collection

• JSON-like structure stored as BSON
• Can contain nested documents and arrays
• Maximum size: 16MB

Example structure:

Database: ecommerce
├── Collection: users
│   ├── Document: {_id: 1, name: "John", email: "john@email.com"}
│   └── Document: {_id: 2, name: "Jane", age: 25, city: "NYC"}
└── Collection: products
    └── Document: {_id: 1, title: "Laptop", price: 999.99}

ObjectId is a 12-byte unique identifier used as the default value for the _id field.

Structure (24 hex characters):

• 4 bytes: Unix timestamp
• 5 bytes: Random unique value
• 3 bytes: Incrementing counter

Properties:

• Automatically generated if not provided
• Contains creation timestamp
• Globally unique across machines
• Sortable by creation time

// ObjectId example
ObjectId("507f1f77bcf86cd799439011")

// Extract timestamp
ObjectId("507f1f77bcf86cd799439011").getTimestamp()
// Returns: ISODate("2012-10-17T20:46:47Z")

Create:

// Insert one document
db.users.insertOne({name: "John", age: 30})

// Insert multiple documents
db.users.insertMany([
  {name: "Alice", age: 25},
  {name: "Bob", age: 35}
])

Read:

// Find all documents
db.users.find()

// Find with criteria
db.users.find({age: {$gte: 25}})

// Find one document
db.users.findOne({name: "John"})

Update:

// Update one document
db.users.updateOne(
  {name: "John"}, 
  {$set: {age: 31}}
)

// Update multiple documents
db.users.updateMany(
  {age: {$lt: 30}}, 
  {$set: {status: "young"}}
)

Delete:

// Delete one document
db.users.deleteOne({name: "John"})

// Delete multiple documents
db.users.deleteMany({age: {$lt: 18}})

find():

• Returns a cursor to all matching documents
• Returns multiple documents
• Lazy evaluation - documents loaded as needed
• Can be chained with other methods

findOne():

• Returns the first matching document
• Returns a single document object or null
• Immediately executes and returns result
• Cannot be chained with cursor methods

// find() - returns cursor
const cursor = db.users.find({age: {$gte: 25}})
cursor.forEach(doc => print(doc.name))

// findOne() - returns document
const user = db.users.findOne({email: "john@email.com"})
if (user) {
  print(user.name)
}