Database Management SystemsSharding

Sharding: Horizontal Scaling for Distributed Databases

LevelAdvanced

Duration90 mins

TopicSharding

4 / 5

Hash Sharding: Uniform Distribution Through Mathematical Elegance

The Mathematics of Balance

In the quest to distribute data evenly across shards, hash sharding leverages one of computer science's most elegant tools: the hash function. Unlike range sharding, which depends on careful boundary design and remains vulnerable to hotspots, hash sharding achieves near-automatic load balancing through mathematical properties that guarantee uniform distribution regardless of the input data patterns.

Hash sharding is the dominant approach for systems prioritizing write scalability, even load distribution, and operational simplicity. From Amazon's DynamoDB to Apache Cassandra to MongoDB's hash-based partitioning, hash sharding powers some of the world's largest and most demanding database systems.

This page explores the theory and practice of hash sharding—from the mathematical foundations to production implementation patterns to the critical evolution of consistent hashing that enables seamless cluster scaling.

What You Will Learn

By the end of this page, you will understand how hash functions create uniform distribution, the mechanics of hash sharding, consistent hashing and virtual nodes, the tradeoffs compared to range sharding, and production patterns for hash-sharded systems. You'll gain the knowledge to implement and operate hash-sharded databases confidently.

Hash Sharding Fundamentals: The Core Mechanism

At its core, hash sharding applies a hash function to the shard key, producing a numeric value that determines which shard stores the record. The hash function's properties guarantee that even non-uniform input data is distributed uniformly across outputs.

Formal Definition:

Hash sharding assigns records to shards using the formula: shard_id = hash(shard_key) % num_shards, where hash is a deterministic function that produces uniformly distributed output values.

The Hash Function's Role:

A good hash function for sharding has these properties:

Deterministic — Same input always produces same output
Uniform Distribution — Outputs are evenly spread across the output space
Avalanche Effect — Small input changes create dramatically different outputs
Fast Computation — Adding latency to every operation is unacceptable

hash-sharding-basic.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import hashlib
 
def simple_hash_shard(key: str, num_shards: int) -> int:
    """
    Basic hash sharding using MD5.
    
    Properties:
    - Deterministic: same key always routes to same shard
    - Uniform: keys distribute evenly across shards
    - Independent of key patterns: sequential IDs don't cluster
    """
    # Hash the key to get a large integer
    hash_bytes = hashlib.md5(key.encode()).digest()
    hash_int = int.from_bytes(hash_bytes[:8], byteorder='big')
    
    # Modulo to map to shard range
    return hash_int % num_shards
 
# Demonstration: sequential IDs distribute uniformly
num_shards = 8
shard_counts = {i: 0 for i in range(num_shards)}
 
for user_id in range(100000):
    shard = simple_hash_shard(str(user_id), num_shards)
    shard_counts[shard] += 1
 
print("Distribution of 100,000 sequential IDs across 8 shards:")
for shard_id, count in sorted(shard_counts.items()):
    percentage = count / 1000
    bar = "█" * int(percentage / 2)
    print(f"  Shard {shard_id}: {count:,} ({percentage:.1f}%) {bar}")
 
# Output:
#   Shard 0: 12,502 (12.5%) ██████
#   Shard 1: 12,518 (12.5%) ██████
#   Shard 2: 12,486 (12.5%) ██████
#   Shard 3: 12,501 (12.5%) ██████
#   Shard 4: 12,493 (12.5%) ██████
#   Shard 5: 12,504 (12.5%) ██████
#   Shard 6: 12,498 (12.5%) ██████
#   Shard 7: 12,498 (12.5%) ██████
# Near-perfect 12.5% distribution!

Converting Mermaid diagram...

Hash Function Selection

Common hash functions for sharding include MD5, MurmurHash, xxHash, and CityHash. MD5 is simple but slower. MurmurHash and xxHash are extremely fast non-cryptographic hashes designed for hash tables—ideal for sharding. Cryptographic strength is unnecessary; speed and distribution quality matter most.

Why Hash Sharding Works: The Mathematics of Uniformity

Understanding why hash sharding produces uniform distribution requires examining the mathematical properties of hash functions.

The Uniformity Guarantee:

A well-designed hash function exhibits the property that for any input from a large domain, the output is uniformly distributed across the output range. This means:

P(hash(x) mod n = k) ≈ 1/n for any shard k
Input patterns (sequential, clustered, skewed) don't affect output distribution
The only requirement is sufficient input entropy (distinct values)

Why This Solves the Hotspot Problem:

Remember the nightmare of range sharding with monotonic keys? All new data went to the 'latest' shard. Hash sharding eliminates this:

Range Sharding (timestamp key):
  new_order_1 → Shard N (current)
  new_order_2 → Shard N (current)
  new_order_3 → Shard N (current)  ← HOTSPOT!

Hash Sharding (timestamp key):
  new_order_1 → hash(order_1) % 8 = 3 → Shard 3
  new_order_2 → hash(order_2) % 8 = 7 → Shard 7
  new_order_3 → hash(order_3) % 8 = 1 → Shard 1 ← DISTRIBUTED!

The hash function transforms the problematic pattern (sequential) into a uniform distribution.

Hash Sharding Benefits

•Automatic Load Balancing — No manual boundary tuning required
•Hotspot Immunity — Monotonic/clustered keys distribute evenly
•Simple Implementation — Just hash function + modulo
•Predictable Performance — Each shard handles ~equal load
•Works with Any Key — No cardinality or distribution requirements

Hash Sharding Limitations

•Range Queries Scatter — Must hit all shards for ranges
•Loses Ordering — Adjacent keys on different shards
•Resharding Pain — Adding shards moves ~all data
•No Data Locality — Related records scattered randomly
•Debugging Harder — Which shard has user X? Must hash!

Statistical Analysis of Hash Distribution:

For n records distributed across k shards using a uniform hash:

Expected records per shard: n/k
Standard deviation: √(n×(1/k)×(1-1/k)) ≈ √(n/k) for large k
Coefficient of variation: √(k/n)

