MongoDB.

MongoDB is a document-oriented NoSQL database. It stores each record as a flexible, JSON-like document in BSON, short for Binary JSON. Documents live in collections instead of tables.

Its key features are:

• A flexible schema, so documents in one collection can have different structures.
• A rich query language with complex queries, indexes and an aggregation pipeline.
• High availability through replica sets, which keep copies of the data and fail over automatically.
• Horizontal scaling through built-in sharding, which spreads data across many servers.
• GridFS for storing large files.
• Multi-document ACID transactions, which make several writes succeed or fail together.

SQL databases store data in tables with a fixed schema and join tables at query time. NoSQL databases such as MongoDB drop the fixed schema and store data in other shapes, like documents, so related data can live together.

Choose MongoDB when the data is semi-structured or changes shape often, and when documents match the objects in your code. That match speeds up development, which suits fast-moving projects such as modern web applications. MongoDB also suits applications that must scale horizontally.

A relational database stays the better fit when most queries join many tables. SQL databases also have a mature ecosystem of tools.

BSON, short for Binary JSON, is the binary format MongoDB uses to store documents and to send them over the network. It looks like JSON when you read it in the shell, but it is encoded as bytes and supports more types.

How it differs from JSON:

• JSON is text, while BSON is binary.
• BSON adds types that JSON lacks, such as ObjectId, Date and binary data.
• BSON is faster to parse and easier to traverse.
• BSON can take more space than the same JSON, because it stores extra metadata.

These values use BSON types that plain JSON cannot express.

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

MongoDB organizes data in three levels: a database holds collections, and a collection holds documents.

• A database is the top-level container for collections. MongoDB comes with the admin, local and config databases. By default, all databases keep their files in one data directory, and the directoryPerDB setting gives each database its own directory.
• A collection is a group of documents, like a table in a relational database. Its documents can have different schemas. MongoDB creates a collection when you insert its first document.
• A document is one record, a JSON-like structure stored as BSON, a binary form of JSON. It can hold nested documents and arrays, and it can be at most 16MB.

The diagram below shows an 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}

An ObjectId is a 12-byte value that MongoDB uses as the default _id of a document. If you insert a document without an _id, one is generated for you.

It is written as 24 hex characters and has three parts.

• 4 bytes: a timestamp in seconds since the Unix epoch, which is January 1, 1970.
• 5 bytes: a random value generated once per process.
• 3 bytes: a counter that starts at a random value and increments.

Because the timestamp comes first, ObjectIds sort by creation time to the second, and getTimestamp() returns that time. They are likely unique across machines, but uniqueness is not guaranteed.

// ObjectId example
ObjectId("507f1f77bcf86cd799439011")

// Extract timestamp
ObjectId("507f1f77bcf86cd799439011").getTimestamp()
// Returns: ISODate("2012-10-17T21:13:27Z")

CRUD operations in MongoDB are the collection methods that create, read, update and delete documents. Each one has a form for one document and a form for many.

To create documents, insertOne() adds one document, and insertMany() takes an array and inserts each document in it. MongoDB adds an _id to any document that has none.

db.users.insertOne({name: "John", age: 30})
db.users.insertMany([
  {name: "Alice", age: 25},
  {name: "Bob", age: 35}
])

To read, find() returns a cursor over the matching documents, and with no filter it matches every document. findOne() returns the first match or null. A filter such as {age: {$gte: 25}} uses query operators.

db.users.find()
db.users.find({age: {$gte: 25}})
db.users.findOne({name: "John"})

To update, updateOne() changes the first match and updateMany() changes every match. Each takes a filter and an update document, and update operators such as $set change only the fields they name.

db.users.updateOne(
  {name: "John"}, 
  {$set: {age: 31}}
)
db.users.updateMany(
  {age: {$lt: 30}}, 
  {$set: {status: "young"}}
)

To delete, deleteOne() removes the first match and deleteMany() removes every match.

db.users.deleteOne({name: "John"})
db.users.deleteMany({age: {$lt: 18}})

find() returns a cursor over every matching document, while findOne() returns the first matching document itself, or null when nothing matches.

• A cursor is lazy. Documents load in batches as you iterate, so find() can walk a large result without holding it all in memory.
• You can chain cursor methods onto find(), such as sort(), limit() and skip().
• findOne() runs at once and returns a plain document, so it has no cursor methods to chain.
• When several documents match, findOne() returns the first one it reaches. With a collection scan, that is the first in natural order, the order MongoDB stored them in. With an index scan, it is the first entry in the index.

Use findOne() to fetch one document by a unique field, and find() to read a list.

// 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)
}