celtuce.commands — celtuce-core 0.4.2

bitfield-args clj

(bitfield-args & commands)

Constructs a BitFieldArgs from a chain of commands

chunked-scan-seq clj macro

(chunked-scan-seq scan-expr)

Takes a scan EXPR composed of:

• a command: "scan", "sscan", "hscan", "zscan"
• a key when the command is not "scan"
• optionals: ScanCursor c, ScanArgs args Returns a lazy seq that calls scan-res on each cursor iteration result (chunk).

ConnectionCommands clj protocol

Redis connection Commands

echo clj

(echo this val)

Echo the given string

ping clj

(ping this)

Ping the server

geo-args clj

(geo-args &
          {with-dist :with-dist
           with-coord :with-coord
           with-hash :with-hash
           count :count
           sort :sort})

GeoCommands clj protocol

Redis Geo Commands

geoadd clj

(geoadd this key lng-lat-members)

(geoadd this key long lat member)

Single or multiple geo add

geodist clj

(geodist this key from to unit)

Retrieve distance between points from and to

geohash clj

(geohash this key member)

Retrieve Geohash of a member of a geospatial index

geopos clj

(geopos this key member)

Get geo coordinates for the member

georadius clj

(georadius this key long lat dist unit)

(georadius this key long lat dist unit args)

Retrieve members selected by dist with the center of long last, Perform a georadius query and store the results in a zset

georadiusbymember clj

(georadiusbymember this key member dist unit)

(georadiusbymember this key member dist unit args)

Retrieve members selected by dist with the center of member, Perform a georadiusbymember query and store the results in a zset

mgeohash clj

(mgeohash this key members)

Retrieve Geohash of multiple members of a geospatial index

mgeopos clj

(mgeopos this key members)

Get geo coordinates for the members

georadius-store-args clj

(georadius-store-args
  &
  {store-key :store-key store-dist-key :store-dist-key count :count sort :sort})

HashCommands clj protocol

Redis Hash Commands

hmset clj

(hmset this key map)

Set multiple hash fields to multiple values (map)

hgetall clj

(hgetall this key)

Get all the fields and values in a hash

hdel clj

(hdel this key field)

Delete one hash field

hmdel clj

(hmdel this key fields)

Delete multiple hash fields

hincrby clj

(hincrby this key field amount)

Increment the value of a hash field by long

hvals clj

(hvals this key)

Get all the values in a hash

hset clj

(hset this key field val)

Set the string value of a hash field

hscan clj

(hscan this key)

(hscan this key cursor)

(hscan this key cursor args)

Incrementally iterate hash fields and associated values

hget clj

(hget this key field)

Get the value of a hash field

hexists clj

(hexists this key field)

Determine if a hash field exists

hmget clj

(hmget this key fields)

Get the values of all the given hash fields

hincrbyfloat clj

(hincrbyfloat this key field amount)

Increment the value of a hash field by double

hkeys clj

(hkeys this key)

Get all the fields in a hash

hsetnx clj

(hsetnx this key field val)

Set the value of a hash field, only if it doesn't exist

hlen clj

(hlen this key)

Get the number of fields in a hash

hstrlen clj

(hstrlen this key field)

Get the string length of the field value in a hash

HLLCommands clj protocol

Redis HLL Commands

mpfadd clj

(mpfadd this key vals)

Add the specified elements to the specified HyperLogLog

mpfcount clj

(mpfcount this keys)

Return the approximated cardinality of the sets (HyperLogLog) at keys

pfadd clj

(pfadd this key val)

Add the specified element to the specified HyperLogLog

pfcount clj

(pfcount this key)

Return the approximated cardinality of the set (HyperLogLog) at key

pfmerge clj

(pfmerge this dest keys)

Merge N different HyperLogLogs into a single one

hscan-seq clj

(hscan-seq cmds key)

(hscan-seq cmds key args)

Lazy HSCAN sequence, takes optional scan-args

KeyCommands clj protocol

Redis Key Commands

obj-idletime clj

(obj-idletime this key)

Number of sec the key's value is idle (no read/write)

mexists clj

(mexists this keys)

Determine how many keys exist

sort-store clj

(sort-store this key args dest)

Sort and store the result in destination key

dump clj

(dump this key)

Serialized version of the value stored at the key