For 1 million records across 100 shards:

Expected per shard: 10,000
Standard deviation: ~100 (1% of expected)
99.7% of shards will have 9,700-10,300 records

This is remarkably balanced for any practical purpose.

The Cardinality Caveat

Hash sharding only works well when the shard key has sufficient cardinality. If you hash a column with only 10 distinct values, you still only get 10 possible shard destinations—hash can't create cardinality that doesn't exist in the input.

The Resharding Problem: When Simple Hashing Fails

The simple hash(key) % num_shards approach has a critical flaw: changing the number of shards invalidates nearly all routing decisions.

The Mathematical Problem:

When num_shards changes, the modulo operation produces different results for most keys:

# Before: 8 shards
hash("user_123") % 8 = 5  → Shard 5

# After: 10 shards (added 2 shards for capacity)
hash("user_123") % 10 = 3 → Shard 3  # DIFFERENT!

# Same hash value, different destination
# This key must be migrated from Shard 5 to Shard 3

Scale of the Problem:

When scaling from k to k+1 shards with simple modulo:

Fraction of keys that move: ~k/(k+1)
For 10 → 11 shards: ~91% of keys relocate
For 100 → 101 shards: ~99% of keys relocate

This is catastrophic. Adding a single shard requires migrating nearly all data.

Converting Mermaid diagram...

The Operational Nightmare:

Migrating most of your data has severe implications:

Network bandwidth saturation — Moving terabytes/petabytes across network
Extended maintenance windows — Hours or days of reduced capacity
Complexity — Tracking what's migrated, handling failures, ensuring consistency
Risk — Any error affects most of your data

Partial Solutions That Don't Scale:

Only double shards: Move exactly 1/2 of data each time (8→16→32)
- Limits scaling flexibility
- Still 50% data movement
Pre-provision shards: Create more shards than initially needed
- Wastes resources
- Eventually still need to add more

The fundamental problem remained unsolved until the introduction of consistent hashing.

Don't Use Simple Modulo Hashing

For any system that might ever need to scale, simple modulo hashing is a trap. It works perfectly until your first scaling event, then creates an operational crisis. Always use consistent hashing or similar techniques from the start.

Consistent Hashing: The Elegant Solution

Consistent hashing, introduced by Karger et al. in 1997 for web caching, revolutionized distributed systems by enabling scaling with minimal data movement. It's now the foundation of most hash-sharded databases.

The Core Idea:

Instead of mapping keys to shard numbers directly, consistent hashing maps both keys AND shards to positions on a conceptual ring (hash space from 0 to 2^32-1 or similar). Each key is assigned to the nearest shard clockwise on the ring.

How It Works:

Hash each shard ID to a position on the ring
Hash each key to a position on the ring
Walk clockwise from the key's position to find the first shard
That shard owns the key

consistent-hashing.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import hashlib
import bisect
from typing import List, Optional
 
class ConsistentHashRing:
    """
    Consistent hashing implementation for shard routing.
    
    Key property: Adding/removing a shard only affects
    keys in the immediate vicinity on the ring.
    """
    
    def __init__(self):
        self.ring = {}  # position -> shard_id
        self.sorted_positions = []
    
    def _hash(self, key: str) -> int:
        """Hash to ring position (0 to 2^32 - 1)"""
        digest = hashlib.md5(key.encode()).digest()
        return int.from_bytes(digest[:4], byteorder='big')
    
    def add_shard(self, shard_id: str):
        """Add a shard to the ring."""
        position = self._hash(shard_id)
        self.ring[position] = shard_id
        self.sorted_positions = sorted(self.ring.keys())
        return position
    
    def remove_shard(self, shard_id: str):
        """Remove a shard from the ring."""
        position = self._hash(shard_id)
        if position in self.ring:
            del self.ring[position]
            self.sorted_positions = sorted(self.ring.keys())
    
    def get_shard(self, key: str) -> str:
        """Find the shard responsible for a key."""
        if not self.ring:
            raise ValueError("No shards in ring")
        
        key_position = self._hash(key)
        
        # Find first shard position >= key position (clockwise walk)
        idx = bisect.bisect(self.sorted_positions, key_position)
        
        # Wrap around if necessary
        if idx >= len(self.sorted_positions):
            idx = 0
        
        shard_position = self.sorted_positions[idx]
        return self.ring[shard_position]
 
# Demonstration
ring = ConsistentHashRing()
for i in range(4):
    ring.add_shard(f"shard-{i}")
 
# Track key assignments
assignments_before = {f"key-{i}": ring.get_shard(f"key-{i}") 
                      for i in range(1000)}
 
# Add a new shard
ring.add_shard("shard-4")
 
# Check how many keys moved
assignments_after = {f"key-{i}": ring.get_shard(f"key-{i}") 
                     for i in range(1000)}
 
moved = sum(1 for k in assignments_before 
            if assignments_before[k] != assignments_after[k])
 
print(f"Keys that changed assignment: {moved}/1000 ({moved/10:.1f}%)")
# Output: Keys that changed assignment: ~200/1000 (~20%)
# Only ~1/5 of keys moved when adding 1 shard to 4 existing!

Why Consistent Hashing Minimizes Movement:

When a shard is added:

Only keys between the new shard and its clockwise neighbor move
Other keys are unaffected
Expected movement: 1/(n+1) of keys, where n is current shard count

For 100 → 101 shards: ~1% of keys move (vs. ~99% with simple modulo!)

Mathematical Property:

Adding k shards to n shards moves at most k/(n+k) of keys
Removing k shards from n shards moves at most k/n of keys
This is optimal—you can't do better without moving data unnecessarily

From O(n) to O(1/n)

Simple modulo: O(n) data movement on resize. Consistent hashing: O(1/n) data movement. This isn't an optimization—it's a fundamental change that makes online scaling practical for the first time.

Virtual Nodes: Solving Consistent Hashing's Imbalance Problem

Basic consistent hashing has a significant flaw: with few shards, distribution can be quite uneven. If shard positions happen to cluster on one part of the ring, those shards handle less data while others handle more.

