Cache-aside (Lazy loading) Pattern

Lazy loading, also known as cache-aside, is the primary pattern used and involves attempting to read from the cache first. If the information is not in the cache, it is considered a cache miss and the system reads from the source data store. It's called "cache aside" because the cache sits on the side of the primary data store (like a database). The key idea is that the cache doesn’t actively manage the data; instead, the application is responsible for loading data into the cache when needed.

In a cache-aside pattern, the application is responsible for loading data into the cache when needed. Cache and database are both separate systems and do not interact with each other.

Steps:

1. Attempts to read from cache: When the application needs data, it first checks the cache to see if it's already available.
2. If not found, cache miss: If the data is not found in the cache, this is called a cache miss.
3. Read from data source and save in memory: When a cache miss occurs, the application fetches the data from the main data source (e.g., a database), saves it in the cache, and returns it to the user.

Let's create a Flask server that connects to the PostgreSQL database and uses Redis for caching with lazy loading pattern:

Imagine we have users and comments data stored in PostgreSQL like this:

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE
);

INSERT INTO users (name, email) VALUES
    ('Alice', 'alice@example.com'),
    ('Bob', 'bob@example.com'),
    ('Charlie', 'charlie@example.com');

CREATE TABLE comments (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    user_id INTEGER REFERENCES users(id)
);

INSERT INTO comments (content, user_id) VALUES
    ('Great post!', 1),
    ('Interesting read.', 1),
    ('Thanks for sharing!', 2),
    ('I learned something new today.', 2),
    ('Very insightful!', 3);

And our app uses this query to get user details

SELECT users.id, users.name, users.email, comments.id, comments.content
    FROM users
    JOIN comments ON users.id = comments.user_id
    WHERE users.name = %s AND users.email = %s;

Now let’s use the query as a cache key and implement lazy loading.

from flask import Flask, jsonify, request
import redis
import psycopg2
import json

app = Flask(__name__)

# Connect to Redis
cache = redis.Redis(host='localhost', port=6379, db=0)

# Database configuration
db_config = {
    "dbname": "your_database_name",
    "user": "your_user",
    "password": "your_password",
    "host": "your_host",
    "port": "your_port"
}

def fetch_data_from_database(name, email):
    conn = psycopg2.connect(**db_config)
    cursor = conn.cursor()

    query = '''
    SELECT users.id, users.name, users.email, comments.id, comments.content
    FROM users
    JOIN comments ON users.id = comments.user_id
    WHERE users.name = %s AND users.email = %s;
    '''

    cursor.execute(query, (name, email))
    data = cursor.fetchall()
    conn.close()

    return data

def get_data(name, email):
    # Generate a cache key from the query parameters
    cache_key = f"comments:name={name}:email={email}"
    data = cache.get(cache_key)

		# Cache miss
    if data is None:
        print(f"Fetching data for name={name} and email={email} from database...")
        data = fetch_data_from_database(name, email)
        if data:
            cache.set(cache_key, json.dumps(data), ex=600)  # Set a TTL of 600 seconds
        else:
            print(f"No comments found for name={name} and email={email}")
            return None
		# Cache hit
    else:
        print(f"Fetching data for name={name} and email={email} from cache...")
        data = json.loads(data.decode('utf-8'))

    return data

@app.route('/comments')
def get_comments():
    name = request.args.get('name', '')
    email = request.args.get('email', '')

    data = get_data(name, email)
    if data:
        return jsonify([
            {
                "user_id": row[0],
                "user_name": row[1],
                "user_email": row[2],
                "comment_id": row[3],
                "comment_content": row[4]
            }
            for row in data
        ])
    else:
        return jsonify({"error": f"No comments found for name={name} and email={email}"}), 404

if __name__ == '__main__':
    app.run(debug=True)SELECT users.id, users.name, users.email, comments.id, comments.content
    FROM users
    JOIN comments ON users.id = comments.user_id
    WHERE users.name = %s AND users.email = %s

Notice that there are several key concepts related to caching in the code: