diff options
Diffstat (limited to 'lib/pure/redis.nim')
| -rw-r--r-- | lib/pure/redis.nim | 384 |
1 files changed, 194 insertions, 190 deletions
diff --git a/lib/pure/redis.nim b/lib/pure/redis.nim index 959f5c6ef..52d81b3a4 100644 --- a/lib/pure/redis.nim +++ b/lib/pure/redis.nim @@ -1,6 +1,6 @@ # # -# Nimrod's Runtime Library +# Nim's Runtime Library # (c) Copyright 2012 Dominik Picheta # # See the file "copying.txt", included in this @@ -20,135 +20,139 @@ const redisNil* = "\0\0" type - PPipeline = ref object + Pipeline = ref object enabled: bool buffer: string expected: int ## number of replies expected if pipelined type - TSendMode = enum + SendMode = enum normal, pipelined, multiple type - TRedis* {.pure, final.} = object - socket: TSocket + Redis* = object + socket: Socket connected: bool - pipeline: PPipeline + pipeline: Pipeline - TRedisStatus* = string - TRedisInteger* = biggestInt - TRedisString* = string ## Bulk reply - TRedisList* = seq[TRedisString] ## Multi-bulk reply + RedisStatus* = string + RedisInteger* = BiggestInt + RedisString* = string ## Bulk reply + RedisList* = seq[RedisString] ## Multi-bulk reply - EInvalidReply* = object of ESynch ## Invalid reply from redis - ERedis* = object of ESynch ## Error in redis + ReplyError* = object of IOError ## Invalid reply from redis + RedisError* = object of IOError ## Error in redis -proc newPipeline(): PPipeline = +{.deprecated: [TSendMode: SendMode, TRedis: Redis, TRedisStatus: RedisStatus, + TRedisInteger: RedisInteger, TRedisString: RedisString, + TRedisList: RedisList, EInvalidReply: ReplyError, ERedis: RedisError].} + +proc newPipeline(): Pipeline = new(result) result.buffer = "" result.enabled = false result.expected = 0 -proc open*(host = "localhost", port = 6379.TPort): TRedis = +proc open*(host = "localhost", port = 6379.Port): Redis = ## Opens a connection to the redis server. result.socket = socket(buffered = false) - if result.socket == InvalidSocket: - OSError(OSLastError()) + if result.socket == invalidSocket: + raiseOSError(osLastError()) result.socket.connect(host, port) result.pipeline = newPipeline() proc raiseInvalidReply(expected, got: char) = - raise newException(EInvalidReply, + raise newException(ReplyError, "Expected '$1' at the beginning of a status reply got '$2'" % [$expected, $got]) -proc raiseNoOK(status: string, pipelineEnabled:bool) = +proc raiseNoOK(status: string, pipelineEnabled: bool) = if pipelineEnabled and not (status == "QUEUED" or status == "PIPELINED"): - raise newException(EInvalidReply, "Expected \"QUEUED\" or \"PIPELINED\" got \"$1\"" % status) + raise newException(ReplyError, "Expected \"QUEUED\" or \"PIPELINED\" got \"$1\"" % status) elif not pipelineEnabled and status != "OK": - raise newException(EInvalidReply, "Expected \"OK\" got \"$1\"" % status) + raise newException(ReplyError, "Expected \"OK\" got \"$1\"" % status) -template readSocket(r: TRedis, dummyVal:expr): stmt = - var line {.inject.} :TaintedString = "" +template readSocket(r: Redis, dummyVal:expr): stmt = + var line {.inject.}: TaintedString = "" if r.pipeline.enabled: return dummyVal else: readLine(r.socket, line) -proc parseStatus(r: TRedis, line: string = ""): TRedisStatus = +proc parseStatus(r: Redis, line: string = ""): RedisStatus = if r.pipeline.enabled: return "PIPELINED" if line == "": - raise newException(ERedis, "Server closed connection prematurely") + raise newException(RedisError, "Server closed connection prematurely") if line[0] == '-': - raise newException(ERedis, strip(line)) + raise newException(RedisError, strip(line)) if line[0] != '+': raiseInvalidReply('+', line[0]) return line.substr(1) # Strip '+' -proc readStatus(r:TRedis): TRedisStatus = +proc readStatus(r:Redis): RedisStatus = r.readSocket("PIPELINED") return r.parseStatus(line) -proc parseInteger(r: TRedis, line: string = ""): TRedisInteger = +proc parseInteger(r: Redis, line: string = ""): RedisInteger = if r.pipeline.enabled: return -1 #if line == "+QUEUED": # inside of multi # return -1 if line == "": - raise newException(ERedis, "Server closed connection prematurely") + raise newException(RedisError, "Server closed connection prematurely") if line[0] == '-': - raise newException(ERedis, strip(line)) + raise newException(RedisError, strip(line)) if line[0] != ':': raiseInvalidReply(':', line[0]) # Strip ':' if parseBiggestInt(line, result, 1) == 0: - raise newException(EInvalidReply, "Unable to parse integer.") + raise newException(ReplyError, "Unable to parse integer.") -proc readInteger(r: TRedis): TRedisInteger = +proc readInteger(r: Redis): RedisInteger = r.readSocket(-1) return r.parseInteger(line) -proc recv(sock: TSocket, size: int): TaintedString = +proc recv(sock: Socket, size: int): TaintedString = result = newString(size).TaintedString if sock.recv(cstring(result), size) != size: - raise newException(EInvalidReply, "recv failed") + raise newException(ReplyError, "recv failed") -proc parseSingleString(r: TRedis, line:string, allowMBNil = False): TRedisString = +proc parseSingleString(r: Redis, line:string, allowMBNil = false): RedisString = if r.pipeline.enabled: return "" # Error. if line[0] == '-': - raise newException(ERedis, strip(line)) + raise newException(RedisError, strip(line)) # Some commands return a /bulk/ value or a /multi-bulk/ nil. Odd. if allowMBNil: if line == "*-1": - return RedisNil + return redisNil if line[0] != '$': raiseInvalidReply('$', line[0]) var numBytes = parseInt(line.substr(1)) if numBytes == -1: - return RedisNil + return redisNil var s = r.socket.recv(numBytes+2) result = strip(s.string) -proc readSingleString(r: TRedis): TRedisString = +proc readSingleString(r: Redis): RedisString = r.readSocket("") return r.parseSingleString(line) -proc readNext(r: TRedis): TRedisList +proc readNext(r: Redis): RedisList -proc parseArrayLines(r: TRedis, countLine:string): TRedisList = +proc parseArrayLines(r: Redis, countLine:string): RedisList = if countLine.string[0] != '*': raiseInvalidReply('*', countLine.string[0]) @@ -162,24 +166,24 @@ proc parseArrayLines(r: TRedis, countLine:string): TRedisList = for item in parsed: result.add(item) -proc readArrayLines(r: TRedis): TRedisList = +proc readArrayLines(r: Redis): RedisList = r.readSocket(nil) return r.parseArrayLines(line) -proc parseBulkString(r: TRedis, allowMBNil = False, line:string = ""): TRedisString = +proc parseBulkString(r: Redis, allowMBNil = false, line:string = ""): RedisString = if r.pipeline.enabled: return "" return r.parseSingleString(line, allowMBNil) -proc readBulkString(r: TRedis, allowMBNil = false): TRedisString = +proc readBulkString(r: Redis, allowMBNil = false): RedisString = r.readSocket("") return r.parseBulkString(allowMBNil, line) -proc readArray(r: TRedis): TRedisList = +proc readArray(r: Redis): RedisList = r.readSocket(@[]) return r.parseArrayLines(line) -proc readNext(r: TRedis): TRedisList = +proc readNext(r: Redis): RedisList = r.readSocket(@[]) var res = case line[0] @@ -188,12 +192,12 @@ proc readNext(r: TRedis): TRedisList = of '$': @[r.parseBulkString(true,line)] of '*': r.parseArrayLines(line) else: - raise newException(EInvalidReply, "readNext failed on line: " & line) + raise newException(ReplyError, "readNext failed on line: " & line) nil r.pipeline.expected -= 1 return res -proc flushPipeline*(r: TRedis, wasMulti = false): TRedisList = +proc flushPipeline*(r: Redis, wasMulti = false): RedisList = ## Send buffered commands, clear buffer, return results if r.pipeline.buffer.len > 0: r.socket.send(r.pipeline.buffer) @@ -212,7 +216,7 @@ proc flushPipeline*(r: TRedis, wasMulti = false): TRedisList = r.pipeline.expected = 0 -proc startPipelining*(r: TRedis) = +proc startPipelining*(r: Redis) = ## Enable command pipelining (reduces network roundtrips). ## Note that when enabled, you must call flushPipeline to actually send commands, except ## for multi/exec() which enable and flush the pipeline automatically. @@ -221,7 +225,7 @@ proc startPipelining*(r: TRedis) = r.pipeline.expected = 0 r.pipeline.enabled = true -proc sendCommand(r: TRedis, cmd: string, args: varargs[string]) = +proc sendCommand(r: Redis, cmd: string, args: varargs[string]) = var request = "*" & $(1 + args.len()) & "\c\L" request.add("$" & $cmd.len() & "\c\L") request.add(cmd & "\c\L") @@ -235,7 +239,7 @@ proc sendCommand(r: TRedis, cmd: string, args: varargs[string]) = else: r.socket.send(request) -proc sendCommand(r: TRedis, cmd: string, arg1: string, +proc sendCommand(r: Redis, cmd: string, arg1: string, args: varargs[string]) = var request = "*" & $(2 + args.len()) & "\c\L" request.add("$" & $cmd.len() & "\c\L") @@ -254,68 +258,68 @@ proc sendCommand(r: TRedis, cmd: string, arg1: string, # Keys -proc del*(r: TRedis, keys: varargs[string]): TRedisInteger = +proc del*(r: Redis, keys: varargs[string]): RedisInteger = ## Delete a key or multiple keys r.sendCommand("DEL", keys) return r.readInteger() -proc exists*(r: TRedis, key: string): bool = +proc exists*(r: Redis, key: string): bool = ## Determine if a key exists r.sendCommand("EXISTS", key) return r.readInteger() == 1 -proc expire*(r: TRedis, key: string, seconds: int): bool = +proc expire*(r: Redis, key: string, seconds: int): bool = ## Set a key's time to live in seconds. Returns `false` if the key could ## not be found or the timeout could not be set. r.sendCommand("EXPIRE", key, $seconds) return r.readInteger() == 1 -proc expireAt*(r: TRedis, key: string, timestamp: int): bool = +proc expireAt*(r: Redis, key: string, timestamp: int): bool = ## Set the expiration for a key as a UNIX timestamp. Returns `false` ## if the key could not be found or the timeout could not be set. r.sendCommand("EXPIREAT", key, $timestamp) return r.readInteger() == 1 -proc keys*(r: TRedis, pattern: string): TRedisList = +proc keys*(r: Redis, pattern: string): RedisList = ## Find all keys matching the given pattern r.sendCommand("KEYS", pattern) return r.readArray() -proc move*(r: TRedis, key: string, db: int): bool = +proc move*(r: Redis, key: string, db: int): bool = ## Move a key to another database. Returns `true` on a successful move. r.sendCommand("MOVE", key, $db) return r.readInteger() == 1 -proc persist*(r: TRedis, key: string): bool = +proc persist*(r: Redis, key: string): bool = ## Remove the expiration from a key. ## Returns `true` when the timeout was removed. r.sendCommand("PERSIST", key) return r.readInteger() == 1 -proc randomKey*(r: TRedis): TRedisString = +proc randomKey*(r: Redis): RedisString = ## Return a random key from the keyspace r.sendCommand("RANDOMKEY") return r.readBulkString() -proc rename*(r: TRedis, key, newkey: string): TRedisStatus = +proc rename*(r: Redis, key, newkey: string): RedisStatus = ## Rename a key. ## ## **WARNING:** Overwrites `newkey` if it exists! r.sendCommand("RENAME", key, newkey) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc renameNX*(r: TRedis, key, newkey: string): bool = +proc renameNX*(r: Redis, key, newkey: string): bool = ## Same as ``rename`` but doesn't continue if `newkey` exists. ## Returns `true` if key was renamed. r.sendCommand("RENAMENX", key, newkey) return r.readInteger() == 1 -proc ttl*(r: TRedis, key: string): TRedisInteger = +proc ttl*(r: Redis, key: string): RedisInteger = ## Get the time to live for a key r.sendCommand("TTL", key) return r.readInteger() -proc keyType*(r: TRedis, key: string): TRedisStatus = +proc keyType*(r: Redis, key: string): RedisStatus = ## Determine the type stored at key r.sendCommand("TYPE", key) return r.readStatus() @@ -323,131 +327,131 @@ proc keyType*(r: TRedis, key: string): TRedisStatus = # Strings -proc append*(r: TRedis, key, value: string): TRedisInteger = +proc append*(r: Redis, key, value: string): RedisInteger = ## Append a value to a key r.sendCommand("APPEND", key, value) return r.readInteger() -proc decr*(r: TRedis, key: string): TRedisInteger = +proc decr*(r: Redis, key: string): RedisInteger = ## Decrement the integer value of a key by one r.sendCommand("DECR", key) return r.readInteger() -proc decrBy*(r: TRedis, key: string, decrement: int): TRedisInteger = +proc decrBy*(r: Redis, key: string, decrement: int): RedisInteger = ## Decrement the integer value of a key by the given number r.sendCommand("DECRBY", key, $decrement) return r.readInteger() -proc get*(r: TRedis, key: string): TRedisString = +proc get*(r: Redis, key: string): RedisString = ## Get the value of a key. Returns `redisNil` when `key` doesn't exist. r.sendCommand("GET", key) return r.readBulkString() -proc getBit*(r: TRedis, key: string, offset: int): TRedisInteger = +proc getBit*(r: Redis, key: string, offset: int): RedisInteger = ## Returns the bit value at offset in the string value stored at key r.sendCommand("GETBIT", key, $offset) return r.readInteger() -proc getRange*(r: TRedis, key: string, start, stop: int): TRedisString = +proc getRange*(r: Redis, key: string, start, stop: int): RedisString = ## Get a substring of the string stored at a key r.sendCommand("GETRANGE", key, $start, $stop) return r.readBulkString() -proc getSet*(r: TRedis, key: string, value: string): TRedisString = +proc getSet*(r: Redis, key: string, value: string): RedisString = ## Set the string value of a key and return its old value. Returns `redisNil` ## when key doesn't exist. r.sendCommand("GETSET", key, value) return r.readBulkString() -proc incr*(r: TRedis, key: string): TRedisInteger = +proc incr*(r: Redis, key: string): RedisInteger = ## Increment the integer value of a key by one. r.sendCommand("INCR", key) return r.readInteger() -proc incrBy*(r: TRedis, key: string, increment: int): TRedisInteger = +proc incrBy*(r: Redis, key: string, increment: int): RedisInteger = ## Increment the integer value of a key by the given number r.sendCommand("INCRBY", key, $increment) return r.readInteger() -proc setk*(r: TRedis, key, value: string) = +proc setk*(r: Redis, key, value: string) = ## Set the string value of a key. ## ## NOTE: This function had to be renamed due to a clash with the `set` type. r.sendCommand("SET", key, value) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc setNX*(r: TRedis, key, value: string): bool = +proc setNX*(r: Redis, key, value: string): bool = ## Set the value of a key, only if the key does not exist. Returns `true` ## if the key was set. r.sendCommand("SETNX", key, value) return r.readInteger() == 1 -proc setBit*(r: TRedis, key: string, offset: int, - value: string): TRedisInteger = +proc setBit*(r: Redis, key: string, offset: int, + value: string): RedisInteger = ## Sets or clears the bit at offset in the string value stored at key r.sendCommand("SETBIT", key, $offset, value) return r.readInteger() -proc setEx*(r: TRedis, key: string, seconds: int, value: string): TRedisStatus = +proc setEx*(r: Redis, key: string, seconds: int, value: string): RedisStatus = ## Set the value and expiration of a key r.sendCommand("SETEX", key, $seconds, value) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc setRange*(r: TRedis, key: string, offset: int, - value: string): TRedisInteger = +proc setRange*(r: Redis, key: string, offset: int, + value: string): RedisInteger = ## Overwrite part of a string at key starting at the specified offset r.sendCommand("SETRANGE", key, $offset, value) return r.readInteger() -proc strlen*(r: TRedis, key: string): TRedisInteger = +proc strlen*(r: Redis, key: string): RedisInteger = ## Get the length of the value stored in a key. Returns 0 when key doesn't ## exist. r.sendCommand("STRLEN", key) return r.readInteger() # Hashes -proc hDel*(r: TRedis, key, field: string): bool = +proc hDel*(r: Redis, key, field: string): bool = ## Delete a hash field at `key`. Returns `true` if the field was removed. r.sendCommand("HDEL", key, field) return r.readInteger() == 1 -proc hExists*(r: TRedis, key, field: string): bool = +proc hExists*(r: Redis, key, field: string): bool = ## Determine if a hash field exists. r.sendCommand("HEXISTS", key, field) return r.readInteger() == 1 -proc hGet*(r: TRedis, key, field: string): TRedisString = +proc hGet*(r: Redis, key, field: string): RedisString = ## Get the value of a hash field r.sendCommand("HGET", key, field) return r.readBulkString() -proc hGetAll*(r: TRedis, key: string): TRedisList = +proc hGetAll*(r: Redis, key: string): RedisList = ## Get all the fields and values in a hash r.sendCommand("HGETALL", key) return r.readArray() -proc hIncrBy*(r: TRedis, key, field: string, incr: int): TRedisInteger = +proc hIncrBy*(r: Redis, key, field: string, incr: int): RedisInteger = ## Increment the integer value of a hash field by the given number r.sendCommand("HINCRBY", key, field, $incr) return r.readInteger() -proc hKeys*(r: TRedis, key: string): TRedisList = +proc hKeys*(r: Redis, key: string): RedisList = ## Get all the fields in a hash r.sendCommand("HKEYS", key) return r.readArray() -proc hLen*(r: TRedis, key: string): TRedisInteger = +proc hLen*(r: Redis, key: string): RedisInteger = ## Get the number of fields in a hash r.sendCommand("HLEN", key) return r.readInteger() -proc hMGet*(r: TRedis, key: string, fields: varargs[string]): TRedisList = +proc hMGet*(r: Redis, key: string, fields: varargs[string]): RedisList = ## Get the values of all the given hash fields r.sendCommand("HMGET", key, fields) return r.readArray() -proc hMSet*(r: TRedis, key: string, - fieldValues: openarray[tuple[field, value: string]]) = +proc hMSet*(r: Redis, key: string, + fieldValues: openArray[tuple[field, value: string]]) = ## Set multiple hash fields to multiple values var args = @[key] for field, value in items(fieldValues): @@ -456,24 +460,24 @@ proc hMSet*(r: TRedis, key: string, r.sendCommand("HMSET", args) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc hSet*(r: TRedis, key, field, value: string): TRedisInteger = +proc hSet*(r: Redis, key, field, value: string): RedisInteger = ## Set the string value of a hash field r.sendCommand("HSET", key, field, value) return r.readInteger() -proc hSetNX*(r: TRedis, key, field, value: string): TRedisInteger = +proc hSetNX*(r: Redis, key, field, value: string): RedisInteger = ## Set the value of a hash field, only if the field does **not** exist r.sendCommand("HSETNX", key, field, value) return r.readInteger() -proc hVals*(r: TRedis, key: string): TRedisList = +proc hVals*(r: Redis, key: string): RedisList = ## Get all the values in a hash r.sendCommand("HVALS", key) return r.readArray() # Lists -proc bLPop*(r: TRedis, keys: varargs[string], timeout: int): TRedisList = +proc bLPop*(r: Redis, keys: varargs[string], timeout: int): RedisList = ## Remove and get the *first* element in a list, or block until ## one is available var args: seq[string] = @[] @@ -482,7 +486,7 @@ proc bLPop*(r: TRedis, keys: varargs[string], timeout: int): TRedisList = r.sendCommand("BLPOP", args) return r.readArray() -proc bRPop*(r: TRedis, keys: varargs[string], timeout: int): TRedisList = +proc bRPop*(r: Redis, keys: varargs[string], timeout: int): RedisList = ## Remove and get the *last* element in a list, or block until one ## is available. var args: seq[string] = @[] @@ -491,8 +495,8 @@ proc bRPop*(r: TRedis, keys: varargs[string], timeout: int): TRedisList = r.sendCommand("BRPOP", args) return r.readArray() -proc bRPopLPush*(r: TRedis, source, destination: string, - timeout: int): TRedisString = +proc bRPopLPush*(r: Redis, source, destination: string, + timeout: int): RedisString = ## Pop a value from a list, push it to another list and return it; or ## block until one is available. ## @@ -500,32 +504,32 @@ proc bRPopLPush*(r: TRedis, source, destination: string, r.sendCommand("BRPOPLPUSH", source, destination, $timeout) return r.readBulkString(true) # Multi-Bulk nil allowed. -proc lIndex*(r: TRedis, key: string, index: int): TRedisString = +proc lIndex*(r: Redis, key: string, index: int): RedisString = ## Get an element from a list by its index r.sendCommand("LINDEX", key, $index) return r.readBulkString() -proc lInsert*(r: TRedis, key: string, before: bool, pivot, value: string): - TRedisInteger = +proc lInsert*(r: Redis, key: string, before: bool, pivot, value: string): + RedisInteger = ## Insert an element before or after another element in a list var pos = if before: "BEFORE" else: "AFTER" r.sendCommand("LINSERT", key, pos, pivot, value) return r.readInteger() -proc lLen*(r: TRedis, key: string): TRedisInteger = +proc lLen*(r: Redis, key: string): RedisInteger = ## Get the length of a list r.sendCommand("LLEN", key) return r.readInteger() -proc lPop*(r: TRedis, key: string): TRedisString = +proc lPop*(r: Redis, key: string): RedisString = ## Remove and get the first element in a list r.sendCommand("LPOP", key) return r.readBulkString() -proc lPush*(r: TRedis, key, value: string, create: bool = True): TRedisInteger = +proc lPush*(r: Redis, key, value: string, create: bool = true): RedisInteger = ## Prepend a value to a list. Returns the length of the list after the push. ## The ``create`` param specifies whether a list should be created if it - ## doesn't exist at ``key``. More specifically if ``create`` is True, `LPUSH` + ## doesn't exist at ``key``. More specifically if ``create`` is true, `LPUSH` ## will be used, otherwise `LPUSHX`. if create: r.sendCommand("LPUSH", key, value) @@ -533,42 +537,42 @@ proc lPush*(r: TRedis, key, value: string, create: bool = True): TRedisInteger = r.sendCommand("LPUSHX", key, value) return r.readInteger() -proc lRange*(r: TRedis, key: string, start, stop: int): TRedisList = +proc lRange*(r: Redis, key: string, start, stop: int): RedisList = ## Get a range of elements from a list. Returns `nil` when `key` ## doesn't exist. r.sendCommand("LRANGE", key, $start, $stop) return r.readArray() -proc lRem*(r: TRedis, key: string, value: string, count: int = 0): TRedisInteger = +proc lRem*(r: Redis, key: string, value: string, count: int = 0): RedisInteger = ## Remove elements from a list. Returns the number of elements that have been ## removed. r.sendCommand("LREM", key, $count, value) return r.readInteger() -proc lSet*(r: TRedis, key: string, index: int, value: string) = +proc lSet*(r: Redis, key: string, index: int, value: string) = ## Set the value of an element in a list by its index r.sendCommand("LSET", key, $index, value) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc lTrim*(r: TRedis, key: string, start, stop: int) = +proc lTrim*(r: Redis, key: string, start, stop: int) = ## Trim a list to the specified range r.sendCommand("LTRIM", key, $start, $stop) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc rPop*(r: TRedis, key: string): TRedisString = +proc rPop*(r: Redis, key: string): RedisString = ## Remove and get the last element in a list r.sendCommand("RPOP", key) return r.readBulkString() -proc rPopLPush*(r: TRedis, source, destination: string): TRedisString = +proc rPopLPush*(r: Redis, source, destination: string): RedisString = ## Remove the last element in a list, append it to another list and return it r.sendCommand("RPOPLPUSH", source, destination) return r.readBulkString() -proc rPush*(r: TRedis, key, value: string, create: bool = True): TRedisInteger = +proc rPush*(r: Redis, key, value: string, create: bool = true): RedisInteger = ## Append a value to a list. Returns the length of the list after the push. ## The ``create`` param specifies whether a list should be created if it - ## doesn't exist at ``key``. More specifically if ``create`` is True, `RPUSH` + ## doesn't exist at ``key``. More specifically if ``create`` is true, `RPUSH` ## will be used, otherwise `RPUSHX`. if create: r.sendCommand("RPUSH", key, value) @@ -578,106 +582,106 @@ proc rPush*(r: TRedis, key, value: string, create: bool = True): TRedisInteger = # Sets -proc sadd*(r: TRedis, key: string, member: string): TRedisInteger = +proc sadd*(r: Redis, key: string, member: string): RedisInteger = ## Add a member to a set r.sendCommand("SADD", key, member) return r.readInteger() -proc scard*(r: TRedis, key: string): TRedisInteger = +proc scard*(r: Redis, key: string): RedisInteger = ## Get the number of members in a set r.sendCommand("SCARD", key) return r.readInteger() -proc sdiff*(r: TRedis, keys: varargs[string]): TRedisList = +proc sdiff*(r: Redis, keys: varargs[string]): RedisList = ## Subtract multiple sets r.sendCommand("SDIFF", keys) return r.readArray() -proc sdiffstore*(r: TRedis, destination: string, - keys: varargs[string]): TRedisInteger = +proc sdiffstore*(r: Redis, destination: string, + keys: varargs[string]): RedisInteger = ## Subtract multiple sets and store the resulting set in a key r.sendCommand("SDIFFSTORE", destination, keys) return r.readInteger() -proc sinter*(r: TRedis, keys: varargs[string]): TRedisList = +proc sinter*(r: Redis, keys: varargs[string]): RedisList = ## Intersect multiple sets r.sendCommand("SINTER", keys) return r.readArray() -proc sinterstore*(r: TRedis, destination: string, - keys: varargs[string]): TRedisInteger = +proc sinterstore*(r: Redis, destination: string, + keys: varargs[string]): RedisInteger = ## Intersect multiple sets and store the resulting set in a key r.sendCommand("SINTERSTORE", destination, keys) return r.readInteger() -proc sismember*(r: TRedis, key: string, member: string): TRedisInteger = +proc sismember*(r: Redis, key: string, member: string): RedisInteger = ## Determine if a given value is a member of a set r.sendCommand("SISMEMBER", key, member) return r.readInteger() -proc smembers*(r: TRedis, key: string): TRedisList = +proc smembers*(r: Redis, key: string): RedisList = ## Get all the members in a set r.sendCommand("SMEMBERS", key) return r.readArray() -proc smove*(r: TRedis, source: string, destination: string, - member: string): TRedisInteger = +proc smove*(r: Redis, source: string, destination: string, + member: string): RedisInteger = ## Move a member from one set to another r.sendCommand("SMOVE", source, destination, member) return r.readInteger() -proc spop*(r: TRedis, key: string): TRedisString = +proc spop*(r: Redis, key: string): RedisString = ## Remove and return a random member from a set r.sendCommand("SPOP", key) return r.readBulkString() -proc srandmember*(r: TRedis, key: string): TRedisString = +proc srandmember*(r: Redis, key: string): RedisString = ## Get a random member from a set r.sendCommand("SRANDMEMBER", key) return r.readBulkString() -proc srem*(r: TRedis, key: string, member: string): TRedisInteger = +proc srem*(r: Redis, key: string, member: string): RedisInteger = ## Remove a member from a set r.sendCommand("SREM", key, member) return r.readInteger() -proc sunion*(r: TRedis, keys: varargs[string]): TRedisList = +proc sunion*(r: Redis, keys: varargs[string]): RedisList = ## Add multiple sets r.sendCommand("SUNION", keys) return r.readArray() -proc sunionstore*(r: TRedis, destination: string, - key: varargs[string]): TRedisInteger = +proc sunionstore*(r: Redis, destination: string, + key: varargs[string]): RedisInteger = ## Add multiple sets and store the resulting set in a key r.sendCommand("SUNIONSTORE", destination, key) return r.readInteger() # Sorted sets -proc zadd*(r: TRedis, key: string, score: int, member: string): TRedisInteger = +proc zadd*(r: Redis, key: string, score: int, member: string): RedisInteger = ## Add a member to a sorted set, or update its score if it already exists r.sendCommand("ZADD", key, $score, member) return r.readInteger() -proc zcard*(r: TRedis, key: string): TRedisInteger = +proc zcard*(r: Redis, key: string): RedisInteger = ## Get the number of members in a sorted set r.sendCommand("ZCARD", key) return r.readInteger() -proc zcount*(r: TRedis, key: string, min: string, max: string): TRedisInteger = +proc zcount*(r: Redis, key: string, min: string, max: string): RedisInteger = ## Count the members in a sorted set with scores within the given values r.sendCommand("ZCOUNT", key, min, max) return r.readInteger() -proc zincrby*(r: TRedis, key: string, increment: string, - member: string): TRedisString = +proc zincrby*(r: Redis, key: string, increment: string, + member: string): RedisString = ## Increment the score of a member in a sorted set r.sendCommand("ZINCRBY", key, increment, member) return r.readBulkString() -proc zinterstore*(r: TRedis, destination: string, numkeys: string, - keys: openarray[string], weights: openarray[string] = [], - aggregate: string = ""): TRedisInteger = +proc zinterstore*(r: Redis, destination: string, numkeys: string, + keys: openArray[string], weights: openArray[string] = [], + aggregate: string = ""): RedisInteger = ## Intersect multiple sorted sets and store the resulting sorted set in ## a new key var args = @[destination, numkeys] @@ -694,8 +698,8 @@ proc zinterstore*(r: TRedis, destination: string, numkeys: string, return r.readInteger() -proc zrange*(r: TRedis, key: string, start: string, stop: string, - withScores: bool): TRedisList = +proc zrange*(r: Redis, key: string, start: string, stop: string, + withScores: bool): RedisList = ## Return a range of members in a sorted set, by index if not withScores: r.sendCommand("ZRANGE", key, start, stop) @@ -703,9 +707,9 @@ proc zrange*(r: TRedis, key: string, start: string, stop: string, r.sendCommand("ZRANGE", "WITHSCORES", key, start, stop) return r.readArray() -proc zrangebyscore*(r: TRedis, key: string, min: string, max: string, - withScore: bool = false, limit: bool = False, - limitOffset: int = 0, limitCount: int = 0): TRedisList = +proc zrangebyscore*(r: Redis, key: string, min: string, max: string, + withScore: bool = false, limit: bool = false, + limitOffset: int = 0, limitCount: int = 0): RedisList = ## Return a range of members in a sorted set, by score var args = @[key, min, max] @@ -718,30 +722,30 @@ proc zrangebyscore*(r: TRedis, key: string, min: string, max: string, r.sendCommand("ZRANGEBYSCORE", args) return r.readArray() -proc zrank*(r: TRedis, key: string, member: string): TRedisString = +proc zrank*(r: Redis, key: string, member: string): RedisString = ## Determine the index of a member in a sorted set r.sendCommand("ZRANK", key, member) return r.readBulkString() -proc zrem*(r: TRedis, key: string, member: string): TRedisInteger = +proc zrem*(r: Redis, key: string, member: string): RedisInteger = ## Remove a member from a sorted set r.sendCommand("ZREM", key, member) return r.readInteger() -proc zremrangebyrank*(r: TRedis, key: string, start: string, - stop: string): TRedisInteger = +proc zremrangebyrank*(r: Redis, key: string, start: string, + stop: string): RedisInteger = ## Remove all members in a sorted set within the given indexes r.sendCommand("ZREMRANGEBYRANK", key, start, stop) return r.readInteger() -proc zremrangebyscore*(r: TRedis, key: string, min: string, - max: string): TRedisInteger = +proc zremrangebyscore*(r: Redis, key: string, min: string, + max: string): RedisInteger = ## Remove all members in a sorted set within the given scores r.sendCommand("ZREMRANGEBYSCORE", key, min, max) return r.readInteger() -proc zrevrange*(r: TRedis, key: string, start: string, stop: string, - withScore: bool): TRedisList = +proc zrevrange*(r: Redis, key: string, start: string, stop: string, + withScore: bool): RedisList = ## Return a range of members in a sorted set, by index, ## with scores ordered from high to low if withScore: @@ -749,9 +753,9 @@ proc zrevrange*(r: TRedis, key: string, start: string, stop: string, else: r.sendCommand("ZREVRANGE", key, start, stop) return r.readArray() -proc zrevrangebyscore*(r: TRedis, key: string, min: string, max: string, - withScore: bool = false, limit: bool = False, - limitOffset: int = 0, limitCount: int = 0): TRedisList = +proc zrevrangebyscore*(r: Redis, key: string, min: string, max: string, + withScore: bool = false, limit: bool = false, + limitOffset: int = 0, limitCount: int = 0): RedisList = ## Return a range of members in a sorted set, by score, with ## scores ordered from high to low var args = @[key, min, max] @@ -765,20 +769,20 @@ proc zrevrangebyscore*(r: TRedis, key: string, min: string, max: string, r.sendCommand("ZREVRANGEBYSCORE", args) return r.readArray() -proc zrevrank*(r: TRedis, key: string, member: string): TRedisString = +proc zrevrank*(r: Redis, key: string, member: string): RedisString = ## Determine the index of a member in a sorted set, with ## scores ordered from high to low r.sendCommand("ZREVRANK", key, member) return r.readBulkString() -proc zscore*(r: TRedis, key: string, member: string): TRedisString = +proc zscore*(r: Redis, key: string, member: string): RedisString = ## Get the score associated with the given member in a sorted set r.sendCommand("ZSCORE", key, member) return r.readBulkString() -proc zunionstore*(r: TRedis, destination: string, numkeys: string, - keys: openarray[string], weights: openarray[string] = [], - aggregate: string = ""): TRedisInteger = +proc zunionstore*(r: Redis, destination: string, numkeys: string, + keys: openArray[string], weights: openArray[string] = [], + aggregate: string = ""): RedisInteger = ## Add multiple sorted sets and store the resulting sorted set in a new key var args = @[destination, numkeys] for i in items(keys): args.add(i) @@ -828,12 +832,12 @@ proc unsubscribe*(r: TRedis, [channel: openarray[string], : string): ???? = # Transactions -proc discardMulti*(r: TRedis) = +proc discardMulti*(r: Redis) = ## Discard all commands issued after MULTI r.sendCommand("DISCARD") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc exec*(r: TRedis): TRedisList = +proc exec*(r: Redis): RedisList = ## Execute all commands issued after MULTI r.sendCommand("EXEC") r.pipeline.enabled = false @@ -842,106 +846,106 @@ proc exec*(r: TRedis): TRedisList = return r.flushPipeline(true) -proc multi*(r: TRedis) = +proc multi*(r: Redis) = ## Mark the start of a transaction block r.startPipelining() r.sendCommand("MULTI") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc unwatch*(r: TRedis) = +proc unwatch*(r: Redis) = ## Forget about all watched keys r.sendCommand("UNWATCH") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc watch*(r: TRedis, key: varargs[string]) = +proc watch*(r: Redis, key: varargs[string]) = ## Watch the given keys to determine execution of the MULTI/EXEC block r.sendCommand("WATCH", key) raiseNoOK(r.readStatus(), r.pipeline.enabled) # Connection -proc auth*(r: TRedis, password: string) = +proc auth*(r: Redis, password: string) = ## Authenticate to the server r.sendCommand("AUTH", password) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc echoServ*(r: TRedis, message: string): TRedisString = +proc echoServ*(r: Redis, message: string): RedisString = ## Echo the given string r.sendCommand("ECHO", message) return r.readBulkString() -proc ping*(r: TRedis): TRedisStatus = +proc ping*(r: Redis): RedisStatus = ## Ping the server r.sendCommand("PING") return r.readStatus() -proc quit*(r: TRedis) = +proc quit*(r: Redis) = ## Close the connection r.sendCommand("QUIT") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc select*(r: TRedis, index: int): TRedisStatus = +proc select*(r: Redis, index: int): RedisStatus = ## Change the selected database for the current connection r.sendCommand("SELECT", $index) return r.readStatus() # Server -proc bgrewriteaof*(r: TRedis) = +proc bgrewriteaof*(r: Redis) = ## Asynchronously rewrite the append-only file r.sendCommand("BGREWRITEAOF") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc bgsave*(r: TRedis) = +proc bgsave*(r: Redis) = ## Asynchronously save the dataset to disk r.sendCommand("BGSAVE") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc configGet*(r: TRedis, parameter: string): TRedisList = +proc configGet*(r: Redis, parameter: string): RedisList = ## Get the value of a configuration parameter r.sendCommand("CONFIG", "GET", parameter) return r.readArray() -proc configSet*(r: TRedis, parameter: string, value: string) = +proc configSet*(r: Redis, parameter: string, value: string) = ## Set a configuration parameter to the given value r.sendCommand("CONFIG", "SET", parameter, value) raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc configResetStat*(r: TRedis) = +proc configResetStat*(r: Redis) = ## Reset the stats returned by INFO r.sendCommand("CONFIG", "RESETSTAT") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc dbsize*(r: TRedis): TRedisInteger = +proc dbsize*(r: Redis): RedisInteger = ## Return the number of keys in the selected database r.sendCommand("DBSIZE") return r.readInteger() -proc debugObject*(r: TRedis, key: string): TRedisStatus = +proc debugObject*(r: Redis, key: string): RedisStatus = ## Get debugging information about a key r.sendCommand("DEBUG", "OBJECT", key) return r.readStatus() -proc debugSegfault*(r: TRedis) = +proc debugSegfault*(r: Redis) = ## Make the server crash r.sendCommand("DEBUG", "SEGFAULT") -proc flushall*(r: TRedis): TRedisStatus = +proc flushall*(r: Redis): RedisStatus = ## Remove all keys from all databases r.sendCommand("FLUSHALL") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc flushdb*(r: TRedis): TRedisStatus = +proc flushdb*(r: Redis): RedisStatus = ## Remove all keys from the current database r.sendCommand("FLUSHDB") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc info*(r: TRedis): TRedisString = +proc info*(r: Redis): RedisString = ## Get information and statistics about the server r.sendCommand("INFO") return r.readBulkString() -proc lastsave*(r: TRedis): TRedisInteger = +proc lastsave*(r: Redis): RedisInteger = ## Get the UNIX time stamp of the last successful save to disk r.sendCommand("LASTSAVE") return r.readInteger() @@ -953,24 +957,24 @@ proc monitor*(r: TRedis) = raiseNoOK(r.readStatus(), r.pipeline.enabled) """ -proc save*(r: TRedis) = +proc save*(r: Redis) = ## Synchronously save the dataset to disk r.sendCommand("SAVE") raiseNoOK(r.readStatus(), r.pipeline.enabled) -proc shutdown*(r: TRedis) = +proc shutdown*(r: Redis) = ## Synchronously save the dataset to disk and then shut down the server r.sendCommand("SHUTDOWN") var s = "".TaintedString r.socket.readLine(s) - if s.string.len != 0: raise newException(ERedis, s.string) + if s.string.len != 0: raise newException(RedisError, s.string) -proc slaveof*(r: TRedis, host: string, port: string) = +proc slaveof*(r: Redis, host: string, port: string) = ## Make the server a slave of another instance, or promote it as master r.sendCommand("SLAVEOF", host, port) raiseNoOK(r.readStatus(), r.pipeline.enabled) -iterator hPairs*(r: TRedis, key: string): tuple[key, value: string] = +iterator hPairs*(r: Redis, key: string): tuple[key, value: string] = ## Iterator for keys and values in a hash. var contents = r.hGetAll(key) @@ -982,7 +986,7 @@ iterator hPairs*(r: TRedis, key: string): tuple[key, value: string] = yield (k, i) k = "" -proc someTests(r: TRedis, how: TSendMode):seq[string] = +proc someTests(r: Redis, how: SendMode):seq[string] = var list:seq[string] = @[] if how == pipelined: @@ -1003,10 +1007,10 @@ proc someTests(r: TRedis, how: TSendMode):seq[string] = for r in res: list.add(r) list.add(r.get("invalid_key")) - list.add($(r.lpush("mylist","itema"))) - list.add($(r.lpush("mylist","itemb"))) - r.ltrim("mylist",0,1) - var p = r.lrange("mylist", 0, -1) + list.add($(r.lPush("mylist","itema"))) + list.add($(r.lPush("mylist","itemb"))) + r.lTrim("mylist",0,1) + var p = r.lRange("mylist", 0, -1) for i in items(p): if not isNil(i): |