How to use SCAN with the MATCH option in Predis

In Redis, using the SCAN command is an effective way to iterate through keys in the database, especially when dealing with a large number of keys. SCAN provides a non-blocking approach to incrementally retrieve keys. Predis, as a PHP Redis client, also supports this functionality. The SCAN command can be used with the MATCH option to filter keys matching a specific pattern, enabling more efficient retrieval of the required data.

1. Basic Usage

Before starting, ensure that you have installed Predis. You can install Predis via Composer:

bash
composer require predis/predis

Next, we create a Predis client instance and use the SCAN command to iterate through keys. Here is a basic example:

php
require 'vendor/autoload.php';

$client = new Predis\Client();

// Iterate through all keys using SCAN
$cursor = 0;
do {
    $result = $client->scan($cursor);
    $cursor = $result[0];
    $keys = $result[1];

    foreach ($keys as $key) {
        echo $key . PHP_EOL;
    }
} while ($cursor != 0);

2. Using the MATCH Option

If you want to find keys matching a specific pattern, you can use the MATCH option. Suppose we are only interested in keys starting with "user:": We can modify the code as follows:

php
require 'vendor/autoload.php';

$client = new Predis\Client();

// Iterate through all keys starting with "user:" 
$pattern = 'user:*';
$cursor = 0;
do {
    $result = $client->scan($cursor, 'MATCH', $pattern);
    $cursor = $result[0];
    $keys = $result[1];

    foreach ($keys as $key) {
        echo $key . PHP_EOL;
    }
} while ($cursor != 0);

In the code above, we add the 'MATCH' option and the $pattern parameter to the scan method. This instructs Redis to return only keys matching the specified pattern.

3. Practical Example

Suppose we are managing user data in an e-commerce platform, where key names are formatted as "user:id", with "id" being the unique identifier for the user. We can use Predis and the SCAN command to find all user keys and then perform further operations, such as checking user information or updating data.

php
require 'vendor/autoload.php';

$client = new Predis\Client();

$pattern = 'user:*';
$cursor = 0;
do {
    $result = $client->scan($cursor, 'MATCH', $pattern);
    $cursor = $result[0];
    $keys = $result[1];

    foreach ($keys as $key) {
        // You can add additional logic here, such as retrieving and processing user data
        echo "Found user key: " . $key . PHP_EOL;
    }
} while ($cursor != 0);

Summary

By using Predis's SCAN and MATCH features, we can efficiently process and query a large number of keys without imposing excessive load on the Redis server. This is crucial for maintaining large, dynamic datasets and ensuring application performance and responsiveness.

In Predis, SCAN is a command used to iterate over keys in the current database, providing a more efficient method than KEYS for handling large numbers of keys. MATCH is an option of the SCAN command that allows users to specify a pattern, returning only keys that match the pattern.

First, let's briefly cover the basic usage of the SCAN command. The SCAN command iterates using a cursor, returning a new cursor and a batch of keys on each invocation. Start with cursor 0 for the initial call, then use the returned cursor for subsequent calls until the returned cursor is 0, indicating completion.

Moving on to the MATCH option, it proves highly useful when you're only interested in keys matching a specific pattern. For instance, to find all keys starting with user:, you can use MATCH user:*.

Below, I'll illustrate how to combine SCAN and MATCH in Predis with a concrete example.

Assume we have multiple user keys starting with user: stored in a Redis database, and our task is to find all these user keys. Using Predis code might look like this:

php
<?php
require "vendor/autoload.php";

$predis = new Predis\Client();

$cursor = 0;
$pattern = 'user:*';

do {
    $result = $predis->scan($cursor, 'MATCH', $pattern);
    $cursor = $result[0];
    $keys = $result[1];

    foreach ($keys as $key) {
        echo $key . PHP_EOL;
    }
} while ($cursor);
?>

In this code snippet, we first set the initial cursor to 0 and define a matching pattern user:*. Then, we enter a do-while loop where we call $predis->scan() with the current cursor and matching pattern as parameters. The scan method returns an array where the first element is the new cursor and the second element is the array of found keys. We update the cursor and process the returned keys until the cursor is 0, indicating completion.

This example demonstrates how to efficiently search for keys matching a specific pattern in Redis while leveraging the iterative nature of the SCAN command to avoid performance issues that might arise from loading a large number of keys at once.

Using SCAN and MATCH options in Predis efficiently iterates through large Redis databases, especially when matching specific patterns. Here's a step-by-step guide on how to leverage these features in Predis.

1. Introducing the Predis Library

First, ensure Predis is installed, a flexible and feature-rich PHP Redis client. If not installed, use Composer:

bash
composer require predis/predis

2. Creating a Redis Client Instance

Next, create a Predis client instance to interact with the Redis server:

php
require 'vendor/autoload.php';

$client = new Predis\Client([
    'scheme' => 'tcp',
    'host'   => '127.0.0.1',
    'port'   => 6379,
]);

3. Using SCAN Command and MATCH Option

Predis supports all Redis commands, including SCAN. When using SCAN, we can pass the MATCH option to specify the pattern for keys to find. For example, to find all keys starting with "sess:", we can do:

php
$pattern = 'sess:*';
$cursor = 0;

do {
    // Using SCAN and MATCH options
    $result = $client->scan($cursor, 'MATCH', $pattern, 'COUNT', 100);
    $cursor = $result[0];
    $keys = $result[1];

    foreach ($keys as $key) {
        echo $key . PHP_EOL;
    }
} while ($cursor);

4. Explaining the Code

In the above code:

• We set the initial cursor to 0 and update it within the loop.
• We use the scan method for iteration, returning the current cursor and matched keys on each iteration.
• The MATCH option specifies the pattern for key names, here all keys prefixed with "sess:".
• The COUNT option specifies the maximum number of keys returned per iteration, which can be adjusted as needed.
• The loop continues until the cursor returns 0, signaling completion.

5. Handling Large Datasets

Using the SCAN command is recommended for handling large datasets, as it avoids the performance issues that KEYS might cause by loading all matching keys at once.

Summary

By leveraging Predis's SCAN and MATCH features, we can effectively manage large key spaces and search for keys by pattern. This approach is superior to using KEYS as it minimizes impact on server performance. In practical applications, adjusting the MATCH and COUNT parameters according to your needs can better control the iteration process.