Redisclient

basic example to connect to local redis on 127.0.0.1:6379

import freeflowuniverse.crystallib.clients.redisclient

mut redis := redisclient.core_get()!
redis.set('test', 'some data') or { panic('set' + err.str() + '\n' + c.str()) }
r := redis.get('test')?
if r != 'some data' {
    panic('get error different result.' + '\n' + c.str())
}

redis commands can be found on https://redis.io/commands/

fn core_get(url RedisURL) !Redis

fn get(addr string) !Redis

fn get_redis_url(url string) !RedisURL

fn new(addrs []string) !Redis

https://redis.io/topics/protocol examples: localhost:6379 /tmp/redis-default.sock

fn (mut r RedisInternal) read_line() !string

fn (mut r RedisInternal) disconnect()

enum KeyType {
	t_none
	t_string
	t_list
	t_set
	t_zset
	t_hash
	t_stream
	t_unknown
}

struct Message {
pub:
	ret_queue string
	now       i64
	cmd       string
	data      string
}

struct RPCArgs {
pub:
	cmd     string @[required]
	data    string @[required]
	timeout u64  = 60000 // 60 sec
	wait    bool = true
}

struct Redis {
pub:
	// current int
	connection_nr []int // is the position in the global
}

fn (mut r Redis) append(key string, value string) !int

fn (mut r Redis) blpop(keys []string, timeout f64) ![]string

fn (mut r Redis) brpop(keys []string, timeout f64) ![]string

fn (mut r Redis) cache(namespace string) RedisCache

return a cache object starting from a redis connection

fn (mut r Redis) decr(key string) !int

fn (mut r Redis) decrby(key string, decrement int) !int

fn (mut r Redis) del(key string) !int

fn (mut r Redis) exists(key string) !bool

fn (mut r Redis) expire(key string, seconds int) !int

fn (mut r Redis) expireat(key string, timestamp int) !int

fn (mut r Redis) flushall() !

fn (mut r Redis) flushdb() !

fn (mut r Redis) get(key string) !string

fn (mut r Redis) get_bool() !bool

fn (mut r Redis) get_bytes() ![]u8

fn (mut r Redis) get_bytes_nil() ![]u8

fn (mut r Redis) get_int() !int

Todo: needs to use the resp library

fn (mut r Redis) get_list_int() ![]int

fn (mut r Redis) get_list_str() ![]string

fn (mut r Redis) get_response() !resp.RValue

fn (mut r Redis) get_string() !string

fn (mut r Redis) get_string_nil() !string

fn (mut r Redis) getrange(key string, start int, end int) !string

fn (mut r Redis) getset(key string, value string) !string

fn (mut r Redis) hdel(key string, skey string) !int

fn (mut r Redis) hexists(key string, skey string) !bool

fn (mut r Redis) hget(key string, skey string) !string

fn (mut r Redis) hgetall(key string) !map[string]string

fn (mut r Redis) hkeys(key string) ![]string

fn (mut r Redis) hset(key string, skey string, value string) !

fn (mut r Redis) incr(key string) !int

fn (mut r Redis) incrby(key string, increment int) !int

fn (mut r Redis) incrbyfloat(key string, increment f64) !f64

fn (mut r Redis) keys(pattern string) ![]string

fn (mut r Redis) llen(key string) !int

fn (mut r Redis) lpop(key string) !string

fn (mut r Redis) lpush(key string, element string) !int

fn (mut r Redis) lrange(key string, start int, end int) ![]resp.RValue

fn (mut r Redis) persist(key string) !int

fn (mut r Redis) pexpire(key string, millis int) !int

fn (mut r Redis) pexpireat(key string, millistimestamp i64) !int

fn (mut r Redis) ping() !string

fn (mut r Redis) psetex(key string, millisecond i64, value string) !

fn (mut r Redis) pttl(key string) !int

fn (mut r Redis) queue_get(key string) RedisQueue

fn (mut r Redis) randomkey() !string

fn (mut r Redis) rename(key string, newkey string) !

fn (mut r Redis) renamenx(key string, newkey string) !int

fn (mut r Redis) rpc_get(key string) RedisRpc

return a rpc mechanism

fn (mut r Redis) rpop(key string) !string

fn (mut r Redis) rpush(key string, element string) !int

fn (mut r Redis) sadd(key string, members []string) !int

Add the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members. An error is returned when the value stored at key is not a set.

fn (mut r Redis) scan(cursor int) !(string, []string)

fn (mut r Redis) script_load(script string) !string

load a script and return the hash

fn (mut r Redis) selectdb(database int) !

select is reserved

fn (mut r Redis) send_expect_bool(items []string) !bool

fn (mut r Redis) send_expect_int(items []string) !int

send list of strings, expect int back

fn (mut r Redis) send_expect_list(items []string) ![]resp.RValue

fn (mut r Redis) send_expect_list_int(items []string) ![]int

fn (mut r Redis) send_expect_list_str(items []string) ![]string

send list of strings, expect list of strings back

fn (mut r Redis) send_expect_ok(items []string) !

send list of strings, expect OK back

fn (mut r Redis) send_expect_str(items []string) !string

send list of strings, expect string back

fn (mut r Redis) send_expect_strnil(items []string) !string

send list of strings, expect string or nil back

fn (mut r Redis) set(key string, value string) !

fn (mut r Redis) set_ex(key string, value string, ex string) !

fn (mut r Redis) set_opts(key string, value string, opts SetOpts) !bool

fn (mut r Redis) setex(key string, second i64, value string) !

fn (mut r Redis) setnx(key string, value string) !int

fn (mut r Redis) setrange(key string, offset int, value string) !int

fn (mut r Redis) smismember(key string, members []string) ![]int

Returns if member is a member of the set stored at key.

fn (mut r Redis) strlen(key string) !int

fn (mut r Redis) ttl(key string) !int

fn (mut r Redis) type_of(key string) !string

fn (mut r Redis) write_rval(val resp.RValue) !

write resp value to the redis channel

struct RedisCache {
mut:
	redis     &Redis @[str: skip]
	namespace string
	enabled   bool = true
}

fn (mut h RedisCache) get(key string) ?string

fn (mut h RedisCache) set(key string, val string, expire int) !

fn (mut h RedisCache) exists(key string) bool

fn (mut h RedisCache) reset() !

struct RedisQueue {
pub mut:
	key   string
	redis &Redis
}

fn (mut q RedisQueue) add(val string) !

fn (mut q RedisQueue) get(timeout u64) !string

timeout in msec

fn (mut q RedisQueue) pop() !string

get without timeout, returns none if nil

struct RedisRpc {
pub mut:
	key   string // queue name as used by this rpc
	redis &Redis
}

fn (mut q RedisRpc) call(args RPCArgs) !string

send data to a queue and wait till return comes back timeout in milliseconds params cmd string @[required] data string @[required] timeout u64=60000 //60 sec wait bool=true

fn (mut q RedisRpc) result(timeout u64, retqueue string) !string

get return once result processed

fn (mut q RedisRpc) process(timeout u64, op fn (string, string) !string) !string

to be used by processor, to get request and execute, this is the server side of a RPC mechanism 2nd argument is a function which needs to execute the job: fn (string,string) !string

fn (mut q RedisRpc) delete() !

get without timeout, returns none if nil

struct RedisURL {
	address string = '127.0.0.1'
	port    int    = 6379
	db      int
}

struct Response {
pub:
	result string
	error  string
}

struct SetOpts {
	ex       int = -4
	px       int = -4
	nx       bool
	xx       bool
	keep_ttl bool
}