db.redis #
Redis Client for V
This module provides a Redis client implementation in V that supports the Redis Serialization Protocol (RESP) with a type-safe interface for common Redis commands.
Features
- Type-Safe Commands: Auto-detects value types at compile time
- Pipeline Support: Group commands for batch execution
- Connection Pooling: Efficient resource management
- RESP Protocol Support: Full Redis Serialization Protocol implementation
- Memory Efficient: Pre-allocated buffers for minimal allocations
Quick Start
module main
import db.redis
fn main() {
// Connect to Redis
mut db := redis.connect(redis.Config{
host: 'localhost'
port: 6379
})!
// Set and get values
db.set('name', 'Alice')!
name := db.get[string]('name')!
println('Name: ${name}') // Output: Name: Alice
// Integer operations
db.set('counter', 42)!
db.incr('counter')!
counter := db.get[int]('counter')!
println('Counter: ${counter}') // Output: Counter: 43
// Clean up
db.close()!
}
Supported Commands
Key Operations
// Set value
db.set('key', 'value')!
db.set('number', 42)!
db.set('binary', []u8{len: 4, init: 0})!
// Get value
str_value := db.get[string]('key')!
int_value := db.get[int]('number')!
bin_value := db.get[[]u8]('binary')!
// Delete key
db.del('key')!
// Set expiration
db.expire('key', 60)! // 60 seconds
Hash Operations
// Set hash fields
db.hset('user:1', {
'name': 'Bob',
'age': 30,
})!
// Get single field
name := db.hget[string]('user:1', 'name')!
// Get all fields
user_data := db.hgetall[string]('user:1')!
println(user_data) // Output: {'name': 'Bob', 'age': '30'}
Pipeline Operations
// Start pipeline
db.pipeline_start()
// Queue commands
db.incr('counter')
db.set('name', 'Charlie')
db.get[string]('name')
// Execute and get responses
responses := db.pipeline_execute()!
for resp in responses {
println(resp)
}
Custom Commands
// Run raw commands
resp := db.cmd('SET', 'custom', 'value')!
result := db.cmd('GET', 'custom')!
// Complex commands
db.cmd('HSET', 'user:2', 'field1', 'value1', 'field2', '42')!
Error Handling
All functions return !
types and will return detailed errors for:
- Connection issues
- Protocol violations
- Type mismatches
- Redis error responses
- Timeout conditions
result := db.get[string]('nonexistent') or {
println('Key not found')
return
}
Connection Management
config := redis.Config{
host: 'redis.server'
port: 6379
version: 2 // RESP2 protocol
}
mut db := redis.connect(config)!
defer {
db.close() or { eprintln('Error closing connection: $err') }
}
Performance Tips
- Reuse Connections: Maintain connections instead of creating new ones
- Use Pipelines: Batch commands for high-throughput operations
- Prefer Integers: Use numeric types for counters and metrics
- Specify Types: Always specify return types for get operations
fn connect #
fn connect(config Config) !DB
connect establishes a connection to a Redis server
type RedisValue #
type RedisValue = string | i64 | bool | f32 | f64 | []u8 | RedisNull | []RedisValue
RedisValue represents all possible RESP (Redis Serialization Protocol) data types
struct Config #
struct Config {
pub mut:
host string = '127.0.0.1' // Redis server host
port u16 = 6379 // Redis server port
version int = 2 // RESP protocol version (default: v2)
}
Configuration options for Redis connection
struct DB #
struct DB {
pub mut:
version int // RESP protocol version
mut:
conn &net.TcpConn = unsafe { nil } // TCP connection to Redis
// Pre-allocated buffers to reduce memory allocations
cmd_buf []u8 // Buffer for building commands
resp_buf []u8 // Buffer for reading responses
pipeline_mode bool
pipeline_buffer []u8
pipeline_cmd_count int
}
DB represents a Redis database connection
fn (DB) close #
fn (mut db DB) close() !
close terminates the connection to Redis server
fn (DB) ping #
fn (mut db DB) ping() !string
ping sends a PING command to verify server responsiveness
fn (DB) del #
fn (mut db DB) del(key string) !i64
del deletes a key
fn (DB) set #
fn (mut db DB) set[T](key string, value T) !string
set stores a key
-value` pair in Redis. Supported value types: number, string, []u8
fn (DB) get #
fn (mut db DB) get[T](key string) !T
get retrieves the value of a key
. Supported return types: string, int, []u8
fn (DB) incr #
fn (mut db DB) incr(key string) !i64
incr increments the integer value of a key
by 1
fn (DB) decr #
fn (mut db DB) decr(key string) !i64
decr decrements the integer value of a key
by 1
fn (DB) hset #
fn (mut db DB) hset[T](key string, m map[string]T) !int
hset sets multiple key
-value
pairs in a hash. Supported value types: string, int, []u8
fn (DB) hget #
fn (mut db DB) hget[T](key string, m_key string) !T
hget retrieves the value of a hash field. Supported return types: string, int, []u8
fn (DB) hgetall #
fn (mut db DB) hgetall[T](key string) !map[string]T
hgetall retrieves all fields and values of a hash. Supported value types: string, int, []u8
fn (DB) expire #
fn (mut db DB) expire(key string, seconds int) !bool
expire sets a key
's time to live in seconds
fn (DB) cmd #
fn (mut db DB) cmd(cmd ...string) !RedisValue
cmd sends a custom command to Redis server for example: db.cmd('SET', 'key', 'value')!
fn (DB) pipeline_start #
fn (mut db DB) pipeline_start()
pipeline_start start a new pipeline
fn (DB) pipeline_execute #
fn (mut db DB) pipeline_execute() ![]RedisValue
pipeline_execute executes the cmds in pipeline at once and retrieves all responses
struct RedisNull #
struct RedisNull {}
RedisNull represents the Redis NULL type