MongoDB Basics

What is MongoDB?

MongoDB is a popular NoSQL database that stores data in flexible, JSON-like documents. It's designed for scalability and performance with features like horizontal scaling and rich queries.

Features of MongoDB

• Document-oriented storage (BSON format)
• Full index support
• Replication and high availability
• Auto-sharding for horizontal scaling
• Rich query language

SQL vs NoSQL

Document Structure

{
  "_id": ObjectId("5f8d..."),
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "New York"
  },
  "hobbies": ["reading", "hiking"]
}

Inserting Documents

// Insert single document
db.users.insertOne({
  name: "Alice",
  age: 25,
  status: "active"
})

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

Viewing Documents

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

// Pretty print results
db.users.find().pretty()

Basic Queries

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

// Find with projection (select fields)
db.users.find({}, {name: 1, age: 1})

// Find one document
db.users.findOne({age: {$gt: 25}})

Comparison Operators

// $eq, $ne, $gt, $lt, $gte, $lte, $in
db.users.find({age: {$gt: 25}})
db.users.find({status: {$in: ["active", "pending"]}})

Logical Operators

// $and, $or, $not
db.users.find({
  $and: [
    {age: {$gt: 25}},
    {status: "active"}
  ]
})

db.users.find({
  $or: [
    {status: "active"},
    {status: "pending"}
  ]
})

Querying Embedded Documents

// Query nested fields
db.users.find({"address.city": "New York"})

// Query array elements
db.users.find({hobbies: "reading"})

Insert

// Insert single
db.users.insertOne({
  name: "David",
  age: 40
})

// Insert multiple
db.users.insertMany([
  {name: "Eve", age: 28},
  {name: "Frank", age: 32}
])

Update

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

// Update many documents
db.users.updateMany(
  {status: "active"},
  {$inc: {score: 5}}
)

Delete

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

// Delete many documents
db.users.deleteMany({status: "inactive"})

Basic Types

• String - UTF-8 text
• Number - Integer (32/64-bit) or Double
• Boolean - true/false
• Date - Timestamp
• Null - Null value

Complex Types

• Array - Ordered list of values
• Object - Embedded document
• ObjectId - Unique identifier (12-byte)
• Binary data - For storing binary

Example Document

{
  _id: ObjectId("..."),
  name: "John",
  age: 30,
  active: true,
  joined: ISODate("2023-01-15"),
  address: {
    city: "New York"
  },
  tags: ["staff", "admin"]
}

Why Indexes?

Indexes support efficient query execution by organizing data to minimize the number of documents MongoDB needs to scan.

Creating Indexes

// Single field index
db.users.createIndex({name: 1}) // 1 for ascending

// Compound index
db.users.createIndex({name: 1, age: -1})

// Text index for search
db.articles.createIndex({content: "text"})

Index Types

• Single Field - On a single field
• Compound - On multiple fields
• Multikey - For array fields
• Text - For text search
• Geospatial - For location data

Viewing Indexes

// List all indexes
db.users.getIndexes()

// Get index size
db.users.totalIndexSize()

What is Aggregation?

The aggregation framework processes data records and returns computed results through a pipeline of operations.

Basic Pipeline Stages

// Simple aggregation
db.orders.aggregate([
  { $match: { status: "completed" } },
  { $group: { 
      _id: "$customer", 
      total: { $sum: "$amount" } 
    } 
  },
  { $sort: { total: -1 } }
])

Common Stages

• $match - Filter documents
• $group - Group by expression
• $sort - Sort documents
• $project - Reshape documents
• $limit - Limit number of documents
• $skip - Skip documents
• $unwind - Deconstruct array

Aggregation Operators

• $sum, $avg, $min, $max
• $push, $addToSet
• $first, $last

Role-Based Access Control

// Create user with roles
db.createUser({
  user: "admin",
  pwd: "password123",
  roles: ["readWrite", "dbAdmin"]
})

// Create custom role
db.createRole({
  role: "readOnly",
  privileges: [
    { resource: { db: "mydb", collection: "" }, 
      actions: ["find"] }
  ],
  roles: []
})

Security Practices

• Enable authentication in mongod.conf
• Use strong passwords
• Limit network exposure
• Implement TLS/SSL encryption
• Regularly update MongoDB

Network Access Control

# In mongod.conf
net:
  bindIp: 127.0.0.1  # Only local connections
  port: 27017
security:
  authorization: enabled

Node.js (Mongoose)

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/mydb');

const userSchema = new mongoose.Schema({
  name: String,
  age: Number
});

const User = mongoose.model('User', userSchema);

Python (PyMongo)

from pymongo import MongoClient
client = MongoClient('localhost', 27017)
db = client.mydb

# Insert document
db.users.insert_one({
  'name': 'Alice',
  'age': 25
})

Java

MongoClient client = new MongoClient();
MongoDatabase db = client.getDatabase("mydb");

// Find documents
MongoCollection users = db.getCollection("users");
FindIterable result = users.find();

What is Atlas?

MongoDB Atlas is a fully-managed cloud database service that handles deployment, scaling, and management of MongoDB.

Key Features

• Automated provisioning and scaling
• Backups and point-in-time recovery
• Performance optimization
• Security features
• Global clusters

Getting Started

1. Sign up for free tier at mongodb.com/atlas
2. Create a cluster (M0 free tier available)
3. Set up network access and database user
4. Connect using connection string

Connection String

mongodb+srv://username:password@cluster0.mongodb.net/mydb

mongodump/mongorestore

# Backup a database
mongodump --db mydb --out /backup/

# Restore a database
mongorestore --db mydb /backup/mydb/

mongoexport/mongoimport

# Export to JSON
mongoexport --db mydb --collection users --out users.json

# Export to CSV
mongoexport --db mydb --collection users --type=csv --fields name,age --out users.csv

# Import from JSON
mongoimport --db mydb --collection users --file users.json