accession.core — accession 0.1.2

append clj

(append key value)

auth clj

(auth password)

bgsave clj

(bgsave)

bgwriteaof clj

(bgwriteaof)

blpop clj

(blpop key timeout)

brpop clj

(brpop key timeout)

brpoplpush clj

(brpoplpush source destination timeout)

connection-map clj

(connection-map)

(connection-map spec)

Creates the initial connection spec. Options can be overridden by passing in a map. The following keys are valid:

:host :port :password :socket :timeout

Although passing in your own socket is not recommended and will probably cause more problems than it solves

dbsize clj

(dbsize)

decr clj

(decr key)

decrby clj

(decrby key increment)

defqueries clj macro

(defqueries & queries)

Given any number of redis commands and argument lists, convert them to function definitions.

This is an interesting use of unquote splicing. Unquote splicing works on a sequence and that sequence can be the result of a function call as it is here. The function which produces this sequence maps each argument passed to this macro over a function which takes each list like (set [key value]), binds it to q, and uses unquote splicing again to create a call to defquery which looks like (defquery set [key value]).

Finally, a macro can only return a single form, so we wrap all of the produced expressions in a do special form.

defquery clj macro

(defquery name params)

Given a redis command and a parameter list, create a function of the form:

 (defn <name> <parameter-list>
   (query <command> <p1> <p2> ... <pN>))

The name which is passed is a symbol and is first used as a symbol for the function name. We convert this symbol to a string and use that string as the command name.

params is a list of N symbols which represent the parameters to the function. We use this list as the parameter-list when we create the function. Each symbol in this list will be an argument to query after the command. We use unquote splicing (~@) to insert these arguments after the command string.

del clj

(del key & keys)

discard clj

(discard)

echo clj

(echo message)

exec clj

(exec)

exists clj

(exists key)

expire clj

(expire key seconds)

expireat clj

(expireat key seconds)

flushall clj

(flushall)

flushdb clj

(flushdb)

get clj

(get key)

getbit clj

(getbit key offset)

getrange clj

(getrange key start end)

getset clj

(getset key value)

hdel clj

(hdel key field & fields)

hexists clj

(hexists key field)

hget clj

(hget key field)

hgetall clj

(hgetall key)

hincrby clj

(hincrby key field increment)

hkeys clj

(hkeys key)

hlen clj

(hlen key)

hmget clj

(hmget key field & fields)

hmset clj

(hmset key field value & pairs)

hset clj

(hset key field value)

hsetnx clj

(hsetnx key field value)

hvals clj

(hvals key)

incr clj

(incr key)

incrby clj

(incrby key increment)

info clj

(info)

IRedisChannel clj protocol

close clj

(close this)

ISubscribable clj protocol

subscribe clj

(subscribe this channels)

IUnsubscribable clj protocol

unsubscribe clj

(unsubscribe this channels)

keys clj

(keys pattern)

lastsave clj

(lastsave)

lindex clj

(lindex key index)

linsert clj

(linsert key before-after pivot value)

llen clj

(llen key)

lpop clj

(lpop key)

lpush clj

(lpush key value)

lpushx clj

(lpushx key value & values)

lrange clj

(lrange key start end)

lrem clj

(lrem key count value)

lset clj

(lset key value index)

ltrim clj

(ltrim key start stop)

mget clj

(mget key & keys)

monitor clj

(monitor)

move clj

(move key db)

mset clj

(mset key value & pairs)

msetnx clj

(msetnx key value & pairs)

multi clj

(multi)

object clj

(object subcommand & arguments)

open-channel clj

(open-channel conn command channels)

Takes a connection and sets up a connection to a Redis channel with the provided functions as callbacks to invoke when messages are received

parameters clj

(parameters params)

This function enables vararg style definitions in the queries. For example you can write:

 (mget [key & keys])

and the defquery macro will properly expand out into a variable argument function

persist clj

(persist key)

ping clj

(ping)

publish clj

(publish channel message)

query clj

(query name & args)

The new unified protocol was introduced in Redis 1.2, but it became the standard way for talking with the Redis server in Redis 2.0. In the unified protocol all the arguments sent to the Redis server are binary safe. This is the general form:

*<number of arguments> CR LF
$<number of bytes of argument 1> CR LF
<argument data> CR LF
...
$<number of bytes of argument N> CR LF
<argument data> CR LF

See the following example:

*3
$3
SET
$5
mykey
$7
myvalue

This is how the above command looks as a quoted string, so that it is possible to see the exact value of every byte in the query:

quit clj

(quit)

randomkey clj

(randomkey)

receive-message clj

(receive-message channel-spec in)

Used in conjunction with an open channel to handle messages that arrive. Takes a channel spec and a message

rename clj

(rename key newkey)

renamenx clj

(renamenx key newkey)

request clj

(request conn & query)

Responsible for actually making the request to the Redis server. Sets the timeout on the socket if one was specified.

response clj multimethod

Redis will reply to commands with different kinds of replies. It is possible to check the kind of reply from the first byte sent by the server:

• With a single line reply the first byte of the reply will be +
• With an error message the first byte of the reply will be -
• With an integer number the first byte of the reply will be :
• With bulk reply the first byte of the reply will be $
• With multi-bulk reply the first byte of the reply will be *

rpop clj

(rpop key)

rpoplpush clj

(rpoplpush source destination)

rpush clj

(rpush key value & values)

rpushx clj

(rpushx key value)

sadd clj

(sadd key member & members)

save clj

(save)

scard clj

(scard key)

sdiff clj

(sdiff key & keys)

sdiffstore clj

(sdiffstore destination set1 set2)

select clj

(select index)

set clj

(set key value)

setbit clj

(setbit key offset value)

setex clj

(setex key seconds value)

setnx clj

(setnx key value)

setrange clj

(setrange key offset value)

shutdown clj

(shutdown)

sinter clj

(sinter key & keys)

sinterstore clj

(sinterstore destination key & keys)

sismember clj

(sismember key member)

slaveof clj

(slaveof host port)

slowlog clj

(slowlog command argument)

smembers clj

(smembers key)

smove clj

(smove source desination member)

sort clj

(sort key & options)

spop clj

(spop key)

srandmember clj

(srandmember key)

srem clj

(srem key member & members)

strlen clj

(strlen key)

sunion clj

(sunion key & keys)

sunionstore clj

(sunionstore destination key & keys)

sync clj

(sync)

ttl clj

(ttl key)

type clj

(type key)

unwatch clj

(unwatch)

watch clj

(watch key & keys)

with-connection clj

(with-connection spec & body)

write-commands clj

(write-commands out command channels)

Sends commands out to the specified channels

zadd clj

(zadd key score member & more)

zcard clj

(zcard key)

zcount clj

(zcount key min max)

zincrby clj

(zincrby key increment member)

zinterstore clj

(zinterstore dest-key source-keys & options)

zrange clj

(zrange key start stop)

zrangebyscore clj

(zrangebyscore key min max & more)

zrank clj

(zrank member)

zrem clj

(zrem key member & members)

zremrangebyrank clj

(zremrangebyrank key start stop)

zremrangebyscore clj

(zremrangebyscore key min max)

zrevrange clj

(zrevrange key start stop & more)

zrevrangebyscore clj

(zrevrangebyscore key max min & more)

zrevrank clj

(zrevrank key member)

zscore clj

(zscore key member)

zunionstore clj

(zunionstore dest-key source-keys & options)