Redis Introduction

# Connect to Redis CLI
redis-cli

# Check Redis is running
PING

# Set and get a simple string
SET greeting "Hello, Redis!"
GET greeting

# Set with expiry (60 seconds)
SET temp_key "I disappear soon" EX 60
TTL temp_key

# Check how many keys are in Redis
DBSIZE

# Delete a key
DEL greeting

# ZADD — add members with scores to a sorted set
ZADD leaderboard:tournament_9 9820 "player:ali"
ZADD leaderboard:tournament_9 8750 "player:sara"
ZADD leaderboard:tournament_9 9100 "player:james"
ZADD leaderboard:tournament_9 9950 "player:lin"

# Update a score — ZADD overwrites existing member's score
ZADD leaderboard:tournament_9 10200 "player:ali"

# Get top 3 players (highest scores first)
ZREVRANGE leaderboard:tournament_9 0 2 WITHSCORES

# Get a specific player's rank (0-indexed, lowest rank = best)
ZREVRANK leaderboard:tournament_9 "player:ali"

# Get a specific player's score
ZSCORE leaderboard:tournament_9 "player:sara"

# Get all players with scores between 9000 and 10000
ZRANGEBYSCORE leaderboard:tournament_9 9000 10000 WITHSCORES

import redis
import threading

r = redis.Redis(host='localhost', port=6379)

# SUBSCRIBER — runs in a separate thread/process
def listen_for_updates(order_id):
    pubsub = r.pubsub()
    pubsub.subscribe(f'order:updates:{order_id}')  # subscribe to channel

    print(f"Listening for updates on order {order_id}...")
    for message in pubsub.listen():
        if message['type'] == 'message':           # filter out subscribe confirmations
            print(f"Update received: {message['data'].decode()}")

# PUBLISHER — runs in your order service
def update_order_status(order_id, new_status):
    # Update the database first
    db.orders.update_one({'_id': order_id}, {'$set': {'status': new_status}})

    # Then publish the change to all subscribers
    channel = f'order:updates:{order_id}'
    message = f'{{"status": "{new_status}", "ts": "{datetime.now().isoformat()}"}}'
    subscriber_count = r.publish(channel, message)

    print(f"Published to {subscriber_count} subscribers")

import redis

r = redis.Redis(host='localhost', port=6379)

# Load 10,000 product prices in one pipeline batch
def bulk_load_prices(price_data):
    pipe = r.pipeline(transaction=False)  # transaction=False = faster, no MULTI/EXEC

    for product_id, price in price_data.items():
        pipe.set(f'price:{product_id}', price, ex=86400)  # expire in 24 hours

    results = pipe.execute()   # ALL commands sent in one network call
    return results.count(True) # count successful writes

def transfer_tokens(from_user, to_user, amount):
    with r.pipeline() as pipe:
        while True:
            try:
                # WATCH the sender's key — abort if it changes before EXEC
                pipe.watch(f'tokens:{from_user}')

                balance = int(pipe.get(f'tokens:{from_user}') or 0)
                if balance < amount:
                    raise ValueError("Insufficient tokens")

                # Queue the two writes atomically
                pipe.multi()                                          # start transaction
                pipe.decrby(f'tokens:{from_user}', amount)           # debit
                pipe.incrby(f'tokens:{to_user}',   amount)           # credit
                pipe.execute()                                        # run both atomically
                break

            except redis.WatchError:
                continue  # another client changed the key — retry

def get_product(product_id):
    cache_key = f"product:{product_id}"

    # Step 1: Check Redis first
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)          # cache hit — return immediately

    # Step 2: Cache miss — query PostgreSQL
    product = db.query("SELECT * FROM products WHERE id = %s", product_id)

    # Step 3: Store in Redis for next time (cache for 10 minutes)
    r.set(cache_key, json.dumps(product), ex=600)

    return product