The Problem Illustrated:

With 4 shards randomly positioned on a ring:

Best case: Each shard covers 25% of the ring (perfect)
Worst case: One shard might cover 50%+ of the ring (2x load)
The variance is high for small numbers of physical shards

The Virtual Nodes Solution:

Instead of placing each physical shard at one ring position, create multiple virtual nodes for each physical shard. With 100 virtual nodes per shard:

4 physical shards → 400 ring positions
Each physical shard spread across 100 arc segments
Law of large numbers kicks in → near-uniform distribution

virtual-nodes.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import hashlib
import bisect
from collections import defaultdict
 
class VirtualNodeConsistentHash:
    """
    Consistent hashing with virtual nodes for balanced distribution.
    
    Each physical shard maps to many positions on the ring,
    spreading its coverage evenly.
    """
    
    def __init__(self, virtual_nodes_per_shard: int = 150):
        self.virtual_nodes = virtual_nodes_per_shard
        self.ring = {}  # position -> physical_shard_id
        self.sorted_positions = []
        self.shard_positions = defaultdict(list)  # shard_id -> [positions]
    
    def _hash(self, key: str) -> int:
        digest = hashlib.md5(key.encode()).digest()
        return int.from_bytes(digest[:4], byteorder='big')
    
    def add_shard(self, shard_id: str):
        """Add shard with virtual nodes."""
        for v in range(self.virtual_nodes):
            # Each virtual node has a unique identifier
            virtual_key = f"{shard_id}:vnode:{v}"
            position = self._hash(virtual_key)
            self.ring[position] = shard_id
            self.shard_positions[shard_id].append(position)
        
        self.sorted_positions = sorted(self.ring.keys())
    
    def remove_shard(self, shard_id: str):
        """Remove all virtual nodes for a shard."""
        for position in self.shard_positions[shard_id]:
            if position in self.ring:
                del self.ring[position]
        del self.shard_positions[shard_id]
        self.sorted_positions = sorted(self.ring.keys())
    
    def get_shard(self, key: str) -> str:
        """Find the physical shard for a key."""
        if not self.ring:
            raise ValueError("No shards in ring")
        
        key_position = self._hash(key)
        idx = bisect.bisect(self.sorted_positions, key_position)
        if idx >= len(self.sorted_positions):
            idx = 0
        
        return self.ring[self.sorted_positions[idx]]
    
    def get_distribution(self, num_keys: int = 100000) -> dict:
        """Analyze key distribution across physical shards."""
        counts = defaultdict(int)
        for i in range(num_keys):
            shard = self.get_shard(f"test-key-{i}")
            counts[shard] += 1
        
        total = sum(counts.values())
        return {
            shard: {
                'count': count,
                'percentage': count * 100 / total,
                'deviation': abs(count / (total / len(counts)) - 1) * 100
            }
            for shard, count in counts.items()
        }
 
# Compare distribution with different virtual node counts
for vnodes in [1, 10, 50, 150, 500]:
    ring = VirtualNodeConsistentHash(virtual_nodes_per_shard=vnodes)
    for i in range(8):
        ring.add_shard(f"shard-{i}")
    
    dist = ring.get_distribution(100000)
    max_dev = max(d['deviation'] for d in dist.values())
    min_pct = min(d['percentage'] for d in dist.values())
    max_pct = max(d['percentage'] for d in dist.values())
    
    print(f"VNodes={vnodes:3}: "
          f"Range {min_pct:.1f}%-{max_pct:.1f}%, "
          f"Max Deviation: {max_dev:.1f}%")
 
# Output:
# VNodes=  1: Range 3.2%-21.8%, Max Deviation: 74.5%
# VNodes= 10: Range 9.8%-15.2%, Max Deviation: 21.6%  
# VNodes= 50: Range 11.5%-13.2%, Max Deviation: 6.0%
# VNodes=150: Range 11.9%-12.9%, Max Deviation: 3.0%
# VNodes=500: Range 12.1%-12.7%, Max Deviation: 1.5%

Virtual Nodes Impact on Distribution
Virtual Nodes	Min Shard %	Max Shard %	Max Deviation	Memory Overhead
1 (basic)	3%	22%	74%	Minimal
10	10%	15%	22%	Low
50	11%	13%	6%	Moderate
150	12%	13%	3%	Higher
500	12%	13%	1.5%	Significant

Virtual Node Tuning

150-200 virtual nodes per shard is a common production setting. More virtual nodes improve balance but increase memory for the ring data structure and slow down lookups slightly. For most systems, the balance benefit far outweighs the overhead.

Hash Sharding Implementation Patterns

Production hash sharding implementations must handle routing, replication, and failure scenarios. Here are battle-tested patterns.

Pattern 1: Routing with Replication

In replicated systems, each key maps to multiple shards (replicas). Consistent hashing naturally supports this:

