Managing Key Expiration

Welcome back! In this lesson, we will explore a crucial feature of Redis : key expiration . This topic builds on our Redis knowledge and adds another tool to our kit for managing data efficiently in high-performance applications.

Understanding Key Expiration

Key expiration allows you to set a time limit on how long data remains in Redis. After the specified time elapses, Redis automatically removes the key and its value—you set it once, and Redis handles the cleanup for you. Time-to-Live (TTL) is the amount of time (in seconds) that a key has left before it expires. You can check a key's TTL at any time to see how much longer it will exist. This automatic cleanup is valuable for: Session Management : User sessions expire after inactivity Caching : Stale data refreshes periodically Rate Limiting : API counters reset after time windows Memory Management : Prevents Redis from filling up with outdated data

What You'll Learn

In this lesson, you will learn how to: Set keys with automatic expiration using the SET command with the EX option Check the remaining time-to-live (TTL) of a key and interpret the results Apply expiration to existing keys using the EXPIRE command Verify that keys expire automatically after the specified time Let's dive in and see how to implement these concepts using Boost.Redis's asynchronous interface.

Step 1: Setting Up the Connection

First, let's establish our connection to Redis: C++#include <boost/redis.hpp> #include <boost/redis/src.hpp> #include <boost/asio.hpp> #include <chrono> #include <iostream> #include <memory> namespace net = boost::asio; using boost::redis::connection; using boost::redis::config; using boost::redis::request; using boost::redis::logger; int main() { net::io_context ioc; auto conn = std::make_shared<connection>(ioc); config cfg; cfg.addr.host = "127.0.0.1"; cfg.addr.port = "6379"; // Start the connection conn->async_run(cfg, logger{logger::level::disabled}, net::consign(net::detached, conn)); This establishes a connection to Redis running on localhost at port 6379.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Step 2: Setting a Key with Expiration

Now let's set a key with an expiration time. The EX option in the SET command specifies the expiration time in seconds:

C++

    std::string key = "session:12345";

    // Create a request to SET key with expiration (EX 2) and then check TTL
    auto req1 = std::make_shared<request>();
    req1->push("SET", key, "data", "EX", "2"); // expire in 2 seconds
    req1->push("TTL", key);                    // get remaining TTL

    // Define response types for SET (returns string) and TTL (returns long long)
    using resp1_type = boost::redis::response<std::string, long long>;
    auto resp1 = std::make_shared<resp1_type>();

    conn->async_exec(*req1, *resp1,
        [conn, key, req1, resp1, &ioc](auto ec, auto)
        {
            if (ec) {
                std::cerr << "SET/TTL error: " << ec.message() << "\n";
                conn->cancel();
                return;
            }

            auto& set_res = std::get<0>(*resp1);
            auto& ttl_res = std::get<1>(*resp1);

            if (set_res.has_value())
                std::cout << "SET result: " << set_res.value() << "\n";

            if (ttl_res.has_value()) {
                long long ttl_value = ttl_res.value();
                if (ttl_value >= 0) {
                    std::cout << "Time-to-live for session key: " << ttl_value << " seconds\n";
                } else if (ttl_value == -1) {
                    std::cout << "Key exists and has no expiration (-1)\n";
                } else if (ttl_value == -2) {
                    std::cout << "Key does not exist (-2)\n";
                }
            } else {
                std::cout << "TTL not available.\n";
            }
            
            // Continue with next step...
        });

This code:

