Overview of Document Databases

Document databases, also called document stores, are designed to store semi-structured data in document format. They allow creating and updating programs without referring to a master schema, making them ideal for content management and mobile applications.

MongoDB: JSON in Binary Format

MongoDB is a document-oriented NoSQL database created by 10gen in 2007. It uses BSON (Binary JSON), which is the binary representation of JSON that supports document storage and data interchange.

Key Features of MongoDB

• BSON Format: Stores data in BSON (Binary JSON) for efficient storage and retrieval
• Collection-based: Documents are grouped into collections based on their structure
• Dynamic Schemas: No need to predefine schema structure
• High Performance: No joins or transactions means faster access and better performance
• Replica Sets: Primary-secondary replication for high availability and backup
• Sharding: Horizontal scaling through data sharding across servers
• Rich Query Language: MongoDB Query Language (MQL) replaces SQL for document queries

MongoDB Architecture Example

{
  "_id": ObjectId("507f1f77bcf86cd799439011"),
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com",
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "country": "USA"
  }
}

CouchDB: Native JSON with HTTP/REST

CouchDB is an Apache Software Foundation product that uses native JSON format and HTTP protocol. It's designed for ease of use and runs on Erlang, supporting JavaScript and Map/Reduce for data processing.

Key Features of CouchDB

• Native JSON: Stores data in pure JSON format (not BSON)
• HTTP/REST API: Intuitive RESTful interface for all operations
• MVCC: Multi-Version Concurrency Control for consistency
• Master-Master Replication: Bidirectional synchronization between nodes
• Mobile Support: Runs on Android and iOS devices
• Lock-free: No database locking during writes
• ACID Compliance: Atomic, Consistent, Isolated, Durable transactions
• Eventual Consistency: AP model (Availability and Partition tolerance)

CouchDB Architecture Example

{
  "_id": "507f1f77bcf86cd799439011",
  "_rev": "1-abc123def456",
  "name": "John Doe",
  "age": 30,
  "email": "john@example.com",
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "country": "USA"
  }
}

Comparison: MongoDB vs CouchDB

Query Differences: Pre-defined vs Dynamic

One of the biggest differences between CouchDB and MongoDB lies in how they handle queries:

CouchDB: Pre-defined Views

CouchDB requires pre-defined views created with JavaScript MapReduce functions. You must create views before querying.

// Define a view function
function(doc) {
  if(doc.type == "parking_ticket" && doc.officer == "Micheal Jordan") {
    emit(doc._id, doc);
  }
}

// Query via HTTP GET
GET /parking_tickets/_design/by_officer/_view/officer_jordan

MongoDB: Dynamic Queries

MongoDB supports dynamic queries similar to traditional databases. You can query any field at runtime.

// Dynamic query in MongoDB
db.parking_tickets.find({
  officer: "Micheal Jordan",
  location: "189 Berkely Road"
})

// Equivalent to SQL:
// SELECT * FROM parking_tickets 
// WHERE officer = 'Micheal Jordan' AND location = '189 Berkely Road'

When to Use MongoDB

When to Use CouchDB

JSON Document Structure Comparison

Both databases store JSON documents but with slight differences:

{
  "_id": ObjectId(...),
  "name": "Document",
  "data": { ... }
}

{
  "_id": "uuid",
  "_rev": "1-abc123",
  "name": "Document",
  "data": { ... }
}

Conclusion

Both MongoDB and CouchDB are excellent document-based NoSQL databases that handle JSON data efficiently. The choice between them depends on your specific requirements:

• Performance and Scale: Choose MongoDB for maximum throughput and rapid growth
• Mobile and Replication: Choose CouchDB for mobile support and master-master replication
• Query Flexibility: Choose MongoDB if you need dynamic, SQL-like queries
• RESTful Interface: Choose CouchDB if you prefer HTTP/REST APIs
• Consistency Model: Choose MongoDB for strong consistency, CouchDB for eventual consistency

MongoDB is generally easier for developers coming from SQL backgrounds due to its query language similarity. CouchDB excels in scenarios requiring mobile support and bidirectional replication. Both databases support JSON natively, making them ideal choices for modern web applications using JSON APIs.