En el procesamiento de datos, a menudo surge la necesidad de almacenar y consultar eficientemente grandes volúmenes de datos booleanos. Redis, una base de datos en memoria de alto rendimiento, proporciona una estructura de datos Bitmap específicamente para este propósito. Esencialmente, un Bitmap es una secuencia de bytes donde cada bit individual puede establecerse en 0 o 1. Esto permite un almacenamiento extremadamente compacto y operaciones a nivel de bit eficientes para estadísticas a gran escala, como el aálisis de comportamiento de usuario, el monitoreo del estado del sistema y la compresión de datos.

Estructura de Almacenamiento y Principios

Representación como Arreglo de Bits

Un Bitmap de Redis se almacena internamente como un valor de tipo string (cadena de bytes). Un byte contiene 8 bits. Al ejecutar un comando como SETBIT en un desplazamiento (offset) específico, Redis calcula el byte objetivo dentro de la cadena y la posición del bit dentro de ese byte para realizar la modificación.

Expansión Dinámica

Los Bitmaps se expanden automáticamente. Si se realiza un SETBIT en un desplazamiento que excede la longitud actual del bitmap, Redis ampliará la cadena de bytes subyacente para acomodar el nuevo bit, asegurando el espacio necesario.

Eficiencia en el Uso de Memoria

La principal ventaja de un Bitmap es su densidad de almacenamiento. Almacenar un millón de indicadores booleanos como un bitmap consume aproximadamente 125 KB (1.000.000 / 8 bytes), frente a múltiples megabytes si se usaran valores de tipo entero o cadenas cortas para cada uno. La eficiencia mejora con el tamaño del conjunto de datos.

Operaciones Fundamentales

Establecer y Leer Bits Individaules

SETBIT: Asigna un valor (0 o 1) a un desplazamiento específico.
GETBIT: Recupera el valor del bit en un desplazamiento dado.

// Ejemplo conceptual en pseudocódigo
SETBIT seguimiento_usuarios:u9876 20231015 1  // Marca al usuario u9876 como activo en la fecha codificada
GETBIT seguimiento_usuarios:u9876 20231015    // Verifica si el usuario estuvo activo ese día

Contar Bits y Operaciones Lógicas

BITCOUNT: Cuenta la cantidad de bits estbalecidos en 1 dentro de un rango (o toda la cadena).

BITCOUNT metricas_sistema:servidor_web_1

BITOP: Ejecuta operaciones lógicas a nivel de bit (AND, OR, XOR, NOT) entre múltiples bitmaps.

// Encuentra días donde ambos servidores estuvieron activos
BITOP AND interseccion:web1_web2 metricas_sistema:servidor_web_1 metricas_sistema:servidor_web_2
// Cuenta los días de intersección
BITCOUNT interseccion:web1_web2

Casos de Uso Prácticos

Analítica de Actividad de Usuarios

Para rastrear la actividad diaria, cada bit en un bitmap puede representar un día. El comando BITCOUNT proporciona rápidamente el total de días activos. Las operaciones BITOP permiten analizar la intersección de actividad entre usuarios, útil para recomendaciones o segmentación.

Monitoreo de Estado de Infraestructura

Cada bit puede indicar el estado (1 = activo, 0 = inactivo) de un servidor en un instante de tiempo. BITCOUNT calcula el uptime, y BITOP OR permite detectar si algún nodo en un clúster falló durante un período específico.

Ejemplo de Implementación en Go

El siguiente código demuestra el uso de la biblioteca go-redis/v8 para operaciones comunes con Bitmaps. Se han modificado los nombres de variables y claves para diferenciarlo.

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/redis/go-redis/v9"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // sin contraseña
		DB:       0,  // base de datos predeterminada
	})
	defer rdb.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// Verificar la conexión
	if err := rdb.Ping(ctx).Err(); err != nil {
		log.Fatalf("No se pudo conectar a Redis: %v", err)
	}
	fmt.Println("Conexión a Redis establecida")

	// Definir claves
	claveBitMap := "datos_monitor:app_frontend"
	desplazamiento1 := uint(1500)
	desplazamiento2 := uint(1501)

	// Limpiar datos previos para el ejemplo
	rdb.Del(ctx, claveBitMap)

	// Operación SETBIT: Marcar eventos
	if err := rdb.SetBit(ctx, claveBitMap, desplazamiento1, 1).Err(); err != nil {
		log.Printf("Error en SETBIT: %v", err)
	}
	rdb.SetBit(ctx, claveBitMap, desplazamiento2, 1) // Otro evento

	// Operación GETBIT: Consultar un evento específico
	valor, err := rdb.GetBit(ctx, claveBitMap, desplazamiento1).Result()
	if err != nil {
		log.Printf("Error en GETBIT: %v", err)
	}
	fmt.Printf("Valor en desplazamiento %d: %d\n", desplazamiento1, valor)

	// Operación BITCOUNT: Contar eventos totales
	totalEventos, err := rdb.BitCount(ctx, claveBitMap, &redis.BitCount{Start: 0, End: -1}).Result()
	if err != nil {
		log.Printf("Error en BITCOUNT: %v", err)
	}
	fmt.Printf("Total de eventos registrados: %d\n", totalEventos)

	// Operación BITOP: Combinar bitmaps
	claveBitMapA := "estado_sistema:region_A"
	claveBitMapB := "estado_sistema:region_B"
	claveResultado := "estado_sistema:region_union"

	// Supongamos que ya existen datos en claveBitMapA y claveBitMapB
	rdb.SetBit(ctx, claveBitMapA, 100, 1)
	rdb.SetBit(ctx, claveBitMapB, 100, 1) // Mismo desplazamiento activo en ambas

	if err := rdb.BitOp(ctx, "OR", claveResultado, claveBitMapA, claveBitMapB).Err(); err != nil {
		log.Printf("Error en BITOP: %v", err)
	}

	unionCount, _ := rdb.BitCount(ctx, claveResultado, nil).Result()
	fmt.Printf("Bits activos en la unión OR: %d\n", unionCount)
}