Creates a key (session:12345) with the value data that expires after 2 seconds using SET ... EX 2.
Immediately checks TTL to see how much time remains before expiration.
Interprets special TTL values:
- -2: key is missing (doesn't exist or already expired),
- -1: key exists but has no expiration set (will live forever),
- 0 or greater: remaining seconds until expiration.

Step 3: Waiting and Verifying Expiration

After setting the key with expiration, we wait 3 seconds (longer than the 2-second TTL) to verify that Redis has automatically removed the key:

C++

            // Wait 3 seconds and then GET the key to see if it has expired
            auto timer = std::make_shared<net::steady_timer>(ioc);
            timer->expires_after(std::chrono::seconds(3));
            timer->async_wait(
                [conn, timer, key](auto ec2)
                {
                    if (ec2) {
                        std::cerr << "Timer error: " << ec2.message() << "\n";
                        conn->cancel();
                        return;
                    }

                    auto req_get = std::make_shared<request>();
                    req_get->push("GET", key);

                    using resp_get_type = boost::redis::response<std::string>;
                    auto resp_get = std::make_shared<resp_get_type>();

                    conn->async_exec(*req_get, *resp_get,
                        [conn, key, req_get, resp_get](auto ec3, auto)
                        {
                            if (ec3) {
                                std::cerr << "GET error: " << ec3.message() << "\n";
                                conn->cancel();
                                return;
                            }

                            auto& get_res = std::get<0>(*resp_get);

                            if (get_res.has_value())
                                std::cout << "Value after 3 seconds: " << get_res.value() << "\n";
                            else
                                std::cout << "Value after 3 seconds: (nil) - key expired\n";
                            
                            // Continue with next step...
                        });
                });

This demonstrates the automatic cleanup: after 2 seconds, Redis removes the key, so when we check after 3 seconds, GET returns nil (no value). You didn't have to manually delete anything—Redis handled it for you.

Step 4: Setting Expiration on an Existing Key

Sometimes you need to add an expiration time to a key that already exists. The EXPIRE command allows you to set the TTL for a key after it has been created:

C++

                            // Create the key without expiration, then apply EXPIRE
                            auto req2 = std::make_shared<request>();
                            req2->push("SET", key, "data");   // no expiry yet
                            req2->push("EXPIRE", key, "2");   // set TTL = 2 seconds
                            req2->push("TTL", key);           // verify TTL

                            using resp2_type = boost::redis::response<std::string, long long, long long>;
                            auto resp2 = std::make_shared<resp2_type>();

                            conn->async_exec(*req2, *resp2,
                                [conn, key, req2, resp2](auto ec4, auto)
                                {
                                    if (ec4) {
                                        std::cerr << "SET/EXPIRE/TTL error: " << ec4.message() << "\n";
                                        conn->cancel();
                                        return;
                                    }

                                    auto& set_res2   = std::get<0>(*resp2);
                                    auto& expire_res = std::get<1>(*resp2);
                                    auto& ttl_res2   = std::get<2>(*resp2);

                                    std::cout << "\nSecond example (SET + EXPIRE):\n";

                                    if (set_res2.has_value())
                                        std::cout << "SET result: " << set_res2.value() << "\n";

                                    if (expire_res.has_value()) {
                                        long long expire_value = expire_res.value();
                                        std::cout << "EXPIRE result: " << expire_value
                                                  << " (1 = TTL set, 0 = key not found)\n";
                                    }

                                    if (ttl_res2.has_value()) {
                                        long long ttl_value2 = ttl_res2.value();
                                        if (ttl_value2 >= 0) {
                                            std::cout << "TTL after EXPIRE: " << ttl_value2 << " seconds\n";
                                        } else if (ttl_value2 == -1) {
                                            std::cout << "Key exists and has no expiration (-1)\n";
                                        } else if (ttl_value2 == -2) {
                                            std::cout << "Key does not exist (-2)\n";
                                        }
                                    }

                                    // Stop the connection and exit.
                                    conn->cancel();
                                });

This demonstrates:

First creating a key without any expiration (it would live forever)
Then using EXPIRE to add a 2-second TTL to the existing key
The EXPIRE command returns 1 if the TTL was set successfully, or 0 if the key wasn't found
Verifying the TTL was applied correctly

This two-step approach is useful when you want to control expiration separately from key creation, or when you need to update the TTL of an existing key.

Managing Key Expiration