1
-- PostgreSQL 范围分区示例：按月分区订单表
2
CREATE TABLE orders (
3
    id BIGINT,
4
    user_id BIGINT,
5
    amount DECIMAL(10,2),
6
    status VARCHAR(20),
7
    created_at TIMESTAMP
8
) PARTITION BY RANGE (created_at);
9

10
CREATE TABLE orders_2026_01 PARTITION OF orders
11
    FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
12

13
CREATE TABLE orders_2026_02 PARTITION OF orders
14
    FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
15

16
CREATE TABLE orders_2026_03 PARTITION OF orders
17
    FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
18

19
-- 查询自动路由到对应分区
20
SELECT * FROM orders WHERE created_at >= '2026-02-15'
21
    AND created_at < '2026-03-01';
22
-- 只扫描 orders_2026_02 分区

1
-- 范围查询：只涉及 1 个分区
2
SELECT * FROM orders
3
WHERE created_at BETWEEN '2026-02-01' AND '2026-02-28';
4
-- 扫描分区：orders_2026_02
5

6
-- 范围查询：跨分区但只涉及 2 个分区
7
SELECT * FROM orders
8
WHERE created_at BETWEEN '2026-01-20' AND '2026-02-15';
9
-- 扫描分区：orders_2026_01, orders_2026_02

1
-- PostgreSQL 哈希分区
2
CREATE TABLE users (
3
    id BIGINT,
4
    name VARCHAR(100),
5
    email VARCHAR(255),
6
    city VARCHAR(50)
7
) PARTITION BY HASH (id);
8

9
CREATE TABLE users_p0 PARTITION OF users FOR VALUES WITH (MODULUS 4, REMAINDER 0);
10
CREATE TABLE users_p1 PARTITION OF users FOR VALUES WITH (MODULUS 4, REMAINDER 1);
11
CREATE TABLE users_p2 PARTITION OF users FOR VALUES WITH (MODULUS 4, REMAINDER 2);
12
CREATE TABLE users_p3 PARTITION OF users FOR VALUES WITH (MODULUS 4, REMAINDER 3);
13

14
-- 数据路由：hash(id) % 4 → 分区编号
15
-- id = 42 → hash(42) % 4 = 2 → users_p2

1
partition_number = hash(key) % num_partitions

1
# 一致性哈希 + 虚拟节点的实现
2
import hashlib
3

4
class ConsistentHash:
5
    def __init__(self, nodes, num_vnodes=150):
6
        self.ring = {}           # 哈希值 → 节点
7
        self.sorted_keys = []    # 排序后的哈希值
8
        self.num_vnodes = num_vnodes
9

10
        for node in nodes:
11
            self.add_node(node)
12

13
    def _hash(self, key: str) -> int:
14
        return int(hashlib.md5(key.encode()).hexdigest(), 16)
15

16
    def add_node(self, node: str):
17
        """添加节点：在环上放置 num_vnodes 个虚拟节点"""
18
        for i in range(self.num_vnodes):
19
            vnode_key = f"{node}:{i}"
20
            h = self._hash(vnode_key)
21
            self.ring[h] = node
22
        self.sorted_keys = sorted(self.ring.keys())
23

24
    def remove_node(self, node: str):
25
        """移除节点：删除所有虚拟节点"""
26
        for i in range(self.num_vnodes):
27
            vnode_key = f"{node}:{i}"
28
            h = self._hash(vnode_key)
29
            del self.ring[h]
30
        self.sorted_keys = sorted(self.ring.keys())
31

32
    def get_node(self, key: str) -> str:
33
        """查找键对应的节点：顺时针查找"""
34
        h = self._hash(key)
35
        # 二分查找第一个 >= h 的虚拟节点
36
        idx = self._bisect(h)
37
        return self.ring[self.sorted_keys[idx]]
38

39
    def _bisect(self, h: int) -> int:
40
        lo, hi = 0, len(self.sorted_keys)
41
        while lo < hi:
42
            mid = (lo + hi) // 2
43
            if self.sorted_keys[mid] < h:
44
                lo = mid + 1
45
            else:
46
                hi = mid
47
        return lo % len(self.sorted_keys)

1
-- 本地索引场景下的覆盖索引
2
-- 分区键：user_id，二级索引：(city, name)
3
SELECT name, city FROM users WHERE city = '北京';
4
-- 覆盖索引：不需要回表，但仍然需要 Scatter/Gather
5

6
-- 全局索引场景下的覆盖索引
7
-- 全局索引键：city，包含列：name, user_id
8
SELECT name FROM users WHERE city = '北京';
9
-- 覆盖索引：不需要回表，也不需要 Scatter/Gather
10
-- 直接从全局索引分区获取结果

1
# 反面教材：直接改变取模数
2
# 从 4 个节点扩展到 5 个节点
3
# hash(key) % 4 → hash(key) % 5
4

5
# 迁移量分析
6
# 对于任意 key，hash(key) % 4 ≠ hash(key) % 5 的概率 ≈ 1 - 1/5 = 80%
7
# 即 80% 的数据需要迁移！