unlink clj

(unlink this key)

Unlink one key (non blocking DEL)

sort clj

(sort this key)

(sort this key args)

Sort the elements in a list, set or sorted set

del clj

(del this key)

Delete one key

exists clj

(exists this key)

Determine whether key exists

obj-refcount clj

(obj-refcount this key)

Number of references of the key's value

randomkey clj

(randomkey this)

Return a random key from the keyspace

expireat clj

(expireat this key ts-sec)

Set the expiration for a key as a UNIX timestamp

pttl clj

(pttl this key)

Get the time to live for a key in milliseconds

munlink clj

(munlink this keys)

Unlink multiple keys (non blocking DEL)

restore clj

(restore this key ttl val)

Create a key using a serialized value obtained by DUMP

migrate clj

(migrate this host port db timeout-ms args)

Transfer a key from a Redis instance to another one

move clj

(move this key db)

Move a key to another database

renamenx clj

(renamenx this key1 key2)

Rename a key, only if the new key does not exist

expire clj

(expire this key sec)

Set a key's time to live in seconds

persist clj

(persist this key)

Remove the expiration from a key

type clj

(type this key)

Determine the type stored at key

mtouch clj

(mtouch this keys)

Touch multiple keys. Sets the keys last accessed time

rename clj

(rename this key1 key2)

Rename a key

keys clj

(keys this pattern)

Find all keys matching the given pattern

pexpireat clj

(pexpireat this key ts-ms)

Set the expiration for a key as a UNIX timestamp in ms

pexpire clj

(pexpire this key ttl-ms)

Set a key's time to live in milliseconds

ttl clj

(ttl this key)

Get the time to live for a key

obj-encoding clj

(obj-encoding this key)

Internal representation used to store the key's value

touch clj

(touch this key)

Touch one key. Sets the key last accessed time

mdel clj

(mdel this keys)

Delete multiple keys

scan clj

(scan this)

(scan this cursor)

(scan this cursor args)

Incrementally iterate the keys space

kill-args clj

(kill-args & {skipme :skipme addr :addr id :id type :type})

ListCommands clj protocol

Redis List Commands

rpop clj

(rpop this key)

Remove and get the last element in a list

brpoplpush clj

(brpoplpush this timeout-sec src dest)

Pop and push to another list, return the elem (blocking)

mrpushx clj

(mrpushx this key vals)

Append multiple values to a list, only if the list exists

rpoplpush clj

(rpoplpush this src dest)

Pop and push to another list, return the elem

mlpush clj

(mlpush this key vals)

Prepend multiple values to a list

mlpushx clj

(mlpushx this key vals)

Prepend multiple values, only if the list exists

lpushx clj

(lpushx this key val)

Prepend a value to a list, only if the list exists

ltrim clj

(ltrim this key start end)

Trim a list to the specified range

lrange clj

(lrange this key start end)

Get a range of elements from a list

linsert clj

(linsert this key before? pivot val)

Insert an elem before or after another elem in a list

rpushx clj

(rpushx this key val)

Append a value to a list, only if the list exists

lset clj

(lset this key idx v)

Set the value of an element in a list by its index

lindex clj

(lindex this key idx)

Get an element from a list by its index

rpush clj

(rpush this key val)

Append one value to a list

llen clj

(llen this key)

Get the length of a list

lpush clj

(lpush this key val)

Prepend one value to a list

blpop clj

(blpop this timeout-sec keys)