replicated-routing.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class ReplicatedHashRouter:
    """
    Hash routing with replication factor.
    Each key maps to N consecutive shards on the ring.
    """
    
    def __init__(self, replication_factor: int = 3):
        self.rf = replication_factor
        self.ring = VirtualNodeConsistentHash()
    
    def get_replicas(self, key: str) -> list:
        """
        Get the list of shards that store replicas of this key.
        Returns replication_factor distinct physical shards.
        """
        if len(self.ring.sorted_positions) == 0:
            raise ValueError("No shards available")
        
        key_pos = self.ring._hash(key)
        idx = bisect.bisect(self.ring.sorted_positions, key_pos)
        
        replicas = []
        seen_shards = set()
        positions = len(self.ring.sorted_positions)
        
        # Walk clockwise until we have enough distinct shards
        for i in range(positions):
            pos = self.ring.sorted_positions[(idx + i) % positions]
            shard = self.ring.ring[pos]
            
            if shard not in seen_shards:
                replicas.append(shard)
                seen_shards.add(shard)
                
                if len(replicas) >= self.rf:
                    break
        
        return replicas
    
    def get_primary(self, key: str) -> str:
        """First replica is the primary."""
        return self.get_replicas(key)[0]
    
    def route_read(self, key: str, consistency: str = 'one') -> list:
        """
        Route a read request based on consistency level.
        """
        replicas = self.get_replicas(key)
        
        if consistency == 'one':
            return [replicas[0]]  # Any single replica
        elif consistency == 'quorum':
            return replicas[:len(replicas) // 2 + 1]  # Majority
        elif consistency == 'all':
            return replicas  # All replicas must respond
    
    def route_write(self, key: str, consistency: str = 'quorum') -> list:
        """
        Route a write request based on consistency level.
        """
        replicas = self.get_replicas(key)
        
        if consistency == 'one':
            return [replicas[0]]
        elif consistency == 'quorum':
            return replicas[:len(replicas) // 2 + 1]
        elif consistency == 'all':
            return replicas

Pattern 2: Token-Based Partitioning

Some systems (Cassandra, Riak) use explicit token assignments rather than hashing shard names:

# Each shard owns a token range
token_ranges = [
    {'shard': 'shard-1', 'start': 0, 'end': 2**32 // 4},
    {'shard': 'shard-2', 'start': 2**32 // 4, 'end': 2**32 // 2},
    {'shard': 'shard-3', 'start': 2**32 // 2, 'end': 3 * 2**32 // 4},
    {'shard': 'shard-4', 'start': 3 * 2**32 // 4, 'end': 2**32},
]

def route(key):
    token = hash(key)
    for range in token_ranges:
        if range['start'] <= token < range['end']:
            return range['shard']

Benefits of Token Ranges:

Explicit control over data placement
Can manually balance by adjusting ranges
Easier to reason about for operators

Pattern 3: Jump Consistent Hashing

Google's Jump Consistent Hash achieves perfect balance with no memory overhead:

jump-hash.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def jump_consistent_hash(key: int, num_buckets: int) -> int:
    """
    Google's Jump Consistent Hash algorithm.
    
    Properties:
    - O(1) memory (no ring to store)
    - Perfect balance across buckets
    - Minimal key movement when buckets change
    - O(log n) computation time
    
    When num_buckets increases from n to n+1:
    - Only keys on bucket n-1 might move to bucket n
    - Expected movement: 1/(n+1) of keys
    """
    if num_buckets <= 0:
        raise ValueError("num_buckets must be positive")
    
    # Use 64-bit arithmetic
    key = key & 0xFFFFFFFFFFFFFFFF
    
    b = -1
    j = 0
    
    while j < num_buckets:
        b = j
        key = ((key * 2862933555777941757) + 1) & 0xFFFFFFFFFFFFFFFF
        j = int((b + 1) * (float(1 << 31) / float((key >> 33) + 1)))
    
    return b
 
# Usage
def route_key(key_string: str, num_shards: int) -> int:
    # Convert string key to integer
    key_hash = int(hashlib.md5(key_string.encode()).hexdigest(), 16)
    return jump_consistent_hash(key_hash, num_shards)
 
# Test distribution
from collections import Counter
shards = Counter()
for i in range(100000):
    shard = route_key(f"key-{i}", 8)
    shards[shard] += 1
 
print("Jump Hash Distribution (100K keys, 8 shards):")
for shard in sorted(shards):
    pct = shards[shard] / 1000
    print(f"  Shard {shard}: {shards[shard]:,} ({pct:.2f}%)")
# Perfect 12.5% distribution guaranteed!

When to Use Jump Hash

Jump Consistent Hash is ideal when shards are numbered 0 to n-1 without gaps, and you only add shards at the end (no removals from the middle). It's simpler and more memory-efficient than ring-based consistent hashing for these scenarios.

Production Considerations for Hash-Sharded Systems

Operating hash-sharded systems in production requires attention to several critical concerns.

Range Query Strategies:

Hash sharding scatters related keys, making range queries expensive. Strategies for systems needing both:

Secondary Index per Shard
- Each shard maintains local indexes for range-queryable fields
- Scatter-gather for range queries, but with index acceleration
Dedicated Range-Ordered Replica
- Maintain a separate replica set ordered by a range key
- Route range queries to that replica set
Composite Key Strategy
- Hash prefix for distribution: hash(user_id)
- Range suffix for ordering: timestamp
- Keys: {hash(user_id)}:{timestamp}
- Range queries within a user are efficient

Hash Sharding Operational Metrics
Metric	Healthy	Warning	Critical	Action
Shard load variance	< 10%	10-25%	25%	Check for hot keys, increase vnodes
Cross-shard query rate	< 20%	20-50%	50%	Review shard key, consider colocation
Ring metadata sync lag	< 1s	1-10s	10s	Check metadata store health
Key distribution skew	< 5%	5-15%	15%	Analyze key cardinality, check hot keys
Rebalance data pending	< 5%	5-20%	20%	Monitor rebalance progress, check bandwidth

Hot Key Handling:

Even with perfect hash distribution, application-level hotspots can emerge:

# Problem: Celebrity user with millions of followers
# All followers query user_id='celebrity123'
# That hash slot becomes a hotspot

# Solution 1: Request-level caching
@cache(ttl=60)
def get_user(user_id):
    return db.query(f"SELECT * FROM users WHERE id = {user_id}")

# Solution 2: Key spreading with random suffixes
def spread_hot_key(user_id, num_copies=10):
    suffix = random.randint(0, num_copies - 1)
    return f"{user_id}:{suffix}"

# Solution 3: Dedicated shard for hot keys
HOT_KEYS = {'celebrity123', 'viral_post_456', ...}
if key in HOT_KEYS:
    return hot_key_shard  # Special high-capacity shard

Graceful Shard Failures:

With consistent hashing, shard failures redistribute load to neighbors:

Before failure: Shard C handles keys in range [X, Y)
After Shard C fails: Keys [X, Y) move to Shard D (next on ring)
Shard D load increases by ~33% (for RF=3)

Mitigation:
- Virtual nodes spread the load increase across multiple shards
- Replication ensures no data loss
- Auto-scaling can quickly add replacement capacity

The Hottest Key Is Your Bottleneck

No amount of sharding helps if a single key receives overwhelming traffic. Identify hot keys proactively through access logs and implement key-specific caching or spreading strategies before they become production incidents.

Summary: Hash Sharding Mastery

Hash sharding leverages mathematical uniformity to create automatically balanced distributed databases. Let's consolidate the key principles:

Key Takeaways

•Hash functions transform any key pattern into uniform distribution — Sequential IDs, timestamps, clustered values all become evenly spread across shards.
•Simple modulo hashing fails at scale — Adding or removing shards causes massive data movement (~100%). Never use for production systems that need to scale.
•Consistent hashing enables elastic scaling — Adding a shard moves only 1/n of data. This makes online scaling practical for the first time.
•Virtual nodes solve the small-cluster imbalance problem — 150+ virtual nodes per shard creates near-perfect distribution regardless of physical shard count.
•Hash sharding sacrifices range queries for balance — Range queries require scatter-gather. Use composite keys or secondary strategies when ranges matter.
•Hot keys bypass all distribution guarantees — Application-level caching, key spreading, or dedicated handling is required for extremely popular keys.

What's Next:

With range and hash sharding strategies mastered, the final page addresses what happens when your sharding scheme needs to change: resharding. We'll explore the strategies, risks, and operational procedures for migrating data to new sharding configurations—one of the most challenging operations in distributed database management.

Page Complete

You now understand hash sharding deeply—from the mathematical foundations through production implementation patterns. You can design, implement, and operate hash-sharded systems with confidence, and you know when consistent hashing and virtual nodes are essential for scalable operation.

4 / 5

Loading learning content...

Database Management SystemsSharding

Sharding: Horizontal Scaling for Distributed Databases

LevelAdvanced

Duration90 mins

TopicSharding

4 / 5

Hash Sharding: Uniform Distribution Through Mathematical Elegance

The Mathematics of Balance

What You Will Learn

Hash Sharding Fundamentals: The Core Mechanism

Formal Definition:

Hash sharding assigns records to shards using the formula: shard_id = hash(shard_key) % num_shards, where hash is a deterministic function that produces uniformly distributed output values.

The Hash Function's Role:

A good hash function for sharding has these properties:

Deterministic — Same input always produces same output
Uniform Distribution — Outputs are evenly spread across the output space
Avalanche Effect — Small input changes create dramatically different outputs
Fast Computation — Adding latency to every operation is unacceptable

hash-sharding-basic.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import hashlib
 
def simple_hash_shard(key: str, num_shards: int) -> int:
    """
    Basic hash sharding using MD5.
    
    Properties:
    - Deterministic: same key always routes to same shard
    - Uniform: keys distribute evenly across shards
    - Independent of key patterns: sequential IDs don't cluster
    """
    # Hash the key to get a large integer
    hash_bytes = hashlib.md5(key.encode()).digest()
    hash_int = int.from_bytes(hash_bytes[:8], byteorder='big')
    
    # Modulo to map to shard range
    return hash_int % num_shards
 
# Demonstration: sequential IDs distribute uniformly
num_shards = 8
shard_counts = {i: 0 for i in range(num_shards)}
 
for user_id in range(100000):
    shard = simple_hash_shard(str(user_id), num_shards)
    shard_counts[shard] += 1
 
print("Distribution of 100,000 sequential IDs across 8 shards:")
for shard_id, count in sorted(shard_counts.items()):
    percentage = count / 1000
    bar = "█" * int(percentage / 2)
    print(f"  Shard {shard_id}: {count:,} ({percentage:.1f}%) {bar}")
 
# Output:
#   Shard 0: 12,502 (12.5%) ██████
#   Shard 1: 12,518 (12.5%) ██████
#   Shard 2: 12,486 (12.5%) ██████
#   Shard 3: 12,501 (12.5%) ██████
#   Shard 4: 12,493 (12.5%) ██████
#   Shard 5: 12,504 (12.5%) ██████
#   Shard 6: 12,498 (12.5%) ██████
#   Shard 7: 12,498 (12.5%) ██████
# Near-perfect 12.5% distribution!

Converting Mermaid diagram...

Hash Function Selection

Why Hash Sharding Works: The Mathematics of Uniformity

Understanding why hash sharding produces uniform distribution requires examining the mathematical properties of hash functions.

The Uniformity Guarantee:

A well-designed hash function exhibits the property that for any input from a large domain, the output is uniformly distributed across the output range. This means:

P(hash(x) mod n = k) ≈ 1/n for any shard k
Input patterns (sequential, clustered, skewed) don't affect output distribution
The only requirement is sufficient input entropy (distinct values)

Why This Solves the Hotspot Problem:

Remember the nightmare of range sharding with monotonic keys? All new data went to the 'latest' shard. Hash sharding eliminates this:

Range Sharding (timestamp key):
  new_order_1 → Shard N (current)
  new_order_2 → Shard N (current)
  new_order_3 → Shard N (current)  ← HOTSPOT!

Hash Sharding (timestamp key):
  new_order_1 → hash(order_1) % 8 = 3 → Shard 3
  new_order_2 → hash(order_2) % 8 = 7 → Shard 7
  new_order_3 → hash(order_3) % 8 = 1 → Shard 1 ← DISTRIBUTED!

The hash function transforms the problematic pattern (sequential) into a uniform distribution.

Hash Sharding Benefits

•Automatic Load Balancing — No manual boundary tuning required
•Hotspot Immunity — Monotonic/clustered keys distribute evenly
•Simple Implementation — Just hash function + modulo
•Predictable Performance — Each shard handles ~equal load
•Works with Any Key — No cardinality or distribution requirements

Hash Sharding Limitations

•Range Queries Scatter — Must hit all shards for ranges
•Loses Ordering — Adjacent keys on different shards
•Resharding Pain — Adding shards moves ~all data
•No Data Locality — Related records scattered randomly
•Debugging Harder — Which shard has user X? Must hash!

Statistical Analysis of Hash Distribution:

For n records distributed across k shards using a uniform hash:

Expected records per shard: n/k
Standard deviation: √(n×(1/k)×(1-1/k)) ≈ √(n/k) for large k
Coefficient of variation: √(k/n)

For 1 million records across 100 shards:

Expected per shard: 10,000
Standard deviation: ~100 (1% of expected)
99.7% of shards will have 9,700-10,300 records

This is remarkably balanced for any practical purpose.

The Cardinality Caveat

The Resharding Problem: When Simple Hashing Fails

The simple hash(key) % num_shards approach has a critical flaw: changing the number of shards invalidates nearly all routing decisions.

The Mathematical Problem:

When num_shards changes, the modulo operation produces different results for most keys:

# Before: 8 shards
hash("user_123") % 8 = 5  → Shard 5

# After: 10 shards (added 2 shards for capacity)
hash("user_123") % 10 = 3 → Shard 3  # DIFFERENT!

# Same hash value, different destination
# This key must be migrated from Shard 5 to Shard 3

Scale of the Problem:

When scaling from k to k+1 shards with simple modulo:

Fraction of keys that move: ~k/(k+1)
For 10 → 11 shards: ~91% of keys relocate
For 100 → 101 shards: ~99% of keys relocate

This is catastrophic. Adding a single shard requires migrating nearly all data.

Converting Mermaid diagram...

The Operational Nightmare:

Migrating most of your data has severe implications:

Network bandwidth saturation — Moving terabytes/petabytes across network
Extended maintenance windows — Hours or days of reduced capacity
Complexity — Tracking what's migrated, handling failures, ensuring consistency
Risk — Any error affects most of your data

Partial Solutions That Don't Scale:

Only double shards: Move exactly 1/2 of data each time (8→16→32)
- Limits scaling flexibility
- Still 50% data movement
Pre-provision shards: Create more shards than initially needed
- Wastes resources
- Eventually still need to add more

The fundamental problem remained unsolved until the introduction of consistent hashing.

Don't Use Simple Modulo Hashing

Consistent Hashing: The Elegant Solution

The Core Idea:

How It Works:

Hash each shard ID to a position on the ring
Hash each key to a position on the ring
Walk clockwise from the key's position to find the first shard
That shard owns the key

consistent-hashing.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import hashlib
import bisect
from typing import List, Optional
 
class ConsistentHashRing:
    """
    Consistent hashing implementation for shard routing.
    
    Key property: Adding/removing a shard only affects
    keys in the immediate vicinity on the ring.
    """
    
    def __init__(self):
        self.ring = {}  # position -> shard_id
        self.sorted_positions = []
    
    def _hash(self, key: str) -> int:
        """Hash to ring position (0 to 2^32 - 1)"""
        digest = hashlib.md5(key.encode()).digest()
        return int.from_bytes(digest[:4], byteorder='big')
    
    def add_shard(self, shard_id: str):
        """Add a shard to the ring."""
        position = self._hash(shard_id)
        self.ring[position] = shard_id
        self.sorted_positions = sorted(self.ring.keys())
        return position
    
    def remove_shard(self, shard_id: str):
        """Remove a shard from the ring."""
        position = self._hash(shard_id)
        if position in self.ring:
            del self.ring[position]
            self.sorted_positions = sorted(self.ring.keys())
    
    def get_shard(self, key: str) -> str:
        """Find the shard responsible for a key."""
        if not self.ring:
            raise ValueError("No shards in ring")
        
        key_position = self._hash(key)
        
        # Find first shard position >= key position (clockwise walk)
        idx = bisect.bisect(self.sorted_positions, key_position)
        
        # Wrap around if necessary
        if idx >= len(self.sorted_positions):
            idx = 0
        
        shard_position = self.sorted_positions[idx]
        return self.ring[shard_position]
 
# Demonstration
ring = ConsistentHashRing()
for i in range(4):
    ring.add_shard(f"shard-{i}")
 
# Track key assignments
assignments_before = {f"key-{i}": ring.get_shard(f"key-{i}") 
                      for i in range(1000)}
 
# Add a new shard
ring.add_shard("shard-4")
 
# Check how many keys moved
assignments_after = {f"key-{i}": ring.get_shard(f"key-{i}") 
                     for i in range(1000)}
 
moved = sum(1 for k in assignments_before 
            if assignments_before[k] != assignments_after[k])
 
print(f"Keys that changed assignment: {moved}/1000 ({moved/10:.1f}%)")
# Output: Keys that changed assignment: ~200/1000 (~20%)
# Only ~1/5 of keys moved when adding 1 shard to 4 existing!

Why Consistent Hashing Minimizes Movement:

When a shard is added:

Only keys between the new shard and its clockwise neighbor move
Other keys are unaffected
Expected movement: 1/(n+1) of keys, where n is current shard count

For 100 → 101 shards: ~1% of keys move (vs. ~99% with simple modulo!)

Mathematical Property:

Adding k shards to n shards moves at most k/(n+k) of keys
Removing k shards from n shards moves at most k/n of keys
This is optimal—you can't do better without moving data unnecessarily

From O(n) to O(1/n)

Simple modulo: O(n) data movement on resize. Consistent hashing: O(1/n) data movement. This isn't an optimization—it's a fundamental change that makes online scaling practical for the first time.

Virtual Nodes: Solving Consistent Hashing's Imbalance Problem

The Problem Illustrated:

With 4 shards randomly positioned on a ring:

Best case: Each shard covers 25% of the ring (perfect)
Worst case: One shard might cover 50%+ of the ring (2x load)
The variance is high for small numbers of physical shards

The Virtual Nodes Solution:

Instead of placing each physical shard at one ring position, create multiple virtual nodes for each physical shard. With 100 virtual nodes per shard:

4 physical shards → 400 ring positions
Each physical shard spread across 100 arc segments
Law of large numbers kicks in → near-uniform distribution

virtual-nodes.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import hashlib
import bisect
from collections import defaultdict
 
class VirtualNodeConsistentHash:
    """
    Consistent hashing with virtual nodes for balanced distribution.
    
    Each physical shard maps to many positions on the ring,
    spreading its coverage evenly.
    """
    
    def __init__(self, virtual_nodes_per_shard: int = 150):
        self.virtual_nodes = virtual_nodes_per_shard
        self.ring = {}  # position -> physical_shard_id
        self.sorted_positions = []
        self.shard_positions = defaultdict(list)  # shard_id -> [positions]
    
    def _hash(self, key: str) -> int:
        digest = hashlib.md5(key.encode()).digest()
        return int.from_bytes(digest[:4], byteorder='big')
    
    def add_shard(self, shard_id: str):
        """Add shard with virtual nodes."""
        for v in range(self.virtual_nodes):
            # Each virtual node has a unique identifier
            virtual_key = f"{shard_id}:vnode:{v}"
            position = self._hash(virtual_key)
            self.ring[position] = shard_id
            self.shard_positions[shard_id].append(position)
        
        self.sorted_positions = sorted(self.ring.keys())
    
    def remove_shard(self, shard_id: str):
        """Remove all virtual nodes for a shard."""
        for position in self.shard_positions[shard_id]:
            if position in self.ring:
                del self.ring[position]
        del self.shard_positions[shard_id]
        self.sorted_positions = sorted(self.ring.keys())
    
    def get_shard(self, key: str) -> str:
        """Find the physical shard for a key."""
        if not self.ring:
            raise ValueError("No shards in ring")
        
        key_position = self._hash(key)
        idx = bisect.bisect(self.sorted_positions, key_position)
        if idx >= len(self.sorted_positions):
            idx = 0
        
        return self.ring[self.sorted_positions[idx]]
    
    def get_distribution(self, num_keys: int = 100000) -> dict:
        """Analyze key distribution across physical shards."""
        counts = defaultdict(int)
        for i in range(num_keys):
            shard = self.get_shard(f"test-key-{i}")
            counts[shard] += 1
        
        total = sum(counts.values())
        return {
            shard: {
                'count': count,
                'percentage': count * 100 / total,
                'deviation': abs(count / (total / len(counts)) - 1) * 100
            }
            for shard, count in counts.items()
        }
 
# Compare distribution with different virtual node counts
for vnodes in [1, 10, 50, 150, 500]:
    ring = VirtualNodeConsistentHash(virtual_nodes_per_shard=vnodes)
    for i in range(8):
        ring.add_shard(f"shard-{i}")
    
    dist = ring.get_distribution(100000)
    max_dev = max(d['deviation'] for d in dist.values())
    min_pct = min(d['percentage'] for d in dist.values())
    max_pct = max(d['percentage'] for d in dist.values())
    
    print(f"VNodes={vnodes:3}: "
          f"Range {min_pct:.1f}%-{max_pct:.1f}%, "
          f"Max Deviation: {max_dev:.1f}%")
 
# Output:
# VNodes=  1: Range 3.2%-21.8%, Max Deviation: 74.5%
# VNodes= 10: Range 9.8%-15.2%, Max Deviation: 21.6%  
# VNodes= 50: Range 11.5%-13.2%, Max Deviation: 6.0%
# VNodes=150: Range 11.9%-12.9%, Max Deviation: 3.0%
# VNodes=500: Range 12.1%-12.7%, Max Deviation: 1.5%

Virtual Nodes Impact on Distribution
Virtual Nodes	Min Shard %	Max Shard %	Max Deviation	Memory Overhead
1 (basic)	3%	22%	74%	Minimal
10	10%	15%	22%	Low
50	11%	13%	6%	Moderate
150	12%	13%	3%	Higher
500	12%	13%	1.5%	Significant

Virtual Node Tuning

Hash Sharding Implementation Patterns

Production hash sharding implementations must handle routing, replication, and failure scenarios. Here are battle-tested patterns.

Pattern 1: Routing with Replication

In replicated systems, each key maps to multiple shards (replicas). Consistent hashing naturally supports this:

replicated-routing.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class ReplicatedHashRouter:
    """
    Hash routing with replication factor.
    Each key maps to N consecutive shards on the ring.
    """
    
    def __init__(self, replication_factor: int = 3):
        self.rf = replication_factor
        self.ring = VirtualNodeConsistentHash()
    
    def get_replicas(self, key: str) -> list:
        """
        Get the list of shards that store replicas of this key.
        Returns replication_factor distinct physical shards.
        """
        if len(self.ring.sorted_positions) == 0:
            raise ValueError("No shards available")
        
        key_pos = self.ring._hash(key)
        idx = bisect.bisect(self.ring.sorted_positions, key_pos)
        
        replicas = []
        seen_shards = set()
        positions = len(self.ring.sorted_positions)
        
        # Walk clockwise until we have enough distinct shards
        for i in range(positions):
            pos = self.ring.sorted_positions[(idx + i) % positions]
            shard = self.ring.ring[pos]
            
            if shard not in seen_shards:
                replicas.append(shard)
                seen_shards.add(shard)
                
                if len(replicas) >= self.rf:
                    break
        
        return replicas
    
    def get_primary(self, key: str) -> str:
        """First replica is the primary."""
        return self.get_replicas(key)[0]
    
    def route_read(self, key: str, consistency: str = 'one') -> list:
        """
        Route a read request based on consistency level.
        """
        replicas = self.get_replicas(key)
        
        if consistency == 'one':
            return [replicas[0]]  # Any single replica
        elif consistency == 'quorum':
            return replicas[:len(replicas) // 2 + 1]  # Majority
        elif consistency == 'all':
            return replicas  # All replicas must respond
    
    def route_write(self, key: str, consistency: str = 'quorum') -> list:
        """
        Route a write request based on consistency level.
        """
        replicas = self.get_replicas(key)
        
        if consistency == 'one':
            return [replicas[0]]
        elif consistency == 'quorum':
            return replicas[:len(replicas) // 2 + 1]
        elif consistency == 'all':
            return replicas

Pattern 2: Token-Based Partitioning

Some systems (Cassandra, Riak) use explicit token assignments rather than hashing shard names:

# Each shard owns a token range
token_ranges = [
    {'shard': 'shard-1', 'start': 0, 'end': 2**32 // 4},
    {'shard': 'shard-2', 'start': 2**32 // 4, 'end': 2**32 // 2},
    {'shard': 'shard-3', 'start': 2**32 // 2, 'end': 3 * 2**32 // 4},
    {'shard': 'shard-4', 'start': 3 * 2**32 // 4, 'end': 2**32},
]

def route(key):
    token = hash(key)
    for range in token_ranges:
        if range['start'] <= token < range['end']:
            return range['shard']

Benefits of Token Ranges:

Explicit control over data placement
Can manually balance by adjusting ranges
Easier to reason about for operators

Pattern 3: Jump Consistent Hashing

Google's Jump Consistent Hash achieves perfect balance with no memory overhead:

jump-hash.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def jump_consistent_hash(key: int, num_buckets: int) -> int:
    """
    Google's Jump Consistent Hash algorithm.
    
    Properties:
    - O(1) memory (no ring to store)
    - Perfect balance across buckets
    - Minimal key movement when buckets change
    - O(log n) computation time
    
    When num_buckets increases from n to n+1:
    - Only keys on bucket n-1 might move to bucket n
    - Expected movement: 1/(n+1) of keys
    """
    if num_buckets <= 0:
        raise ValueError("num_buckets must be positive")
    
    # Use 64-bit arithmetic
    key = key & 0xFFFFFFFFFFFFFFFF
    
    b = -1
    j = 0
    
    while j < num_buckets:
        b = j
        key = ((key * 2862933555777941757) + 1) & 0xFFFFFFFFFFFFFFFF
        j = int((b + 1) * (float(1 << 31) / float((key >> 33) + 1)))
    
    return b
 
# Usage
def route_key(key_string: str, num_shards: int) -> int:
    # Convert string key to integer
    key_hash = int(hashlib.md5(key_string.encode()).hexdigest(), 16)
    return jump_consistent_hash(key_hash, num_shards)
 
# Test distribution
from collections import Counter
shards = Counter()
for i in range(100000):
    shard = route_key(f"key-{i}", 8)
    shards[shard] += 1
 
print("Jump Hash Distribution (100K keys, 8 shards):")
for shard in sorted(shards):
    pct = shards[shard] / 1000
    print(f"  Shard {shard}: {shards[shard]:,} ({pct:.2f}%)")
# Perfect 12.5% distribution guaranteed!

When to Use Jump Hash

Production Considerations for Hash-Sharded Systems

Operating hash-sharded systems in production requires attention to several critical concerns.

Range Query Strategies:

Hash sharding scatters related keys, making range queries expensive. Strategies for systems needing both:

Secondary Index per Shard
- Each shard maintains local indexes for range-queryable fields
- Scatter-gather for range queries, but with index acceleration
Dedicated Range-Ordered Replica
- Maintain a separate replica set ordered by a range key
- Route range queries to that replica set
Composite Key Strategy
- Hash prefix for distribution: hash(user_id)
- Range suffix for ordering: timestamp
- Keys: {hash(user_id)}:{timestamp}
- Range queries within a user are efficient

Hash Sharding Operational Metrics
Metric	Healthy	Warning	Critical	Action
Shard load variance	< 10%	10-25%	25%	Check for hot keys, increase vnodes
Cross-shard query rate	< 20%	20-50%	50%	Review shard key, consider colocation
Ring metadata sync lag	< 1s	1-10s	10s	Check metadata store health
Key distribution skew	< 5%	5-15%	15%	Analyze key cardinality, check hot keys
Rebalance data pending	< 5%	5-20%	20%	Monitor rebalance progress, check bandwidth

Hot Key Handling:

Even with perfect hash distribution, application-level hotspots can emerge:

# Problem: Celebrity user with millions of followers
# All followers query user_id='celebrity123'
# That hash slot becomes a hotspot

# Solution 1: Request-level caching
@cache(ttl=60)
def get_user(user_id):
    return db.query(f"SELECT * FROM users WHERE id = {user_id}")

# Solution 2: Key spreading with random suffixes
def spread_hot_key(user_id, num_copies=10):
    suffix = random.randint(0, num_copies - 1)
    return f"{user_id}:{suffix}"

# Solution 3: Dedicated shard for hot keys
HOT_KEYS = {'celebrity123', 'viral_post_456', ...}
if key in HOT_KEYS:
    return hot_key_shard  # Special high-capacity shard

Graceful Shard Failures:

With consistent hashing, shard failures redistribute load to neighbors:

Before failure: Shard C handles keys in range [X, Y)
After Shard C fails: Keys [X, Y) move to Shard D (next on ring)
Shard D load increases by ~33% (for RF=3)

Mitigation:
- Virtual nodes spread the load increase across multiple shards
- Replication ensures no data loss
- Auto-scaling can quickly add replacement capacity

The Hottest Key Is Your Bottleneck

Summary: Hash Sharding Mastery

Hash sharding leverages mathematical uniformity to create automatically balanced distributed databases. Let's consolidate the key principles:

Key Takeaways

•Hash functions transform any key pattern into uniform distribution — Sequential IDs, timestamps, clustered values all become evenly spread across shards.
•Simple modulo hashing fails at scale — Adding or removing shards causes massive data movement (~100%). Never use for production systems that need to scale.
•Consistent hashing enables elastic scaling — Adding a shard moves only 1/n of data. This makes online scaling practical for the first time.
•Virtual nodes solve the small-cluster imbalance problem — 150+ virtual nodes per shard creates near-perfect distribution regardless of physical shard count.
•Hash sharding sacrifices range queries for balance — Range queries require scatter-gather. Use composite keys or secondary strategies when ranges matter.
•Hot keys bypass all distribution guarantees — Application-level caching, key spreading, or dedicated handling is required for extremely popular keys.

What's Next:

Page Complete

4 / 5