Nosql Database Design

NoSQL Database Design

Table of Contents

• Overview
• When to Use
• Quick Start
• Reference Guides
• Best Practices

Overview

Design scalable NoSQL schemas for MongoDB (document) and DynamoDB (key-value). Covers data modeling patterns, denormalization strategies, and query optimization for NoSQL systems.

When to Use

• MongoDB collection design
• DynamoDB table and index design
• Document structure modeling
• Embedding vs. referencing decisions
• Query pattern optimization
• NoSQL indexing strategies
• Data denormalization planning

Quick Start

Minimal working example:

// Single document with embedded arrays
db.createCollection("users");

db.users.insertOne({
  _id: ObjectId("..."),
  email: "john@example.com",
  name: "John Doe",
  createdAt: new Date(),

  // Embedded address
  address: {
    street: "123 Main St",
    city: "New York",
    state: "NY",
    zipCode: "10001",
  },

  // Embedded array of items
  orders: [
    {
      orderId: ObjectId("..."),
      date: new Date(),
      total: 149.99,
    },
    {
// ... (see reference guides for full implementation)

Reference Guides

Detailed implementations in the references/ directory:

Best Practices

✅ DO

• Follow established patterns and conventions
• Write clean, maintainable code
• Add appropriate documentation
• Test thoroughly before deploying

❌ DON'T

• Skip testing or validation
• Ignore error handling
• Hard-code configuration values

Document Structure Design

Document Structure Design

MongoDB - Embedded Documents:

// Single document with embedded arrays
db.createCollection("users");

db.users.insertOne({
  _id: ObjectId("..."),
  email: "john@example.com",
  name: "John Doe",
  createdAt: new Date(),

  // Embedded address
  address: {
    street: "123 Main St",
    city: "New York",
    state: "NY",
    zipCode: "10001",
  },

  // Embedded array of items
  orders: [
    {
      orderId: ObjectId("..."),
      date: new Date(),
      total: 149.99,
    },
    {
      orderId: ObjectId("..."),
      date: new Date(),
      total: 89.99,
    },
  ],
});

MongoDB - Referenced Documents:

// Separate collections with references
db.createCollection("users");
db.createCollection("orders");

db.users.insertOne({
  _id: ObjectId("..."),
  email: "john@example.com",
  name: "John Doe",
});

db.orders.insertMany([
  {
    _id: ObjectId("..."),
    userId: ObjectId("..."), // Reference to user
    orderDate: new Date(),
    total: 149.99,
  },
  {
    _id: ObjectId("..."),
    userId: ObjectId("..."),
    orderDate: new Date(),
    total: 89.99,
  },
]);

// Query with $lookup for JOINs
db.orders.aggregate([
  {
    $match: { userId: ObjectId("...") },
  },
  {
    $lookup: {
      from: "users",
      localField: "userId",
      foreignField: "_id",
      as: "user",
    },
  },
]);

DynamoDB Item Operations

DynamoDB Item Operations

// Put item (insert/update)
const putParams = {
  TableName: "users",
  Item: {
    userId: { S: "user-123" },
    email: { S: "john@example.com" },
    name: { S: "John Doe" },
    createdAt: { N: Date.now().toString() },
    metadata: {
      M: {
        joinDate: { N: Date.now().toString() },
        source: { S: "web" },
      },
    },
  },
};

// Query using GSI
const queryParams = {
  TableName: "users",
  IndexName: "emailIndex",
  KeyConditionExpression: "email = :email",
  ExpressionAttributeValues: {
    ":email": { S: "john@example.com" },
  },
};

// Batch get items
const batchGetParams = {
  RequestItems: {
    users: {
      Keys: [{ userId: { S: "user-123" } }, { userId: { S: "user-456" } }],
    },
  },
};

Global Secondary Indexes (GSI)

Global Secondary Indexes (GSI)

// Add GSI for querying by email
const gsiParams = {
  TableName: "users",
  AttributeDefinitions: [{ AttributeName: "email", AttributeType: "S" }],
  GlobalSecondaryIndexes: [
    {
      IndexName: "emailIndex",
      KeySchema: [{ AttributeName: "email", KeyType: "HASH" }],
      Projection: {
        ProjectionType: "ALL", // Return all attributes
      },
      BillingMode: "PAY_PER_REQUEST",
    },
  ],
};

// GSI with composite key for time-based queries
const timeIndexParams = {
  GlobalSecondaryIndexes: [
    {
      IndexName: "userCreatedIndex",
      KeySchema: [
        { AttributeName: "userId", KeyType: "HASH" },
        { AttributeName: "createdAt", KeyType: "RANGE" },
      ],
      Projection: { ProjectionType: "ALL" },
      BillingMode: "PAY_PER_REQUEST",
    },
  ],
};

Indexing in MongoDB

Indexing in MongoDB

// Single field index
db.users.createIndex({ email: 1 });
db.orders.createIndex({ createdAt: -1 });

// Compound index
db.orders.createIndex({ userId: 1, createdAt: -1 });

// Text index for search
db.products.createIndex({ name: "text", description: "text" });

// Geospatial index
db.stores.createIndex({ location: "2dsphere" });

// TTL index for auto-expiration
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

// Sparse index (only documents with field)
db.users.createIndex({ phone: 1 }, { sparse: true });

// Check index usage
db.users.aggregate([{ $indexStats: {} }]);

Schema Validation

Schema Validation

// Define collection validation schema
db.createCollection("products", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "price", "category"],
      properties: {
        _id: { bsonType: "objectId" },
        name: {
          bsonType: "string",
          description: "Product name (required)",
        },
        price: {
          bsonType: "decimal",
          minimum: 0,
          description: "Price must be positive",
        },
        category: {
          enum: ["electronics", "clothing", "food"],
          description: "Category must be one of listed values",
        },
        tags: {
          bsonType: "array",
          items: { bsonType: "string" },
        },
        createdAt: {
          bsonType: "date",
        },
      },
    },
  },
});

Table Structure

Table Structure

// DynamoDB table with single primary key
const TableName = "users";
const params = {
  TableName,
  KeySchema: [
    { AttributeName: "userId", KeyType: "HASH" }, // Partition key
  ],
  AttributeDefinitions: [
    { AttributeName: "userId", AttributeType: "S" }, // String
  ],
  BillingMode: "PAY_PER_REQUEST", // On-demand
};

// DynamoDB table with composite primary key
const ordersParams = {
  TableName: "orders",
  KeySchema: [
    { AttributeName: "userId", KeyType: "HASH" }, // Partition key
    { AttributeName: "orderId", KeyType: "RANGE" }, // Sort key
  ],
  AttributeDefinitions: [
    { AttributeName: "userId", AttributeType: "S" },
    { AttributeName: "orderId", AttributeType: "S" },
  ],
  BillingMode: "PAY_PER_REQUEST",
};