Implementación de Operaciones Comunes de Redis en C++ mediante redis-plus-plus

Para consultar la referencia completa de la API, se recomienda revisar el archivo de cabecera redis.h incluido en la biblioteca.

Instanciación del Cliente Redis

Toda interacción con el servidor requiere la creación de una instancia de la clase Redis, ubicada en el espacio de nombres sw::redis.

#include <iostream>
#include <sw/redis++/redis++.h>

int main() {
    sw::redis::Redis conexion("tcp://localhost:6379");
    std::string respuesta = conexion.ping();
    std::cout << "Respuesta del servidor: " << respuesta << std::endl;
    return 0;
}

El constructor acepta una URI con el formato tcp://host:puerto. El puerto predeterminado para Redis es el 6379. El método ping() es útil para verificar la conectividad y devuelve una cadena de texto.

Para compilar el proyecto, es necesario enlazar las dependencias de hiredis, redis++ y pthread:

g++ -o cliente_redis main.cpp -std=c++17 -lhiredis -lredis++ -lpthread

Operaciones Básicas de Cadenas

Almacenamiento y Recuperación (set & get)

#include <iostream>
#include <sw/redis++/redis++.h>

int main() {
    sw::redis::Redis conexion("tcp://localhost:6379");

    conexion.set("sesion:token", "abc123xyz");
    conexion.set("usuario:rol", "administrador");

    auto token = conexion.get("sesion:token");
    if (token) {
        std::cout << "Token obtenido: " << token.value() << std::endl;
    }

    auto clave_inexistente = conexion.get("datos:fantasma");
    // Llamar a clave_inexistente.value() directamente lanzaría std::bad_optional_access
    if (clave_inexistente) {
        std::cout << clave_inexistente.value() << std::endl;
    } else {
        std::cout << "La clave solicitada no está presente en la base de datos." << std::endl;
    }

    return 0;
}

El método get devuelve un objeto OptionalString. Si la clave no existe, intentar acceder a su valer mediante .value() provocará una excepción std::bad_optional_access. Para evitarlo, OptionalString soporta conversión implícita a bool, permitiendo validar su existencia antes de extraer el dato.

Gestión de Existencia y Eliminación

Verificación (exists)

La función exists comprueba si una o varias claves están presentes. Devuelve un entero largo (long long) que indica la cantidad de claves encontradas.

long long cantidad_individual = conexion.exists("sesion:token");
long long cantidad_multiple = conexion.exists({"sesion:token", "usuario:rol", "datos:fantasma"});

Gracias a la sobrecarga que acepta std::initializer_list, es posible evaluar múltiples claves en una sola llamada a la red.

Eliminación (del)

De manera similar, del elimina claves y retorna el número de elementos efectivamente borrados:

long long borrados_uno = conexion.del("sesion:token");
long long borrados_varios = conexion.del({"usuario:rol", "datos:fantasma"});

Limpieaz y Búsqueda de Patrones

Vaciado de Base de Datos (flushall)

El método flushall elimina todos los datos de todas las bases de datos del servidor. Su firma es void flushall(bool async = false);. Debe usarse exclusivamente en entornos de desarrollo o pruebas, ya que la operación es destructiva.

Búsqueda por Patrón (keys)

Para buscar claves que coincidan con un patrón glob, se utiliza keys. Esta función requiere un iterador de salida para almacenar los resultados, lo que permite desacoplar la biblioteca de los contenedores específicos de la STL.

#include <vector>
#include <iterator>

// ... dentro de main ...
std::vector<std::string> resultados;
conexion.keys("usuario:*", std::back_inserter(resultados));

for (const auto& clave : resultados) {
    std::cout << "Clave encontrada: " << clave << std::endl;
}

Los iteradores de inserción estándar facilitan esta tarea:

std::back_inserter(contenedor): Inserta al final.
std::front_inserter(contenedor): Inserta al principio.
std::inserter(contenedor, posicion): Inserta en una posición específica.

Control de Expiración y Tipos de Datos

Tiempo de Vida (ttl & expire)

El método expire asigna un tiempo de vida a una clave. Acepta tanto un entero largo (en segundos) como objetos de la biblioteca <chrono>.

#include <chrono>

conexion.set("cache:reporte", "datos_binarios");
conexion.expire("cache:reporte", 300); // 300 segundos
conexion.expire("cache:reporte", std::chrono::seconds(600));

long long tiempo_restante = conexion.ttl("cache:reporte");

Al consultar ttl, el servidor devuelve el tiempo restante en segundos. Si la clave no existe, retorna -2; si existe pero no tiene un tiempo de expiración asociado, retorna -1.

Identificación de Tipo (type)

Finalmente, para determinar la estructura de datos subyacente de una clave (como string, list, set, hash, etc.), se emplea type, el cual devuelve un objeto std::string con el nombre del tipo.

std::string estructura = conexion.type("cache:reporte");
std::cout << "Tipo de dato: " << estructura << std::endl;

Etiquetas: redis-plus-plus C++ hiredis Redis STL

Publicado el 7-30 07:32

Friki Work