Remove and get the first elem (block until there's one)

lpop clj

(lpop this key)

Remove and get the first element in a list

brpop clj

(brpop this timeout-sec keys)

Remove and get the last elem (block until there's one)

lrem clj

(lrem this key count val)

Remove elements from a list

mrpush clj

(mrpush this key vals)

Append multiple values to a list

migrate-args clj

(migrate-args & {copy :copy replace :replace k :key ks :keys})

PubSubCommands clj protocol

Redis PubSub Commands

subscribe clj

(subscribe this channel)

Listen for messages published to channel

publish clj

(publish this channel message)

Post a message to a channel

pubsub-numpat clj

(pubsub-numpat this)

Returns the number of subscriptions to patterns

mpsubscribe clj

(mpsubscribe this pattern)

Listen for messages published to channels matching patterns

pubsub-channels clj

(pubsub-channels this)

(pubsub-channels this channel)

Lists the currently active channels

unsubscribe clj

(unsubscribe this channel)

Stop listening for messages posted to channel

psubscribe clj

(psubscribe this pattern)

Listen for messages published to channels matching pattern

msubscribe clj

(msubscribe this channels)

Listen for messages published to channels

pubsub-numsub clj

(pubsub-numsub this channel)

Returns the number of subscribers for the specified channel

munsubscribe clj

(munsubscribe this channels)

Stop listening for messages posted to channels

mpunsubscribe clj

(mpunsubscribe this pattern)

Stop listening for messages posted to channels matching patterns

punsubscribe clj

(punsubscribe this pattern)

Stop listening for messages posted to channels matching pattern

PubSubListener clj protocol

Protocol for redis pub/sub listeners

message clj

(message this channel message)

(message this pattern channel message)

Message received from a channel (or pattern) subscription

psubscribed clj

(psubscribed this pattern count)

Subscribed to a pattern

punsubscribed clj

(punsubscribed this pattern count)

Unsubscribed from a pattern

subscribed clj

(subscribed this channel count)

Subscribed to a channel

unsubscribed clj

(unsubscribed this channel count)

Unsubscribed from a channel

scan-args clj

(scan-args & {limit :limit match :match})

scan-cursor clj

(scan-cursor)

(scan-cursor cursor)

scan-res clj

(scan-res this)

Get the data contained in a scan cursor result

scan-seq clj

(scan-seq cmds)

(scan-seq cmds args)

Lazy SCAN sequence, takes optional scan-args

ScriptingCommands clj protocol

Redis Scripting Commands (Lua 5.1)

digest clj

(digest this script)

Create a SHA1 digest from a Lua script

eval clj

(eval this script type keys)

(eval this script type keys vals)

Execute a Lua script server side

evalsha clj

(evalsha this digest type keys)

(evalsha this digest type keys vals)

Evaluates a script cached on the server side by its SHA1 digest

script-exists? clj

(script-exists? this digests)

Check existence of scripts in the script cache

script-flush clj

(script-flush this)

Remove all the scripts from the script cache

script-kill clj

(script-kill this)

Kill the script currently in execution

script-load clj

(script-load this script)

Load the specified Lua script into the script cache

ServerCommands clj protocol

Redis Server Commands

slowlog-get clj

(slowlog-get this)

(slowlog-get this count)

Read the slow log

debug-htstats clj

(debug-htstats this db)

Get debugging information about the internal hash-table state

bgrewriteaof clj

(bgrewriteaof this)

Asynchronously rewrite the append-only file

debug-segfault clj

(debug-segfault this)

Make the server crash: Invalid pointer access

shutdown clj

(shutdown this save?)

Synchronously save the dataset to disk and shutdown the server

client-kill clj

(client-kill this addr-or-args)

Kill the connection of a client identified by ip:port, or args

debug-oom clj

(debug-oom this)

Make the server crash: Out of memory

command-info clj

(command-info this commands)

Return an array reply of details about the requested commands

slowlog-len clj

(slowlog-len this)

Obtaining the current length of the slow log

client-setname clj

(client-setname this name)

Set the current connection name

slowlog-reset clj

(slowlog-reset this)

Resetting the slow log

slaveof-no-one clj

(slaveof-no-one this)

Promote server as master

slaveof clj

(slaveof this host port)

Make the server a slave of another server, or promote it as master

client-pause clj

(client-pause this timeout-ms)

Stop processing commands from clients for some time

flushall clj

(flushall this)

Remove all keys from all databases

config-rewrite clj

(config-rewrite this)

Rewrite the configuration file with the in memory configuration

command-count clj

(command-count this)

Get total number of Redis commands

debug-restart clj

(debug-restart this delay-ms)

Restart the server gracefully

debug-crash-recov clj

(debug-crash-recov this delay-ms)

Crash and recover

time clj

(time this)

Return the current server time

client-list clj

(client-list this)

Get the list of client connections

debug-reload clj

(debug-reload this)

Save RDB, clear the database and reload RDB

debug-object clj

(debug-object this key)

Get debugging information about a key

command clj

(command this)

Return an array reply of details about all Redis commands

dbsize clj

(dbsize this)

Return the number of keys in the selected database

bgsave clj

(bgsave this)

Asynchronously save the dataset to disk

save clj

(save this)

Synchronously save the dataset to disk

debug-sds-len clj

(debug-sds-len this key)

Get debugging information about the internal SDS length

flushdb-async clj

(flushdb-async this)

Remove all keys asynchronously from the current database

config-get clj

(config-get this param)

Get the value of a configuration parameter

flushall-async clj

(flushall-async this)

Remove all keys asynchronously from all databases

config-set clj

(config-set this param val)

Set a configuration parameter to the given value

info clj

(info this)

(info this section)

Get information and statistics about the server

lastsave clj

(lastsave this)

Get the UNIX time stamp of the last successful save to disk

flushdb clj

(flushdb this)

Remove all keys from the current database

client-getname clj

(client-getname this)

Get the current connection name

config-resetstat clj

(config-resetstat this)

Reset the stats returned by INFO

set-args clj

(set-args & {ex :ex px :px nx :nx xx :xx})

SetCommands clj protocol

Redis Set Commands

msrem clj

(msrem this key members)

Remove multiple members from a set

sunionstore clj

(sunionstore this dest keys)

Add multiple sets and store the resulting set in a key

sismember clj

(sismember this key val)

Determine if a given value is a member of a set

sinterstore clj

(sinterstore this dest keys)

Intersect multiple sets and store the resulting set in a key

sadd clj

(sadd this key member)

Add one member to a set

scard clj

(scard this key)

Get the number of members in a set

srandmember clj

(srandmember this key)

(srandmember this key count)

Get one or multiple random members from a set

smembers clj

(smembers this key)

Get all the members in a set

srem clj

(srem this key member)

Remove one member from a set

sinter clj

(sinter this keys)

Intersect multiple sets

sunion clj

(sunion this keys)

Add multiple sets

sscan clj

(sscan this key)

(sscan this key cursor)

(sscan this key cursor args)

Incrementally iterate set elements

msadd clj

(msadd this key members)

Add multiple members to a set

sdiffstore clj

(sdiffstore this dest keys)

Subtract multiple sets and store the resulting set in a key

smove clj

(smove this key dest member)

Move a member from one set to another

sdiff clj

(sdiff this keys)

Subtract multiple sets

spop clj

(spop this key)

(spop this key count)

Remove and return one or multiple random members from a set

sort-args clj

(sort-args &
           {by :by
            [offset count :as limit] :limit
            get :get
            asc :asc
            desc :desc
            alpha :alpha})

SortedSetCommands clj protocol

Redis Sorted Set Commands

zrange clj

(zrange this key start end)

Return a range of members in a sorted set, by index (scores asc)

zremrangebyscore clj

(zremrangebyscore this key min max)

Remove all members in a sorted set within the given scores

zscore clj

(zscore this key member)

Get the score associated with the given member in a sorted set.

zrevrange-withscores clj

(zrevrange-withscores this key start end)

zinterstore clj

(zinterstore this dest keys)

(zinterstore this dest args keys)

Intersect multiple sorted sets ks, store the result in a new key d

mzrem clj

(mzrem this key members)

Remove multiple members from a sorted set

zscan clj

(zscan this key)

(zscan this key cursor)

(zscan this key cursor args)

Incrementally iterate sorted sets elements and associated scores

zremrangebyrank clj

(zremrangebyrank this key start end)

Remove all members in a sorted set within the given indexes

zrange-withscores clj

(zrange-withscores this key start end)

zunionstore clj

(zunionstore this dest keys)

(zunionstore this dest args keys)

Add multiple sorted sets ks, store the result in a new key d

zrevrank clj

(zrevrank this key member)

Determine the index of a member in a sorted set (score desc)

zrank clj

(zrank this key member)

Determine the index of a member in a sorted set (score asc)

zcard clj

(zcard this key)

Get the number of members in a sorted set

zincrby clj

(zincrby this key amount member)

Increment the score of a member in a sorted set

zrangebylex clj

(zrangebylex this key min max)

(zrangebylex this key min max offset count)

Return a range of members in a sorted set, by lexicographical range

zadd clj

(zadd this key score member)

(zadd this key args score member)

Add one member to a sorted set (update score if exists)

zcount clj

(zcount this key min max)

Count the members in a sorted set with scores within [min max]

zrem clj

(zrem this key member)

Remove one member from a sorted set

zremrangebylex clj

(zremrangebylex this key min max)

Remove all members in a sorted set in a given lexicographical range

mzadd clj

(mzadd this key scored-members)

(mzadd this key args scored-members)

Add multiple members to a sorted set (update scores if exist)

zlexcount clj

(zlexcount this key min max)

Count the members in a sorted set in a given lexicographical range

zrangebyscore-withscores clj

(zrangebyscore-withscores this key min max)

(zrangebyscore-withscores this key min max offset count)

zaddincr clj

(zaddincr this key score member)

Increment the score of a member in a sorted set

zrevrange clj

(zrevrange this key start end)

Return a range of members in a sorted set, by index (scores desc)

zrevrangebyscore clj

(zrevrangebyscore this key min max)

(zrevrangebyscore this key min max offset count)

Return a range of members in a sorted set, by score (scores desc)

zrevrangebyscore-withscores clj

(zrevrangebyscore-withscores this key min max)

(zrevrangebyscore-withscores this key min max offset count)

zrangebyscore clj

(zrangebyscore this key min max)

(zrangebyscore this key min max offset count)

Return a range of members in a sorted set, by score (scores asc)

sscan-seq clj

(sscan-seq cmds key)

(sscan-seq cmds key args)

Lazy SSCAN sequence, takes optional scan-args

StringsCommands clj protocol

Redis Strings Commands

mset clj

(mset this map)

Set multiple keys to multiple values (map)

bitfield clj

(bitfield this key args)

Execute BITFIELD with its subcommands

bitop-xor clj

(bitop-xor this dest keys)

Perform bitwise XOR between strings

setex clj

(setex this key ttl-sec val)

Set the value and expiration of a key

set clj

(set this key val)

(set this key val args)

Set the string value of a key

getbit clj

(getbit this key offset)

Get the bit value at offset in the key's string value

decr clj

(decr this key)

Decrement the integer value of a key by one

psetex clj

(psetex this key ttl-ms val)

Set the value and expiration in milliseconds of a key

bitop-or clj

(bitop-or this dest keys)

Perform bitwise OR between strings

mget clj

(mget this keys)

Get the values of all the given keys

bitcount clj

(bitcount this key)

(bitcount this key start end)

Count the bits set to 1 in a string

bitop-and clj

(bitop-and this dest keys)

Perform bitwise AND between strings

get clj

(get this key)

Get the value of a key

bitop-not clj

(bitop-not this dest key)

Perform bitwise NOT between strings

strlen clj

(strlen this key)

Get the length of the value stored in a key

setrange clj

(setrange this key offset val)

Overwrite part of a string at key starting at the offset

incr clj

(incr this key)

Increment the integer value of a key by one

append clj

(append this key val)

Append a value to a key

setnx clj

(setnx this key val)

Set the value of a key, only if the key does not exist

getset clj

(getset this key val)

Set the string value of a key and return its old value

bitpos clj

(bitpos this key state)

(bitpos this key state start end)

Find first bit set or clear in a string

incrbyfloat clj

(incrbyfloat this key amount)

Increment the float value of a key by the given amount

getrange clj

(getrange this key start end)

Get a substring of the string stored at a key

msetnx clj

(msetnx this map)

Like mset, but only if none of the keys exist

decrby clj

(decrby this key amount)

Decrement the integer value of a key by the given number

incrby clj

(incrby this key amount)

Increment the integer value of a key by the given amount

setbit clj

(setbit this key offset val)

Sets or clears the bit at offset in the key's string value

TransactionalCommands clj protocol

Redis Transactional Commands

discard clj

(discard this)

Discard all commands issued after MULTI

exec clj

(exec this)

Execute all commands issued after MULTI

multi clj

(multi this)

Mark the start of a transaction block

mwatch clj

(mwatch this keys)

Watch keys to determine execution of a transaction

unwatch clj

(unwatch this)

Forget about all watched keys

watch clj

(watch this key)

Watch key to determine execution of a transaction

zscan-seq clj

(zscan-seq cmds key)

(zscan-seq cmds key args)

Lazy ZSCAN sequence, takes optional scan-args

zstore-args clj

(zstore-args agg & weights)