Lesson 3
Handling Transactions with Pipelines in C++ Using Hiredis
Handling Transactions with Pipelines in C++

Welcome back! We're advancing in our Redis-based backend system project by tackling transactions using pipelines. This enhancement allows us to execute multiple Redis commands as a single atomic operation. You should already be comfortable with managing user data and leaderboards. This unit will optimize these operations using pipelines.

What You'll Build

Before we proceed, let's outline the primary focus of this unit. The key tasks include:

  1. Adding user data with expiration using pipelines: We will group multiple commands into one pipeline to add user data more efficiently.
  2. Adding scores to a leaderboard using pipelines: Using pipelines ensures that these operations are executed atomically.
  3. Executing the pipeline: We'll execute the grouped commands within the pipeline as a single operation.

These tasks demonstrate how pipelines can enhance performance and consistency in our Redis operations.

Example for Pipelines

Below is an example of how to implement pipelines in C++ using the hiredis library:

C++
1#include <iostream>
2#include <hiredis/hiredis.h>
3#include <vector>
4
5// Structure to hold user data
6struct User {
7    std::string username;
8    std::string name;
9    int age;
10    std::string email;
11};
12
13int main() {
14    // Connect to the Redis server
15    redisContext* context = redisConnect("127.0.0.1", 6379);
16    if (context == nullptr || context->err) {
17        if (context) {
18            std::cerr << "Connection error: " << context->errstr << std::endl;
19        } else {
20            std::cerr << "Connection error: can't allocate Redis context" << std::endl;
21        }
22        return 1;
23    }
24
25    // Prepare users data
26    std::vector<User> users = {
27        {"alice", "Alice", 30, "alice@example.com"},
28        {"bob", "Bob", 25, "bob@example.com"}
29    };
30
31    // Add user data using pipeline
32    for (const auto& user : users) {
33        redisAppendCommand(context, "SETEX user:%s 86400 %s:%d:%s", 
34                           user.username.c_str(), user.name.c_str(), user.age, user.email.c_str());
35    }
36
37    // Execute all commands in the pipeline
38    for (size_t i = 0; i < users.size(); ++i) {
39        redisReply* reply;
40        if (redisGetReply(context, (void**)&reply) == REDIS_OK && reply) {
41            std::cout << "Pipeline result: " << reply->str << std::endl;
42            freeReplyObject(reply);
43        } else {
44            std::cerr << "Pipeline execution failed." << std::endl;
45        }
46    }
47
48    // Verify by getting one user's data
49    redisReply* reply = (redisReply*)redisCommand(context, "GET user:alice");
50    if (reply->type == REDIS_REPLY_STRING) {
51        std::cout << "Stored string in Redis: " << reply->str << std::endl;
52    } else {
53        std::cout << "Failed to retrieve the value." << std::endl;
54    }
55    freeReplyObject(reply);
56
57    // Free the context
58    redisFree(context);
59
60    return 0;
61}

In this code, all commands appended to the pipeline are sent to the Redis server in one batch, which optimizes network usage and ensures atomic execution when redisGetReply() is called.

Let's start building efficient backend systems with this approach!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.