1
# 固定分区再平衡示例（Redis Cluster 风格）
2
# 16384 个哈希槽，初始分配给 4 个节点
3

4
slot_assignment_before = {
5
    "node_A": range(0, 4096),      # 槽 0-4095
6
    "node_B": range(4096, 8192),   # 槽 4096-8191
7
    "node_C": range(8192, 12288),  # 槽 8192-12287
8
    "node_D": range(12288, 16384), # 槽 12288-16383
9
}
10

11
# 添加 node_E，从每个节点各迁移一部分槽
12
slot_assignment_after = {
13
    "node_A": range(0, 3277),       # 迁出 819 个槽
14
    "node_B": range(4096, 7373),    # 迁出 819 个槽
15
    "node_C": range(8192, 11469),   # 迁出 819 个槽
16
    "node_D": range(12288, 15565),  # 迁出 819 个槽
17
    "node_E": range(3277, 4096) + range(7373, 8192)
18
            + range(11469, 12288) + range(15565, 16384),
19
    # 共接收 3276 个槽 ≈ 16384 / 5
20
}

1
// HBase Region 分裂触发条件（简化）
2
// 当 Region 大小超过 hbase.hregion.max.filesize（默认 10GB）
3
// 自动触发分裂
4

5
// 分裂过程：
6
// 1. Region Server 选择分裂点（通常为中间行键）
7
// 2. 创建两个新 Region，原 Region 下线
8
// 3. 将数据按分裂点分配到新 Region
9
// 4. 新 Region 上线，更新 Meta 表
10
// 5. 可选：将新 Region 迁移到其他 Region Server 以均衡负载

1
# Cassandra nodetool move 操作示例
2
# 将 token 重新分配给节点
3

4
# 1. 查看当前集群状态
5
nodetool status
6

7
# 2. 触发再平衡（自动计算新 token 分配）
8
nodetool rebalance
9

10
# 3. 手动移动节点到新 token（谨慎使用）
11
nodetool move <new_token>
12

13
# 4. 清理不再属于本节点的数据
14
nodetool cleanup
15

16
# 5. 监控再平衡进度
17
nodetool netstats
18
nodetool compactionstats

1
-- 反面：仅按时间分区，写入全部集中
2
-- PARTITION BY RANGE (created_at)
3

4
-- 正面：先按用户 ID 哈希，再按时间范围
5
-- Cassandra 风格的组合分区键
6
CREATE TABLE events (
7
    user_id BIGINT,
8
    event_time TIMESTAMP,
9
    event_type VARCHAR(50),
10
    payload TEXT,
11
    PRIMARY KEY ((user_id), event_time)
12
    --       ^^^^^^^^ 分区键（哈希）
13
    --                    ^^^^^^^^^^ 聚簇列（范围排序）
14
);
15

16
-- 同一用户的事件按时间排序存储在同一分区
17
-- 不同用户的事件分散到不同分区
18
-- 查询某用户某时间段的事件只需访问一个分区

1
# 热点键缓解：加盐打散
2
# 假设 user_id=1 是超级用户，数据量远超其他用户
3

4
# 原始分区键
5
def original_key(user_id):
6
    return f"user:{user_id}"
7

8
# 加盐分区键：为热点用户添加随机前缀
9
def salted_key(user_id, num_buckets=10):
10
    if is_hot_user(user_id):
11
        bucket = random.randint(0, num_buckets - 1)
12
        return f"user:{user_id}:bucket:{bucket}"
13
    return f"user:{user_id}"
14

15
# 查询时需要扫描所有桶
16
def query_hot_user(user_id, num_buckets=10):
17
    results = []
18
    for bucket in range(num_buckets):
19
        key = f"user:{user_id}:bucket:{bucket}"
20
        results.extend(query_partition(key))
21
    return results

1
-- 电商订单表分区设计
2
-- 挑战：按卖家查询（热点卖家）、按时间查询（写入热点）
3

4
-- 方案：组合分区键 + 二级索引
5
-- 主表：按 (seller_id % 100, created_at) 分区
6
-- seller_id 哈希打散写入，created_at 保证时间局部性
7

8
CREATE TABLE orders (
9
    order_id BIGINT,           -- 分布式 ID（Snowflake）
10
    seller_id BIGINT,          -- 卖家 ID
11
    buyer_id BIGINT,           -- 买家 ID
12
    status VARCHAR(20),
13
    amount DECIMAL(10,2),
14
    created_at TIMESTAMP,
15
    PRIMARY KEY (order_id)
16
) PARTITION BY HASH (seller_id);
17

18
-- 买家维度的查询通过全局二级索引支持
19
CREATE INDEX idx_buyer ON orders (buyer_id, created_at)
20
    GLOBAL;  -- 全局索引，按 buyer_id 分区
21

22
-- 时间维度的查询通过本地二级索引支持
23
-- 同一卖家的订单按时间排序，范围查询高效
24
CREATE INDEX idx_seller_time ON orders (seller_id, created_at)
25
    LOCAL;   -- 本地索引，与主表同分区