NoSQL for Big Data

-- Create keyspace (like database)
CREATE KEYSPACE ecommerce 
WITH replication = {
  'class': 'NetworkTopologyStrategy',
  'datacenter1': 3,  -- 3 replicas in DC1
  'datacenter2': 2   -- 2 replicas in DC2
};

-- Create table (design for specific query!)
CREATE TABLE user_activity_by_date (
  user_id UUID,
  activity_date DATE,
  activity_time TIMESTAMP,
  action TEXT,
  details MAP<TEXT, TEXT>,
  PRIMARY KEY ((user_id, activity_date), activity_time)
) WITH CLUSTERING ORDER BY (activity_time DESC);

-- Insert (extremely fast, just append to log)
INSERT INTO user_activity_by_date (
  user_id, activity_date, activity_time, action, details
) VALUES (
  uuid(),
  '2024-01-15',
  toTimestamp(now()),
  'page_view',
  {'page': '/products', 'duration_sec': '45'}
);

-- Query by partition key (FAST, single partition)
SELECT * FROM user_activity_by_date
WHERE user_id = 550e8400-e29b-41d4-a716-446655440000
  AND activity_date = '2024-01-15'
LIMIT 100;

-- BAD: Query without partition key
SELECT * FROM user_activity_by_date
WHERE action = 'purchase';  -- Scans ALL partitions!

┌────────────────────────────────────────────────────┐
│              SHARDED CLUSTER                       │
├────────────────────────────────────────────────────┤
│                                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │  Shard 1     │  │  Shard 2     │  │  Shard 3  │ │
│  │ (Replica Set)│  │ (Replica Set)│  │(Replica...│ │
│  │              │  │              │  │           │ │
│  │ ┌──────────┐ │  │ ┌──────────┐ │  │┌─────────┐│ │
│  │ │ Primary  │ │  │ │ Primary  │ │  ││Primary  ││ │
│  │ └──────────┘ │  │ └──────────┘ │  │└─────────┘│ │
│  │ ┌──────────┐ │  │ ┌──────────┐ │  │┌─────────┐│ │
│  │ │Secondary │ │  │ │Secondary │ │  ││Secondary││ │
│  │ └──────────┘ │  │ └──────────┘ │  │└─────────┘│ │
│  └──────────────┘  └──────────────┘  └───────────┘ │
│         ▲                ▲                ▲        │
└─────────┼────────────────┼────────────────┼────────┘
          └────────────────┼────────────────┘
                           │
                    ┌──────▼──────┐
                    │   mongos    │
                    │  (Router)   │
                    └─────────────┘

// Insert documents with different structures
db.products.insertMany([
  {
    name: "Laptop",
    price: 999,
    specs: {cpu: "Intel i7", ram: "16GB"},
    tags: ["electronics", "computers"]
  },
  {
    name: "T-Shirt",
    price: 25,
    size: "L",
    color: "blue",
    tags: ["clothing"]
    // Different fields, no problem!
  }
]);

// Complex query with operators
db.products.find({
  price: { $gte: 100, $lte: 2000 },
  tags: { $in: ["electronics", "computers"] },
  "specs.ram": { $exists: true }
}).sort({ price: -1 }).limit(10);

// Analytics: Average price by category
db.products.aggregate([
  { $match: { price: { $gt: 0 } } },
  { $group: {
      _id: "$category",
      avgPrice: { $avg: "$price" },
      count: { $sum: 1 }
    }
  },
  { $sort: { avgPrice: -1 } }
]);

// Enable sharding on database
sh.enableSharding("ecommerce");

// Shard collection by user_id (hashed for even distribution)
sh.shardCollection(
  "ecommerce.orders",
  { user_id: "hashed" }
);

// Result: Orders distributed evenly across shards
// Queries for specific user_id route to single shard

┌───────────────────────────────────────────────────┐
│                 HBase CLUSTER                     │
├───────────────────────────────────────────────────┤
│                                                   │
│  ┌─────────────┐  ┌─────────────┐  ┌────────────┐ │
│  │RegionServer1│  │RegionServer2│  │RegionServer│ │
│  │             │  │             │  │            │ │
│  │ Region A    │  │ Region B    │  │ Region C   │ │
│  │ (rows 0-100)│  │(rows 101-200│  │(rows 201+) │ │
│  │             │  │             │  │            │ │
│  │  MemStore   │  │  MemStore   │  │ MemStore   │ │
│  │  HFile      │  │  HFile      │  │ HFile      │ │
│  └─────────────┘  └─────────────┘  └────────────┘ │
│         ▲                ▲                ▲       │
└─────────┼────────────────┼────────────────┼───────┘
          │                │                │
          └────────────────┼────────────────┘
                           │
                    ┌──────▼──────┐
                    │   Master    │
                    │ (metadata)  │
                    └─────────────┘
                           │
                   ┌───────▼────────┐
                   │    ZooKeeper   │
                   │ (coordination) │
                   └────────────────┘

# Create table with Column Families (CF)
create 'web_analytics',
  {NAME => 'user_info', VERSIONS => 3},
  {NAME => 'page_views', VERSIONS => 1}

# Key Strategy: Reverse Timestamp RowKey
# RowKey = [user_id] + [Long.MAX_VALUE - timestamp]

// Put data (Java API)
Put put = new Put(Bytes.toBytes("user123_99999984321")); // RowKey

// Column Family : Qualifier : Value
put.addColumn(CF_INFO, Bytes.toBytes("name"), Bytes.toBytes("Alice"));
put.addColumn(CF_VIEWS, Bytes.toBytes("/products"), Bytes.toBytes("5"));

table.put(put);

// Scan range of rows (user's recent activity)
Scan scan = new Scan();
scan.withStartRow(Bytes.toBytes("user123_999999999999000"));
scan.withStopRow(Bytes.toBytes("user123_999999999999999"));
scan.addFamily(Bytes.toBytes("page_views"));

ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
  // Process results
}

// Get multiple versions of a cell
Get get = new Get(Bytes.toBytes("user123"));
get.addColumn(Bytes.toBytes("user_info"), Bytes.toBytes("email"));
get.setMaxVersions(3);  // Get last 3 versions

Result result = table.get(get);
List<Cell> cells = result.getColumnCells(...);
// Returns 3 timestamped versions of email