Limitations

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

# What you CAN do:
user = kv_store.get("user:123")  # Exact key lookup
 
# What you CANNOT do:
# SQL equivalent: SELECT * FROM users WHERE email = 'alice@example.com'
# Key-value: No built-in way to do this!
 
# Workaround: Build and maintain secondary indexes manually
class UserStore:
    def create_user(self, user: dict):
        user_id = user["id"]
        # Primary storage
        self.kv.set(f"user:{user_id}", json.dumps(user))
        # Manual secondary index
        self.kv.set(f"user:email:{user['email']}", user_id)
    
    def get_by_email(self, email: str) -> dict:
        # Two lookups required
        user_id = self.kv.get(f"user:email:{email}")
        if not user_id:
            return None
        return json.loads(self.kv.get(f"user:{user_id}"))
    
    def update_email(self, user_id: str, new_email: str):
        user = json.loads(self.kv.get(f"user:{user_id}"))
        old_email = user["email"]
        
        # Must update both primary data AND index
        user["email"] = new_email
        self.kv.set(f"user:{user_id}", json.dumps(user))
        self.kv.delete(f"user:email:{old_email}")
        self.kv.set(f"user:email:{new_email}", user_id)
        # If any step fails, data is inconsistent!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# SQL: One query with JOIN
# SELECT u.name, o.id, o.total 
# FROM users u JOIN orders o ON u.id = o.user_id 
# WHERE u.id = 123
 
# Key-value: Multiple queries required
def get_user_with_orders(user_id: str):
    # Query 1: Get user
    user = json.loads(kv.get(f"user:{user_id}"))
    
    # Query 2: Get order IDs list
    order_ids = json.loads(kv.get(f"user:{user_id}:orders") or "[]")
    
    # Query 3+: Get each order (or use MGET)
    orders = []
    for order_id in order_ids:
        order = json.loads(kv.get(f"order:{order_id}"))
        orders.append(order)
    
    return {"user": user, "orders": orders}
    # Minimum 3 round-trips vs 1 SQL query!
 
# Alternative: Denormalize (duplicate user info in orders)
# Trades storage/consistency for fewer queries

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

# Memory-conscious practices
 
# 1. Always set TTL on ephemeral data
redis.setex("cache:query:abc", 3600, result)  # Expires in 1 hour
 
# 2. Use appropriate data structures
# Hash with small values uses less memory than individual keys
redis.hset("user:123", mapping={"name": "Alice", "email": "a@b.com"})
# vs
redis.set("user:123:name", "Alice")
redis.set("user:123:email", "a@b.com")
 
# 3. Compress large values before storing
import zlib
compressed = zlib.compress(large_json.encode())
redis.set("large:data", compressed)
 
# 4. Use memory-efficient data types
# - Small hashes/sets/lists use ziplist encoding (dense)
# - Configure hash-max-ziplist-entries and similar settings
 
# 5. Monitor memory usage
info = redis.info("memory")
used_memory = info["used_memory"]
maxmemory = info["maxmemory"]
usage_percent = (used_memory / maxmemory) * 100

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

# Redis transaction limitation: No rollback on command error
 
pipe = redis.pipeline()
pipe.multi()
pipe.set("key1", "value1")        # Will succeed
pipe.incr("key2")                  # Will FAIL if key2 is not a number
pipe.set("key3", "value3")        # Still executes!
results = pipe.execute()
# Results: [True, ResponseError, True]
# key1 and key3 are set, key2 failed
# No automatic rollback!
 
# Workaround: Use Lua for true atomic operations
lua_script = """
local current = redis.call('GET', KEYS[1])
if current then
    local new_value = tonumber(current) + 1
    redis.call('SET', KEYS[1], new_value)
    redis.call('SET', KEYS[2], new_value)
    return new_value
else
    return nil
end
"""
# Entire script executes atomically with ability to abort