Caching Database Queries in PHP with Redis for Speed Optimization

zeroexp.dev ZeroonLeave a Comment on Caching Database Queries in PHP with Redis for Speed Optimization
Caching Database Queries in PHP with Redis for Speed Optimization

Learn how to cache database queries in PHP using Redis. Improve performance by reducing database load and serving cached results efficiently.

Introduction

Databases are often the performance bottleneck in web applications, especially when handling frequent queries. Instead of querying the database repeatedly, caching results in Redis reduces load times, server strain, and overall response time.

Redis provides an in-memory cache that allows PHP applications to:

  • Store query results temporarily
  • Retrieve cached data quickly
  • Expire old or stale data automatically

This guide covers:

  • Setting up Redis for query caching
  • Implementing cache-first logic in PHP
  • Expiring and refreshing cached database results
  • Best practices for caching queries effectively

1. Why Cache Database Queries with Redis?

Caching database queries with Redis provides:

  • Faster response times by avoiding redundant queries
  • Lower database server load by reducing repeated queries
  • Automatic expiration of cached results to prevent stale data
  • Better scalability by allowing frequent queries to be served from memory

2. Installing and Setting Up Redis for PHP Caching

Ensure Redis is installed and running on your system.

redis-cli ping

If Redis is running, it returns:

PONG

Install PHP Redis client:

For PHPRedis (C Extension):

sudo apt install php-redis  # Ubuntu/Debian
brew install php-redis      # macOS

For Predis (Pure PHP Client):

composer require predis/predis

3. Implementing Query Caching in PHP with Redis

A cache-first strategy checks Redis for a cached result before querying the database.

Step 1: Connect to Redis

Using PHPRedis

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

Using Predis

require 'vendor/autoload.php';

$redis = new Predis\Client();

Step 2: Check if Query Results Exist in Redis

$cacheKey = "users_list";
$cachedData = $redis->get($cacheKey);

if ($cachedData) {
    echo "Serving from cache: ";
    print_r(json_decode($cachedData, true));
    exit;
}

If the result exists in Redis, it is retrieved instantly without querying the database.

Step 3: Fetch from Database If No Cache Exists

$pdo = new PDO("mysql:host=localhost;dbname=mydb", "user", "password");
$query = $pdo->query("SELECT * FROM users");
$users = $query->fetchAll(PDO::FETCH_ASSOC);

Step 4: Store Query Results in Redis

$redis->setex($cacheKey, 600, json_encode($users)); // Cache expires in 10 minutes

This stores the query result for 10 minutes, preventing unnecessary database queries.

4. Expiring and Refreshing Cached Queries

Automatic Expiry

Using setex(), cached data expires automatically after a set time.

$redis->setex("users_list", 600, json_encode($users)); // Expires in 10 minutes

Manually Deleting Cache When Data Updates

When inserting, updating, or deleting data, remove outdated cache keys.

$redis->del("users_list"); // Deletes cached user list

This ensures new data is fetched from the database on the next request.

5. Handling Large Query Results Efficiently

Using Redis Hashes Instead of Single Keys

For large datasets, store individual records in a Redis hash instead of caching the entire result.

foreach ($users as $user) {
    $redis->hset("users_cache", $user['id'], json_encode($user));
}

Retrieve a single user efficiently:

$userData = json_decode($redis->hget("users_cache", 1), true);

Using Pagination with Redis Caching

For paginated queries, use cache keys per page.

$page = 1;
$cacheKey = "users_page_" . $page;

$cachedPage = $redis->get($cacheKey);
if ($cachedPage) {
    echo "Serving paginated results from cache.";
    print_r(json_decode($cachedPage, true));
    exit;
}

6. Best Practices for Query Caching with Redis

✅ Use unique cache keys per query to prevent conflicts.
✅ Set expiration times to remove outdated data automatically.
✅ Invalidate cache when data updates to maintain accuracy.
✅ Use Redis hashes for large datasets to store records individually.
✅ Monitor cache usage to prevent unnecessary memory consumption.

Conclusion

Caching database queries with Redis enhances PHP application performance by reducing repeated queries and optimizing response times.

This guide covered:

  • Setting up Redis for PHP query caching
  • Implementing a cache-first strategy to reduce database load
  • Using expiration and cache invalidation techniques
  • Handling large datasets with Redis hashes

By following these best practices, you can improve scalability and efficiency in your PHP applications.

Leave a Reply