Database Sharding & Replication

import hashlib

def get_shard(user_id: int, num_shards: int = 3) -> int:
    # user_id hash করে shard number বের করুন
    hash_val = int(hashlib.md5(str(user_id).encode()).hexdigest(), 16)
    return hash_val % num_shards

# Consistent Hashing — shard add/remove এ data movement কমায়
import bisect

class ConsistentHashRing:
    def __init__(self, replicas=100):
        self.replicas = replicas
        self.ring = {}
        self.sorted_keys = []

    def add_shard(self, shard_name):
        for i in range(self.replicas):
            key = hash(f"{shard_name}:{i}")
            self.ring[key] = shard_name
            bisect.insort(self.sorted_keys, key)

    def get_shard(self, key):
        if not self.ring: return None
        h = hash(key)
        idx = bisect.bisect(self.sorted_keys, h) % len(self.sorted_keys)
        return self.ring[self.sorted_keys[idx]]

ring = ConsistentHashRing()
ring.add_shard("shard-1")
ring.add_shard("shard-2")
ring.add_shard("shard-3")

print(ring.get_shard("user:12345"))   # → shard-2
print(ring.get_shard("user:67890"))   # → shard-1

const { Pool } = require('pg');

// Primary (write) database
const primary = new Pool({ connectionString: process.env.DB_PRIMARY_URL });

// Read replicas — multiple
const replicas = [
  new Pool({ connectionString: process.env.DB_REPLICA1_URL }),
  new Pool({ connectionString: process.env.DB_REPLICA2_URL }),
];
let replicaIndex = 0;

// Round-robin replica selection
function getReadPool() {
  const pool = replicas[replicaIndex % replicas.length];
  replicaIndex++;
  return pool;
}

// Use primary for writes
async function writeQuery(sql, params) {
  console.log('✍️ Writing to PRIMARY');
  return primary.query(sql, params);
}

// Use replica for reads
async function readQuery(sql, params) {
  console.log('📖 Reading from REPLICA');
  return getReadPool().query(sql, params);
}

// Usage
await writeQuery('INSERT INTO users...', [name, email]);
await readQuery('SELECT * FROM users WHERE id=$1', [userId]);

import psycopg2

SHARD_CONFIGS = {
    0: {'host': 'shard0.db.com', 'dbname': 'users_0'},
    1: {'host': 'shard1.db.com', 'dbname': 'users_1'},
    2: {'host': 'shard2.db.com', 'dbname': 'users_2'},
}

def get_connection(user_id: int):
    shard_num = user_id % len(SHARD_CONFIGS)
    config = SHARD_CONFIGS[shard_num]
    print(f"User {user_id} → Shard {shard_num}")
    return psycopg2.connect(**config)

def get_user(user_id: int):
    with get_connection(user_id) as conn:
        with conn.cursor() as cur:
            cur.execute("SELECT * FROM users WHERE id=%s", (user_id,))
            return cur.fetchone()

print(get_user(12345))   # User 12345 → Shard 0 (12345 % 3 = 0)
print(get_user(12346))   # User 12346 → Shard 1 (12346 % 3 = 1)