hedis-0.9.9: Client library for the Redis datastore: supports full command set, pipelining.

Safe Haskell | None
Language | Haskell98

Database.Redis

Contents

- How To Use This Module
  - Command Type Signatures
  - Lua Scripting
  - Automatic Pipelining
  - Error Behavior
- The Redis Monad
- Connection
- Commands
  - Connection
  - Keys
  - Hashes
  - HyperLogLogs
  - Lists
  - Scripting
  - Server
  - Sets
  - Sorted Sets
  - Strings
- Unimplemented Commands
- Transactions
- Pub/Sub
  - Subscribing to channels
    - Single-thread Pub/Sub
    - Continuous Pub/Sub message controller
- Low-Level Command API

Synopsis

- data Redis a
- runRedis :: Connection -> Redis a -> IO a
- unRedis :: Redis a -> ReaderT RedisEnv IO a
- reRedis :: ReaderT RedisEnv IO a -> Redis a
- class MonadRedis m => RedisCtx m f | m -> f where
  - returnDecode :: RedisResult a => Reply -> m (f a)
- class Monad m => MonadRedis m where
  - liftRedis :: Redis a -> m a
- data Connection
- connect :: ConnectInfo -> IO Connection
- checkedConnect :: ConnectInfo -> IO Connection
- data ConnectInfo = ConnInfo {
  - connectHost :: HostName
  - connectPort :: PortID
  - connectAuth :: Maybe ByteString
  - connectDatabase :: Integer
  - connectMaxConnections :: Int
  - connectMaxIdleTime :: NominalDiffTime
  }
- defaultConnectInfo :: ConnectInfo
- type HostName = String
- data PortID :: *
  - = Service String
  - | PortNumber PortNumber
  - | UnixSocket String
- auth :: ByteString -> Redis (Either Reply Status)
- echo :: RedisCtx m f => ByteString -> m (f ByteString)
- ping :: RedisCtx m f => m (f Status)
- quit :: RedisCtx m f => m (f Status)
- select :: RedisCtx m f => Integer -> m (f Status)
- del :: RedisCtx m f => [ByteString] -> m (f Integer)
- dump :: RedisCtx m f => ByteString -> m (f ByteString)
- exists :: RedisCtx m f => ByteString -> m (f Bool)
- expire :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
- expireat :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
- keys :: RedisCtx m f => ByteString -> m (f [ByteString])
- data MigrateOpts = MigrateOpts {
  - migrateCopy :: Bool
  - migrateReplace :: Bool
  }
- defaultMigrateOpts :: MigrateOpts
- migrate :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Integer -> Integer -> m (f Status)
- migrateMultiple :: RedisCtx m f => ByteString -> ByteString -> Integer -> Integer -> MigrateOpts -> [ByteString] -> m (f Status)
- move :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
- objectRefcount :: RedisCtx m f => ByteString -> m (f Integer)
- objectEncoding :: RedisCtx m f => ByteString -> m (f ByteString)
- objectIdletime :: RedisCtx m f => ByteString -> m (f Integer)
- persist :: RedisCtx m f => ByteString -> m (f Bool)
- pexpire :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
- pexpireat :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
- pttl :: RedisCtx m f => ByteString -> m (f Integer)
- randomkey :: RedisCtx m f => m (f (Maybe ByteString))
- rename :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
- renamenx :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
- restore :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
- restoreReplace :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
- data Cursor
- cursor0 :: Cursor
- data ScanOpts = ScanOpts {
  - scanMatch :: Maybe ByteString
  - scanCount :: Maybe Integer
  }
- defaultScanOpts :: ScanOpts
- scan :: RedisCtx m f => Cursor -> m (f (Cursor, [ByteString]))
- scanOpts :: RedisCtx m f => Cursor -> ScanOpts -> m (f (Cursor, [ByteString]))
- data SortOpts = SortOpts {
  - sortBy :: Maybe ByteString
  - sortLimit :: (Integer, Integer)
  - sortGet :: [ByteString]
  - sortOrder :: SortOrder
  - sortAlpha :: Bool
  }
- defaultSortOpts :: SortOpts
- data SortOrder
  - = Asc
  - | Desc
- sort :: RedisCtx m f => ByteString -> SortOpts -> m (f [ByteString])
- sortStore :: RedisCtx m f => ByteString -> ByteString -> SortOpts -> m (f Integer)
- ttl :: RedisCtx m f => ByteString -> m (f Integer)
- data RedisType
  - = None
  - | String
  - | Hash
  - | List
  - | Set
  - | ZSet
- getType :: RedisCtx m f => ByteString -> m (f RedisType)
- wait :: RedisCtx m f => Integer -> Integer -> m (f Integer)
- hdel :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- hexists :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
- hget :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
- hgetall :: RedisCtx m f => ByteString -> m (f [(ByteString, ByteString)])
- hincrby :: RedisCtx m f => ByteString -> ByteString -> Integer -> m (f Integer)
- hincrbyfloat :: RedisCtx m f => ByteString -> ByteString -> Double -> m (f Double)
- hkeys :: RedisCtx m f => ByteString -> m (f [ByteString])
- hlen :: RedisCtx m f => ByteString -> m (f Integer)
- hmget :: RedisCtx m f => ByteString -> [ByteString] -> m (f [Maybe ByteString])
- hmset :: RedisCtx m f => ByteString -> [(ByteString, ByteString)] -> m (f Status)
- hscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [(ByteString, ByteString)]))
- hscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [(ByteString, ByteString)]))
- hset :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
- hsetnx :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
- hstrlen :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- hvals :: RedisCtx m f => ByteString -> m (f [ByteString])
- pfadd :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- pfcount :: RedisCtx m f => [ByteString] -> m (f Integer)
- pfmerge :: RedisCtx m f => ByteString -> [ByteString] -> m (f ByteString)
- blpop :: RedisCtx m f => [ByteString] -> Integer -> m (f (Maybe (ByteString, ByteString)))
- brpop :: RedisCtx m f => [ByteString] -> Integer -> m (f (Maybe (ByteString, ByteString)))
- brpoplpush :: RedisCtx m f => ByteString -> ByteString -> Integer -> m (f (Maybe ByteString))
- lindex :: RedisCtx m f => ByteString -> Integer -> m (f (Maybe ByteString))
- linsertBefore :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
- linsertAfter :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
- llen :: RedisCtx m f => ByteString -> m (f Integer)
- lpop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
- lpush :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- lpushx :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- lrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
- lrem :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
- lset :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
- ltrim :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f Status)
- rpop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
- rpoplpush :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
- rpush :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- rpushx :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- eval :: (RedisCtx m f, RedisResult a) => ByteString -> [ByteString] -> [ByteString] -> m (f a)
- evalsha :: (RedisCtx m f, RedisResult a) => ByteString -> [ByteString] -> [ByteString] -> m (f a)
- data DebugMode
- scriptDebug :: RedisCtx m f => DebugMode -> m (f Bool)
- scriptExists :: RedisCtx m f => [ByteString] -> m (f [Bool])
- scriptFlush :: RedisCtx m f => m (f Status)
- scriptKill :: RedisCtx m f => m (f Status)
- scriptLoad :: RedisCtx m f => ByteString -> m (f ByteString)
- bgrewriteaof :: RedisCtx m f => m (f Status)
- bgsave :: RedisCtx m f => m (f Status)
- clientGetname :: RedisCtx m f => m (f Status)
- clientList :: RedisCtx m f => m (f [ByteString])
- clientPause :: RedisCtx m f => Integer -> m (f Status)
- data ReplyMode
- clientReply :: RedisCtx m f => ReplyMode -> m (f Bool)
- clientSetname :: RedisCtx m f => ByteString -> m (f ByteString)
- commandCount :: RedisCtx m f => m (f Integer)
- commandInfo :: RedisCtx m f => [ByteString] -> m (f [ByteString])
- configGet :: RedisCtx m f => ByteString -> m (f [(ByteString, ByteString)])
- configResetstat :: RedisCtx m f => m (f Status)
- configRewrite :: RedisCtx m f => m (f Status)
- configSet :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
- dbsize :: RedisCtx m f => m (f Integer)
- debugObject :: RedisCtx m f => ByteString -> m (f ByteString)
- flushall :: RedisCtx m f => m (f Status)
- flushdb :: RedisCtx m f => m (f Status)
- info :: RedisCtx m f => m (f ByteString)
- infoSection :: RedisCtx m f => ByteString -> m (f ByteString)
- lastsave :: RedisCtx m f => m (f Integer)
- save :: RedisCtx m f => m (f Status)
- slaveof :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
- data Slowlog = Slowlog {
  - slowlogId :: Integer
  - slowlogTimestamp :: Integer
  - slowlogMicros :: Integer
  - slowlogCmd :: [ByteString]
  }
- slowlogGet :: RedisCtx m f => Integer -> m (f [Slowlog])
- slowlogLen :: RedisCtx m f => m (f Integer)
- slowlogReset :: RedisCtx m f => m (f Status)
- time :: RedisCtx m f => m (f (Integer, Integer))
- sadd :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- scard :: RedisCtx m f => ByteString -> m (f Integer)
- sdiff :: RedisCtx m f => [ByteString] -> m (f [ByteString])
- sdiffstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- sinter :: RedisCtx m f => [ByteString] -> m (f [ByteString])
- sinterstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- sismember :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
- smembers :: RedisCtx m f => ByteString -> m (f [ByteString])
- smove :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
- spop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
- srandmember :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
- srandmemberN :: RedisCtx m f => ByteString -> Integer -> m (f (Maybe ByteString))
- srem :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- sscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [ByteString]))
- sscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [ByteString]))
- sunion :: RedisCtx m f => [ByteString] -> m (f [ByteString])
- sunionstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- data ZaddOpts = ZaddOpts {
  - zaddCondition :: Maybe Condition
  - zaddChange :: Bool
  - zaddIncrement :: Bool
  }
- defaultZaddOpts :: ZaddOpts
- zadd :: RedisCtx m f => ByteString -> [(Double, ByteString)] -> m (f Integer)
- zaddOpts :: RedisCtx m f => ByteString -> [(Double, ByteString)] -> ZaddOpts -> m (f Integer)
- zcard :: RedisCtx m f => ByteString -> m (f Integer)
- zcount :: RedisCtx m f => ByteString -> Double -> Double -> m (f Integer)
- zincrby :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Double)
- data Aggregate
  - = Sum
  - | Min
  - | Max
- zinterstore :: RedisCtx m f => ByteString -> [ByteString] -> Aggregate -> m (f Integer)
- zinterstoreWeights :: RedisCtx m f => ByteString -> [(ByteString, Double)] -> Aggregate -> m (f Integer)
- zlexcount :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
- zrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
- zrangeWithscores :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [(ByteString, Double)])
- data RangeLex a
  - = Incl a
  - | Excl a
  - | Minr
  - | Maxr
- zrangebylex :: RedisCtx m f => ByteString -> RangeLex ByteString -> RangeLex ByteString -> m (f [ByteString])
- zrangebylexLimit :: RedisCtx m f => ByteString -> RangeLex ByteString -> RangeLex ByteString -> Integer -> Integer -> m (f [ByteString])
- zrangebyscore :: RedisCtx m f => ByteString -> Double -> Double -> m (f [ByteString])
- zrangebyscoreWithscores :: RedisCtx m f => ByteString -> Double -> Double -> m (f [(ByteString, Double)])
- zrangebyscoreLimit :: RedisCtx m f => ByteString -> Double -> Double -> Integer -> Integer -> m (f [ByteString])
- zrangebyscoreWithscoresLimit :: RedisCtx m f => ByteString -> Double -> Double -> Integer -> Integer -> m (f [(ByteString, Double)])
- zrank :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Integer))
- zrem :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- zremrangebylex :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
- zremrangebyrank :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f Integer)
- zremrangebyscore :: RedisCtx m f => ByteString -> Double -> Double -> m (f Integer)
- zrevrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
- zrevrangeWithscores :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [(ByteString, Double)])
- zrevrangebyscore :: RedisCtx m f => ByteString -> Double -> Double -> m (f [ByteString])
- zrevrangebyscoreWithscores :: RedisCtx m f => ByteString -> Double -> Double -> m (f [(ByteString, Double)])
- zrevrangebyscoreLimit :: RedisCtx m f => ByteString -> Double -> Double -> Integer -> Integer -> m (f [ByteString])
- zrevrangebyscoreWithscoresLimit :: RedisCtx m f => ByteString -> Double -> Double -> Integer -> Integer -> m (f [(ByteString, Double)])
- zrevrank :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Integer))
- zscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [(ByteString, Double)]))
- zscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [(ByteString, Double)]))
- zscore :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Double))
- zunionstore :: RedisCtx m f => ByteString -> [ByteString] -> Aggregate -> m (f Integer)
- zunionstoreWeights :: RedisCtx m f => ByteString -> [(ByteString, Double)] -> Aggregate -> m (f Integer)
- append :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- bitcount :: RedisCtx m f => ByteString -> m (f Integer)
- bitcountRange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f Integer)
- bitopAnd :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- bitopOr :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- bitopXor :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
- bitopNot :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- bitpos :: RedisCtx m f => ByteString -> Integer -> Integer -> Integer -> m (f Integer)
- decr :: RedisCtx m f => ByteString -> m (f Integer)
- decrby :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
- get :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
- getbit :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
- getrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f ByteString)
- getset :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
- incr :: RedisCtx m f => ByteString -> m (f Integer)
- incrby :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
- incrbyfloat :: RedisCtx m f => ByteString -> Double -> m (f Double)
- mget :: RedisCtx m f => [ByteString] -> m (f [Maybe ByteString])
- mset :: RedisCtx m f => [(ByteString, ByteString)] -> m (f Status)
- msetnx :: RedisCtx m f => [(ByteString, ByteString)] -> m (f Bool)
- psetex :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
- data Condition
  - = Nx
  - | Xx
- data SetOpts = SetOpts {
  - setSeconds :: Maybe Integer
  - setMilliseconds :: Maybe Integer
  - setCondition :: Maybe Condition
  }
- set :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
- setOpts :: RedisCtx m f => ByteString -> ByteString -> SetOpts -> m (f Status)
- setbit :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
- setex :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
- setnx :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
- setrange :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
- strlen :: RedisCtx m f => ByteString -> m (f Integer)
- watch :: [ByteString] -> Redis (Either Reply Status)
- unwatch :: Redis (Either Reply Status)
- multiExec :: RedisTx (Queued a) -> Redis (TxResult a)
- data Queued a
- data TxResult a
  - = TxSuccess a
  - | TxAborted
  - | TxError String
- data RedisTx a
- publish :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
- pubSub :: PubSub -> (Message -> IO PubSub) -> Redis ()
- data Message
  - = Message {
    - msgChannel, msgMessage :: ByteString
    }
  - | PMessage {
    - msgPattern, msgChannel, msgMessage :: ByteString
    }
- data PubSub
- subscribe :: [ByteString] -> PubSub
- unsubscribe :: [ByteString] -> PubSub
- psubscribe :: [ByteString] -> PubSub
- punsubscribe :: [ByteString] -> PubSub
- pubSubForever :: Connection -> PubSubController -> IO () -> IO ()
- type RedisChannel = ByteString
- type RedisPChannel = ByteString
- type MessageCallback = ByteString -> IO ()
- type PMessageCallback = RedisChannel -> ByteString -> IO ()
- data PubSubController
- newPubSubController :: MonadIO m => [(RedisChannel, MessageCallback)] -> [(RedisPChannel, PMessageCallback)] -> m PubSubController
- currentChannels :: MonadIO m => PubSubController -> m [RedisChannel]
- currentPChannels :: MonadIO m => PubSubController -> m [RedisPChannel]
- addChannels :: MonadIO m => PubSubController -> [(RedisChannel, MessageCallback)] -> [(RedisPChannel, PMessageCallback)] -> m UnregisterCallbacksAction
- addChannelsAndWait :: MonadIO m => PubSubController -> [(RedisChannel, MessageCallback)] -> [(RedisPChannel, PMessageCallback)] -> m UnregisterCallbacksAction
- removeChannels :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()
- removeChannelsAndWait :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()
- type UnregisterCallbacksAction = IO ()
- sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)
- data Reply
  - = SingleLine ByteString
  - | Error ByteString
  - | Integer Integer
  - | Bulk (Maybe ByteString)
  - | MultiBulk (Maybe [Reply])
- data Status
  - = Ok
  - | Pong
  - | Status ByteString
- class RedisResult a where
  - decode :: Reply -> Either Reply a
- data ConnectionLostException = ConnectionLost

# How To Use This Module

Connect to a Redis server:

    -- connects to localhost:6379
    conn <- checkedConnect defaultConnectInfo

Send commands to the server:

    {-# LANGUAGE OverloadedStrings #-}
    ...
    runRedis conn $ do
         set "hello" "hello"
         set "world" "world"
         hello <- get "hello"
         world <- get "world"
         liftIO $ print (hello,world)

## Command Type Signatures

Redis commands behave differently when issued in- or outside of a transaction. To make them work in both contexts, most command functions have a type signature similar to the following:

     echo :: (RedisCtx m f) => ByteString -> m (f ByteString)

Here is how to interpret this type signature:

- The argument types are independent of the execution context. `echo` always takes a `ByteString` parameter, whether in- or outside of a transaction. This is true for all command functions.
- All Redis commands return their result wrapped in some "container". The type `f` of this container depends on the commands execution context `m`. The `ByteString` return type in the example is specific to the `echo` command. For other commands, it will often be another type.
- In the "normal" context `Redis`, outside of any transactions, results are wrapped in an ``Either` `Reply``.
- Inside a transaction, in the `RedisTx` context, results are wrapped in a `Queued`.

In short, you can view any command with a `RedisCtx` constraint in the type signature, to "have two types". For example `echo` "has both types":

     echo :: ByteString -> Redis (Either Reply ByteString)
     echo :: ByteString -> RedisTx (Queued ByteString)

Exercise
  What are the types of `expire` inside a transaction and `lindex` outside of a transaction? The solutions are at the very bottom of this page.

## Lua Scripting

Lua values returned from the `eval` and `evalsha` functions will be converted to Haskell values by the `decode` function from the `RedisResult` type class.

     Lua Type      | Haskell Type       | Conversion Example
     --------------|--------------------|-----------------------------
     Number        | Integer            | 1.23   => 1
     String        | ByteString, Double | "1.23" => "1.23" or 1.23
     Boolean       | Bool               | false  => False
     Table         | List               | {1,2}  => [1,2]

Additionally, any of the Haskell types from the table above can be wrapped in a `Maybe`:

     42  => Just 42 :: Maybe Integer
     nil => Nothing :: Maybe Integer

Note that Redis imposes some limitations on the possible conversions:

- Lua numbers can only be converted to Integers. Only Lua strings can be interpreted as Doubles.
- Associative Lua tables can not be converted at all. Returned tables must be "arrays", i.e. indexed only by integers.

The Redis Scripting website (http://redis.io/commands/eval) documents the exact semantics of the scripting commands and value conversion.

## Automatic Pipelining

Commands are automatically pipelined as much as possible. For example, in the above "hello world" example, all four commands are pipelined. Automatic pipelining makes use of Haskell's laziness. As long as a previous reply is not evaluated, subsequent commands can be pipelined.

Automatic pipelining is limited to the scope of `runRedis` call and it is guaranteed that every reply expected as a part of `runRedis` execution gets received after `runRedis` invocation.

To keep memory usage low, the number of requests "in the pipeline" is limited (per connection) to 1000. After that number, the next command is sent only when at least one reply has been received. That means, command functions may block until there are less than 1000 outstanding replies.

## Error Behavior

Operations against keys holding the wrong kind of value:
  Outside of a transaction, if the Redis server returns an `Error`, command functions will return `Left` the `Reply`. The library user can inspect the error message to gain information on what kind of error occured.
Connection to the server lost:
  In case of a lost connection, command functions throw a `ConnectionLostException`. It can only be caught outside of `runRedis`.
Trying to connect to an unreachable server:
  When trying to connect to a server that does not exist or can't be reached, the connection pool only starts the first connection when actually executing a call to the server. This can lead to discovering very late that the server is not available, for example when running a server that logs to Redis. To prevent this, run a `ping` command directly after connecting or use the `checkedConnect` function which encapsulates this behavior.
Exceptions:
  Any exceptions can only be caught outside of `runRedis`. This way the connection pool can properly close the connection, making sure it is not left in an unusable state, e.g. closed or inside a transaction.

# The Redis Monad

data Redis a

Context for normal command execution, outside of transactions. Use `runRedis` to run actions of this type.

In this context, each result is wrapped in an `Either` to account for the possibility of Redis returning an `Error` reply.

Instances

Monad Redis |
Functor Redis |
Applicative Redis |
MonadIO Redis |
MonadRedis Redis |
RedisCtx Redis (Either Reply) |

runRedis :: Connection -> Redis a -> IO a

Interact with a Redis datastore specified by the given `Connection`.

Each call of `runRedis` takes a network connection from the `Connection` pool and runs the given `Redis` action. Calls to `runRedis` may thus block while all connections from the pool are in use.

unRedis :: Redis a -> ReaderT RedisEnv IO a

Deconstruct Redis constructor.

`unRedis` and `reRedis` can be used to define instances for arbitrary typeclasses.

WARNING! These functions are considered internal and no guarantee is given at this point that they will not break in future.

reRedis :: ReaderT RedisEnv IO a -> Redis a

Reconstruct Redis constructor.

class MonadRedis m => RedisCtx m f | m -> f where

This class captures the following behaviour: In a context `m`, a command will return its result wrapped in a "container" of type `f`.

Please refer to the Command Type Signatures section of this page for more information.

Methods

returnDecode :: RedisResult a => Reply -> m (f a)

Instances

RedisCtx RedisTx Queued |
RedisCtx Redis (Either Reply) |

class Monad m => MonadRedis m where

Methods

liftRedis :: Redis a -> m a

Instances

MonadRedis Redis |
MonadRedis RedisTx |

# Connection

data Connection

A threadsafe pool of network connections to a Redis server. Use the `connect` function to create one.

connect :: ConnectInfo -> IO Connection

Constructs a `Connection` pool to a Redis server designated by the given `ConnectInfo`. The first connection is not actually established until the first call to the server.

checkedConnect :: ConnectInfo -> IO Connection

Constructs a `Connection` pool to a Redis server designated by the given `ConnectInfo`, then tests if the server is actually there. Throws an exception if the connection to the Redis server can't be established.

data ConnectInfo

Information for connnecting to a Redis server.

It is recommended to not use the `ConnInfo` data constructor directly. Instead use `defaultConnectInfo` and update it with record syntax. For example to connect to a password protected Redis server running on localhost and listening to the default port:

    myConnectInfo :: ConnectInfo
    myConnectInfo = defaultConnectInfo {connectAuth = Just "secret"}

Constructors

ConnInfo |

Fields

connectHost :: HostName
connectPort :: PortID
connectAuth :: Maybe ByteString

  When the server is protected by a password, set `connectAuth` to `Just` the password. Each connection will then authenticate by the `auth` command.

connectDatabase :: Integer

  Each connection will `select` the database with the given index.

connectMaxConnections :: Int

  Maximum number of connections to keep open. The smallest acceptable value is 1.

connectMaxIdleTime :: NominalDiffTime

  Amount of time for which an unused connection is kept open. The smallest acceptable value is 0.5 seconds. If the `timeout` value in your redis.conf file is non-zero, it should be larger than `connectMaxIdleTime`.

Instances

Show ConnectInfo |

defaultConnectInfo :: ConnectInfo

Default information for connecting:

     connectHost           = "localhost"
     connectPort           = PortNumber 6379 -- Redis default port
     connectAuth           = Nothing         -- No password
     connectDatabase       = 0               -- SELECT database 0
     connectMaxConnections = 50              -- Up to 50 connections
     connectMaxIdleTime    = 30              -- Keep open for 30 seconds

type HostName = String

Either a host name e.g., `"haskell.org"` or a numeric host address string consisting of a dotted decimal IPv4 address or an IPv6 address e.g., `"192.168.0.1"`.

data PortID :: *

Constructors

Service String |
PortNumber PortNumber |
UnixSocket String |

Instances

Eq PortID |
Show PortID |

# Commands

## Connection

auth

Arguments

:: ByteString | password
-> Redis (Either Reply Status) |

Authenticate to the server (http://redis.io/commands/auth). Since Redis 1.0.0

echo

Arguments

:: RedisCtx m f |
=> ByteString | message
-> m (f ByteString) |

Echo the given string (http://redis.io/commands/echo). Since Redis 1.0.0

ping :: RedisCtx m f => m (f Status)

Ping the server (http://redis.io/commands/ping). Since Redis 1.0.0

quit :: RedisCtx m f => m (f Status)

Close the connection (http://redis.io/commands/quit). Since Redis 1.0.0

select

Arguments

:: RedisCtx m f |
=> Integer | index
-> m (f Status) |

Change the selected database for the current connection (http://redis.io/commands/select). Since Redis 1.0.0

## Keys

del

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f Integer) |

Delete a key (http://redis.io/commands/del). Since Redis 1.0.0

dump

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f ByteString) |

Return a serialized version of the value stored at the specified key (http://redis.io/commands/dump). Since Redis 2.6.0

exists

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Bool) |

Determine if a key exists (http://redis.io/commands/exists). Since Redis 1.0.0

expire

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | seconds
-> m (f Bool) |

Set a key's time to live in seconds (http://redis.io/commands/expire). Since Redis 1.0.0

expireat

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | timestamp
-> m (f Bool) |

Set the expiration for a key as a UNIX timestamp (http://redis.io/commands/expireat). Since Redis 1.2.0

keys

Arguments

:: RedisCtx m f |
=> ByteString | pattern
-> m (f [ByteString]) |

Find all keys matching the given pattern (http://redis.io/commands/keys). Since Redis 1.0.0

data MigrateOpts

Options for the `migrate` command.

Constructors

MigrateOpts |

Fields

migrateCopy :: Bool
migrateReplace :: Bool

Instances

Eq MigrateOpts |
Show MigrateOpts |

defaultMigrateOpts :: MigrateOpts

Redis default `MigrateOpts`. Equivalent to omitting all optional parameters.

    MigrateOpts
        { migrateCopy    = False -- remove the key from the local instance
        , migrateReplace = False -- don't replace existing key on the remote instance
        }

migrate

Arguments

:: RedisCtx m f |
=> ByteString | host
-> ByteString | port
-> ByteString | key
-> Integer | destinationDb
-> Integer | timeout
-> m (f Status) |

Atomically transfer a key from a Redis instance to another one (http://redis.io/commands/migrate). The Redis command `MIGRATE` is split up into `migrate`, `migrateMultiple`. Since Redis 2.6.0

migrateMultiple

Arguments

:: RedisCtx m f |
=> ByteString | host
-> ByteString | port
-> Integer | destinationDb
-> Integer | timeout
-> MigrateOpts |
-> [ByteString] | keys
-> m (f Status) |

Atomically transfer a key from a Redis instance to another one (http://redis.io/commands/migrate). The Redis command `MIGRATE` is split up into `migrate`, `migrateMultiple`. Since Redis 2.6.0

move

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | db
-> m (f Bool) |

Move a key to another database (http://redis.io/commands/move). Since Redis 1.0.0

objectRefcount

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command `OBJECT` is split up into `objectRefcount`, `objectEncoding`, `objectIdletime`. Since Redis 2.2.3

objectEncoding

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f ByteString) |

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command `OBJECT` is split up into `objectRefcount`, `objectEncoding`, `objectIdletime`. Since Redis 2.2.3

objectIdletime

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command `OBJECT` is split up into `objectRefcount`, `objectEncoding`, `objectIdletime`. Since Redis 2.2.3

persist

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Bool) |

Remove the expiration from a key (http://redis.io/commands/persist). Since Redis 2.2.0

pexpire

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | milliseconds
-> m (f Bool) |

Set a key's time to live in milliseconds (http://redis.io/commands/pexpire). Since Redis 2.6.0

pexpireat

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | millisecondsTimestamp
-> m (f Bool) |

Set the expiration for a key as a UNIX timestamp specified in milliseconds (http://redis.io/commands/pexpireat). Since Redis 2.6.0

pttl

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the time to live for a key in milliseconds (http://redis.io/commands/pttl). Since Redis 2.6.0

randomkey :: RedisCtx m f => m (f (Maybe ByteString))

Return a random key from the keyspace (http://redis.io/commands/randomkey). Since Redis 1.0.0

rename

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | newkey
-> m (f Status) |

Rename a key (http://redis.io/commands/rename). Since Redis 1.0.0

renamenx

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | newkey
-> m (f Bool) |

Rename a key, only if the new key does not exist (http://redis.io/commands/renamenx). Since Redis 1.0.0

restore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | timeToLive
-> ByteString | serializedValue
-> m (f Status) |

Create a key using the provided serialized value, previously obtained using DUMP (http://redis.io/commands/restore). The Redis command `RESTORE` is split up into `restore`, `restoreReplace`. Since Redis 2.6.0

restoreReplace

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | timeToLive
-> ByteString | serializedValue
-> m (f Status) |

Create a key using the provided serialized value, previously obtained using DUMP (http://redis.io/commands/restore). The Redis command `RESTORE` is split up into `restore`, `restoreReplace`. Since Redis 2.6.0

data Cursor

Instances

Eq Cursor |
Show Cursor |
RedisResult Cursor |

cursor0 :: Cursor

data ScanOpts

Constructors

ScanOpts |

Fields

scanMatch :: Maybe ByteString
scanCount :: Maybe Integer

Instances

Eq ScanOpts |
Show ScanOpts |

defaultScanOpts :: ScanOpts

Redis default `ScanOpts`. Equivalent to omitting all optional parameters.

    ScanOpts
        { scanMatch = Nothing -- don't match any pattern
        , scanCount = Nothing -- don't set any requirements on number elements returned (works like value COUNT 10)
        }

scan

Arguments

:: RedisCtx m f |
=> Cursor |
-> m (f (Cursor, [ByteString])) | next cursor and values

Incrementally iterate the keys space (http://redis.io/commands/scan). The Redis command `SCAN` is split up into `scan`, `scanOpts`. Since Redis 2.8.0

scanOpts

Arguments

:: RedisCtx m f |
=> Cursor |
-> ScanOpts |
-> m (f (Cursor, [ByteString])) | next cursor and values

Incrementally iterate the keys space (http://redis.io/commands/scan). The Redis command `SCAN` is split up into `scan`, `scanOpts`. Since Redis 2.8.0

data SortOpts

Options for the `sort` command.

Constructors

SortOpts |

Fields

sortBy :: Maybe ByteString
sortLimit :: (Integer, Integer)
sortGet :: [ByteString]
sortOrder :: SortOrder
sortAlpha :: Bool

Instances

Eq SortOpts |
Show SortOpts |

defaultSortOpts :: SortOpts

Redis default `SortOpts`. Equivalent to omitting all optional parameters.

    SortOpts
        { sortBy    = Nothing -- omit the BY option
        , sortLimit = (0,-1)  -- return entire collection
        , sortGet   = []      -- omit the GET option
        , sortOrder = Asc     -- sort in ascending order
        , sortAlpha = False   -- sort numerically, not lexicographically
        }

data SortOrder

Constructors

Asc |
Desc |

Instances

Eq SortOrder |
Show SortOrder |

sort

Arguments

:: RedisCtx m f |
=> ByteString | key
-> SortOpts |
-> m (f [ByteString]) |

Sort the elements in a list, set or sorted set (http://redis.io/commands/sort). The Redis command `SORT` is split up into `sort`, `sortStore`. Since Redis 1.0.0

sortStore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | destination
-> SortOpts |
-> m (f Integer) |

Sort the elements in a list, set or sorted set (http://redis.io/commands/sort). The Redis command `SORT` is split up into `sort`, `sortStore`. Since Redis 1.0.0

ttl

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the time to live for a key (http://redis.io/commands/ttl). Since Redis 1.0.0

data RedisType

Constructors

None |
String |
Hash |
List |
Set |
ZSet |

Instances

Eq RedisType |
Show RedisType |
RedisResult RedisType |

getType

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f RedisType) |

Determine the type stored at key (http://redis.io/commands/type). Since Redis 1.0.0

wait

Arguments

:: RedisCtx m f |
=> Integer | numslaves
-> Integer | timeout
-> m (f Integer) |

Wait for the synchronous replication of all the write commands sent in the context of the current connection (http://redis.io/commands/wait). Since Redis 3.0.0

## Hashes

hdel

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | field
-> m (f Integer) |

Delete one or more hash fields (http://redis.io/commands/hdel). Since Redis 2.0.0

hexists

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> m (f Bool) |

Determine if a hash field exists (http://redis.io/commands/hexists). Since Redis 2.0.0

hget

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> m (f (Maybe ByteString)) |

Get the value of a hash field (http://redis.io/commands/hget). Since Redis 2.0.0

hgetall

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f [(ByteString, ByteString)]) |

Get all the fields and values in a hash (http://redis.io/commands/hgetall). Since Redis 2.0.0

hincrby

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> Integer | increment
-> m (f Integer) |

Increment the integer value of a hash field by the given number (http://redis.io/commands/hincrby). Since Redis 2.0.0

hincrbyfloat

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> Double | increment
-> m (f Double) |

Increment the float value of a hash field by the given amount (http://redis.io/commands/hincrbyfloat). Since Redis 2.6.0

hkeys

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f [ByteString]) |

Get all the fields in a hash (http://redis.io/commands/hkeys). Since Redis 2.0.0

hlen

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the number of fields in a hash (http://redis.io/commands/hlen). Since Redis 2.0.0

hmget

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | field
-> m (f [Maybe ByteString]) |

Get the values of all the given hash fields (http://redis.io/commands/hmget). Since Redis 2.0.0

hmset

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [(ByteString, ByteString)] | fieldValue
-> m (f Status) |

Set multiple hash fields to multiple values (http://redis.io/commands/hmset). Since Redis 2.0.0

hscan

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> m (f (Cursor, [(ByteString, ByteString)])) | next cursor and values

Incrementally iterate hash fields and associated values (http://redis.io/commands/hscan). The Redis command `HSCAN` is split up into `hscan`, `hscanOpts`. Since Redis 2.8.0

hscanOpts

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> ScanOpts |
-> m (f (Cursor, [(ByteString, ByteString)])) | next cursor and values

Incrementally iterate hash fields and associated values (http://redis.io/commands/hscan). The Redis command `HSCAN` is split up into `hscan`, `hscanOpts`. Since Redis 2.8.0

hset

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> ByteString | value
-> m (f Bool) |

Set the string value of a hash field (http://redis.io/commands/hset). Since Redis 2.0.0

hsetnx

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> ByteString | value
-> m (f Bool) |

Set the value of a hash field, only if the field does not exist (http://redis.io/commands/hsetnx). Since Redis 2.0.0

hstrlen

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | field
-> m (f Integer) |

Get the length of the value of a hash field (http://redis.io/commands/hstrlen). Since Redis 3.2.0

hvals

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f [ByteString]) |

Get all the values in a hash (http://redis.io/commands/hvals). Since Redis 2.0.0

## HyperLogLogs

pfadd

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | value
-> m (f Integer) |

Adds all the elements arguments to the HyperLogLog data structure stored at the variable name specified as first argument (http://redis.io/commands/pfadd). Since Redis 2.8.9

pfcount

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f Integer) |

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s) (http://redis.io/commands/pfcount). Since Redis 2.8.9

pfmerge

Arguments

:: RedisCtx m f |
=> ByteString | destkey
-> [ByteString] | sourcekey
-> m (f ByteString) |

Merge N different HyperLogLogs into a single one (http://redis.io/commands/pfmerge). Since Redis 2.8.9

## Lists

blpop

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> Integer | timeout
-> m (f (Maybe (ByteString, ByteString))) |

Remove and get the first element in a list, or block until one is available (http://redis.io/commands/blpop). Since Redis 2.0.0

brpop

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> Integer | timeout
-> m (f (Maybe (ByteString, ByteString))) |

Remove and get the last element in a list, or block until one is available (http://redis.io/commands/brpop). Since Redis 2.0.0

brpoplpush

Arguments

:: RedisCtx m f |
=> ByteString | source
-> ByteString | destination
-> Integer | timeout
-> m (f (Maybe ByteString)) |

Pop a value from a list, push it to another list and return it; or block until one is available (http://redis.io/commands/brpoplpush). Since Redis 2.2.0

lindex

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | index
-> m (f (Maybe ByteString)) |

Get an element from a list by its index (http://redis.io/commands/lindex). Since Redis 1.0.0

linsertBefore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | pivot
-> ByteString | value
-> m (f Integer) |

Insert an element before or after another element in a list (http://redis.io/commands/linsert). The Redis command `LINSERT` is split up into `linsertBefore`, `linsertAfter`. Since Redis 2.2.0

linsertAfter

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | pivot
-> ByteString | value
-> m (f Integer) |

Insert an element before or after another element in a list (http://redis.io/commands/linsert). The Redis command `LINSERT` is split up into `linsertBefore`, `linsertAfter`. Since Redis 2.2.0

llen

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the length of a list (http://redis.io/commands/llen). Since Redis 1.0.0

lpop

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f (Maybe ByteString)) |

Remove and get the first element in a list (http://redis.io/commands/lpop). Since Redis 1.0.0

lpush

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | value
-> m (f Integer) |

Prepend one or multiple values to a list (http://redis.io/commands/lpush). Since Redis 1.0.0

lpushx

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f Integer) |

Prepend a value to a list, only if the list exists (http://redis.io/commands/lpushx). Since Redis 2.2.0

lrange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f [ByteString]) |

Get a range of elements from a list (http://redis.io/commands/lrange). Since Redis 1.0.0

lrem

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | count
-> ByteString | value
-> m (f Integer) |

Remove elements from a list (http://redis.io/commands/lrem). Since Redis 1.0.0

lset

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | index
-> ByteString | value
-> m (f Status) |

Set the value of an element in a list by its index (http://redis.io/commands/lset). Since Redis 1.0.0

ltrim

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f Status) |

Trim a list to the specified range (http://redis.io/commands/ltrim). Since Redis 1.0.0

rpop

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f (Maybe ByteString)) |

Remove and get the last element in a list (http://redis.io/commands/rpop). Since Redis 1.0.0

rpoplpush

Arguments

:: RedisCtx m f |
=> ByteString | source
-> ByteString | destination
-> m (f (Maybe ByteString)) |

Remove the last element in a list, prepend it to another list and return it (http://redis.io/commands/rpoplpush). Since Redis 1.2.0

rpush

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | value
-> m (f Integer) |

Append one or multiple values to a list (http://redis.io/commands/rpush). Since Redis 1.0.0

rpushx

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f Integer) |

Append a value to a list, only if the list exists (http://redis.io/commands/rpushx). Since Redis 2.2.0

## Scripting

eval

Arguments

:: (RedisCtx m f, RedisResult a) |
=> ByteString | script
-> [ByteString] | keys
-> [ByteString] | args
-> m (f a) |

Execute a Lua script server side (http://redis.io/commands/eval). Since Redis 2.6.0

evalsha

Arguments

:: (RedisCtx m f, RedisResult a) |
=> ByteString | script
-> [ByteString] | keys
-> [ByteString] | args
-> m (f a) |

Execute a Lua script server side (http://redis.io/commands/evalsha). Since Redis 2.6.0

data DebugMode

Instances

Eq DebugMode |
Show DebugMode |

scriptDebug :: RedisCtx m f => DebugMode -> m (f Bool)

Set the debug mode for executed scripts (http://redis.io/commands/script-debug). Since Redis 3.2.0

scriptExists

Arguments

:: RedisCtx m f |
=> [ByteString] | script
-> m (f [Bool]) |

Check existence of scripts in the script cache (http://redis.io/commands/script-exists). Since Redis 2.6.0

scriptFlush :: RedisCtx m f => m (f Status)

Remove all the scripts from the script cache (http://redis.io/commands/script-flush). Since Redis 2.6.0

scriptKill :: RedisCtx m f => m (f Status)

Kill the script currently in execution (http://redis.io/commands/script-kill). Since Redis 2.6.0

scriptLoad

Arguments

:: RedisCtx m f |
=> ByteString | script
-> m (f ByteString) |

Load the specified Lua script into the script cache (http://redis.io/commands/script-load). Since Redis 2.6.0

## Server

bgrewriteaof :: RedisCtx m f => m (f Status)

Asynchronously rewrite the append-only file (http://redis.io/commands/bgrewriteaof). Since Redis 1.0.0

bgsave :: RedisCtx m f => m (f Status)

Asynchronously save the dataset to disk (http://redis.io/commands/bgsave). Since Redis 1.0.0

clientGetname :: RedisCtx m f => m (f Status)

Get the current connection name (http://redis.io/commands/client-getname). Since Redis 2.6.9

clientList :: RedisCtx m f => m (f [ByteString])

Get the list of client connections (http://redis.io/commands/client-list). Since Redis 2.4.0

clientPause

Arguments

:: RedisCtx m f |
=> Integer | timeout
-> m (f Status) |

Stop processing commands from clients for some time (http://redis.io/commands/client-pause). Since Redis 2.9.50

data ReplyMode

Instances

Eq ReplyMode |
Show ReplyMode |

clientReply :: RedisCtx m f => ReplyMode -> m (f Bool)

Instruct the server whether to reply to commands (http://redis.io/commands/client-reply). Since Redis 3.2

clientSetname

Arguments

:: RedisCtx m f |
=> ByteString | connectionName
-> m (f ByteString) |

Set the current connection name (http://redis.io/commands/client-setname). Since Redis 2.6.9

commandCount :: RedisCtx m f => m (f Integer)

Get total number of Redis commands (http://redis.io/commands/command-count). Since Redis 2.8.13

commandInfo

Arguments

:: RedisCtx m f |
=> [ByteString] | commandName
-> m (f [ByteString]) |

Get array of specific Redis command details (http://redis.io/commands/command-info). Since Redis 2.8.13

configGet

Arguments

:: RedisCtx m f |
=> ByteString | parameter
-> m (f [(ByteString, ByteString)]) |

Get the value of a configuration parameter (http://redis.io/commands/config-get). Since Redis 2.0.0

configResetstat :: RedisCtx m f => m (f Status)

Reset the stats returned by INFO (http://redis.io/commands/config-resetstat). Since Redis 2.0.0

configRewrite :: RedisCtx m f => m (f Status)

Rewrite the configuration file with the in memory configuration (http://redis.io/commands/config-rewrite). Since Redis 2.8.0

configSet

Arguments

:: RedisCtx m f |
=> ByteString | parameter
-> ByteString | value
-> m (f Status) |

Set a configuration parameter to the given value (http://redis.io/commands/config-set). Since Redis 2.0.0

dbsize :: RedisCtx m f => m (f Integer)

Return the number of keys in the selected database (http://redis.io/commands/dbsize). Since Redis 1.0.0

debugObject

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f ByteString) |

Get debugging information about a key (http://redis.io/commands/debug-object). Since Redis 1.0.0

flushall :: RedisCtx m f => m (f Status)

Remove all keys from all databases (http://redis.io/commands/flushall). Since Redis 1.0.0

flushdb :: RedisCtx m f => m (f Status)

Remove all keys from the current database (http://redis.io/commands/flushdb). Since Redis 1.0.0

info :: RedisCtx m f => m (f ByteString)

Get information and statistics about the server (http://redis.io/commands/info). The Redis command `INFO` is split up into `info`, `infoSection`. Since Redis 1.0.0

infoSection

Arguments

:: RedisCtx m f |
=> ByteString | section
-> m (f ByteString) |

Get information and statistics about the server (http://redis.io/commands/info). The Redis command `INFO` is split up into `info`, `infoSection`. Since Redis 1.0.0

lastsave :: RedisCtx m f => m (f Integer)

Get the UNIX time stamp of the last successful save to disk (http://redis.io/commands/lastsave). Since Redis 1.0.0

save :: RedisCtx m f => m (f Status)

Synchronously save the dataset to disk (http://redis.io/commands/save). Since Redis 1.0.0

slaveof

Arguments

:: RedisCtx m f |
=> ByteString | host
-> ByteString | port
-> m (f Status) |

Make the server a slave of another instance, or promote it as master (http://redis.io/commands/slaveof). Since Redis 1.0.0

data Slowlog

A single entry from the slowlog.

Constructors

Slowlog |

Fields

slowlogId :: Integer

  A unique progressive identifier for every slow log entry.

slowlogTimestamp :: Integer

  The unix timestamp at which the logged command was processed.

slowlogMicros :: Integer

  The amount of time needed for its execution, in microseconds.

slowlogCmd :: [ByteString]

  The command and it's arguments.

Instances

Eq Slowlog |
Show Slowlog |
RedisResult Slowlog |

slowlogGet

Arguments

:: RedisCtx m f |
=> Integer | cnt
-> m (f [Slowlog]) |

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command `SLOWLOG` is split up into `slowlogGet`, `slowlogLen`, `slowlogReset`. Since Redis 2.2.12

slowlogLen :: RedisCtx m f => m (f Integer)

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command `SLOWLOG` is split up into `slowlogGet`, `slowlogLen`, `slowlogReset`. Since Redis 2.2.12

slowlogReset :: RedisCtx m f => m (f Status)

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command `SLOWLOG` is split up into `slowlogGet`, `slowlogLen`, `slowlogReset`. Since Redis 2.2.12

time :: RedisCtx m f => m (f (Integer, Integer))

Return the current server time (http://redis.io/commands/time). Since Redis 2.6.0

## Sets

sadd

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | member
-> m (f Integer) |

Add one or more members to a set (http://redis.io/commands/sadd). Since Redis 1.0.0

scard

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the number of members in a set (http://redis.io/commands/scard). Since Redis 1.0.0

sdiff

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f [ByteString]) |

Subtract multiple sets (http://redis.io/commands/sdiff). Since Redis 1.0.0

sdiffstore

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [ByteString] | key
-> m (f Integer) |

Subtract multiple sets and store the resulting set in a key (http://redis.io/commands/sdiffstore). Since Redis 1.0.0

sinter

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f [ByteString]) |

Intersect multiple sets (http://redis.io/commands/sinter). Since Redis 1.0.0

sinterstore

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [ByteString] | key
-> m (f Integer) |

Intersect multiple sets and store the resulting set in a key (http://redis.io/commands/sinterstore). Since Redis 1.0.0

sismember

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | member
-> m (f Bool) |

Determine if a given value is a member of a set (http://redis.io/commands/sismember). Since Redis 1.0.0

smembers

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f [ByteString]) |

Get all the members in a set (http://redis.io/commands/smembers). Since Redis 1.0.0

smove

Arguments

:: RedisCtx m f |
=> ByteString | source
-> ByteString | destination
-> ByteString | member
-> m (f Bool) |

Move a member from one set to another (http://redis.io/commands/smove). Since Redis 1.0.0

spop

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f (Maybe ByteString)) |

Remove and return one or multiple random members from a set (http://redis.io/commands/spop). Since Redis 1.0.0

srandmember

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f (Maybe ByteString)) |

Get one or multiple random members from a set (http://redis.io/commands/srandmember). The Redis command `SRANDMEMBER` is split up into `srandmember`, `srandmemberN`. Since Redis 1.0.0

srandmemberN

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | count
-> m (f (Maybe ByteString)) |

Get one or multiple random members from a set (http://redis.io/commands/srandmember). The Redis command `SRANDMEMBER` is split up into `srandmember`, `srandmemberN`. Since Redis 1.0.0

srem

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | member
-> m (f Integer) |

Remove one or more members from a set (http://redis.io/commands/srem). Since Redis 1.0.0

sscan

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> m (f (Cursor, [ByteString])) | next cursor and values

Incrementally iterate Set elements (http://redis.io/commands/sscan). The Redis command `SSCAN` is split up into `sscan`, `sscanOpts`. Since Redis 2.8.0

sscanOpts

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> ScanOpts |
-> m (f (Cursor, [ByteString])) | next cursor and values

Incrementally iterate Set elements (http://redis.io/commands/sscan). The Redis command `SSCAN` is split up into `sscan`, `sscanOpts`. Since Redis 2.8.0

sunion

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f [ByteString]) |

Add multiple sets (http://redis.io/commands/sunion). Since Redis 1.0.0

sunionstore

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [ByteString] | key
-> m (f Integer) |

Add multiple sets and store the resulting set in a key (http://redis.io/commands/sunionstore). Since Redis 1.0.0

## Sorted Sets

data ZaddOpts

Constructors

ZaddOpts |

Fields

zaddCondition :: Maybe Condition
zaddChange :: Bool
zaddIncrement :: Bool

Instances

Eq ZaddOpts |
Show ZaddOpts |

defaultZaddOpts :: ZaddOpts

Redis default `ZaddOpts`. Equivalent to omitting all optional parameters.

    ZaddOpts
        { zaddCondition = Nothing -- omit NX and XX options
        , zaddChange    = False   -- don't modify the return value from the number of new elements added, to the total number of elements changed
        , zaddIncrement = False   -- don't add like ZINCRBY
        }

zadd

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [(Double, ByteString)] | scoreMember
-> m (f Integer) |

Add one or more members to a sorted set, or update its score if it already exists (http://redis.io/commands/zadd). The Redis command `ZADD` is split up into `zadd`, `zaddOpts`. Since Redis 1.2.0

zaddOpts

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [(Double, ByteString)] | scoreMember
-> ZaddOpts | options
-> m (f Integer) |

Add one or more members to a sorted set, or update its score if it already exists (http://redis.io/commands/zadd). The Redis command `ZADD` is split up into `zadd`, `zaddOpts`. Since Redis 1.2.0

zcard

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the number of members in a sorted set (http://redis.io/commands/zcard). Since Redis 1.2.0

zcount

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> m (f Integer) |

Count the members in a sorted set with scores within the given values (http://redis.io/commands/zcount). Since Redis 2.0.0

zincrby

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | increment
-> ByteString | member
-> m (f Double) |

Increment the score of a member in a sorted set (http://redis.io/commands/zincrby). Since Redis 1.2.0

data Aggregate

Constructors

Sum |
Min |
Max |

Instances

Eq Aggregate |
Show Aggregate |

zinterstore

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [ByteString] | keys
-> Aggregate |
-> m (f Integer) |

Intersect multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zinterstore). The Redis command `ZINTERSTORE` is split up into `zinterstore`, `zinterstoreWeights`. Since Redis 2.0.0

zinterstoreWeights

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [(ByteString, Double)] | weighted keys
-> Aggregate |
-> m (f Integer) |

Intersect multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zinterstore). The Redis command `ZINTERSTORE` is split up into `zinterstore`, `zinterstoreWeights`. Since Redis 2.0.0

zlexcount

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | min
-> ByteString | max
-> m (f Integer) |

Count the number of members in a sorted set between a given lexicographical range (http://redis.io/commands/zlexcount). Since Redis 2.8.9

zrange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f [ByteString]) |

Return a range of members in a sorted set, by index (http://redis.io/commands/zrange). The Redis command `ZRANGE` is split up into `zrange`, `zrangeWithscores`. Since Redis 1.2.0

zrangeWithscores

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by index (http://redis.io/commands/zrange). The Redis command `ZRANGE` is split up into `zrange`, `zrangeWithscores`. Since Redis 1.2.0

data RangeLex a

Constructors

Incl a |
Excl a |
Minr |
Maxr |

zrangebylex

Arguments

:: RedisCtx m f |
=> ByteString | key
-> RangeLex ByteString | min
-> RangeLex ByteString | max
-> m (f [ByteString]) |

zrangebylexLimit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> RangeLex ByteString | min
-> RangeLex ByteString | max
-> Integer | offset
-> Integer | count
-> m (f [ByteString]) |

Return a range of members in a sorted set, by lexicographical range (http://redis.io/commands/zrangebylex). Since Redis 2.8.9

zrangebyscore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> m (f [ByteString]) |

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command `ZRANGEBYSCORE` is split up into `zrangebyscore`, `zrangebyscoreWithscores`, `zrangebyscoreLimit`, `zrangebyscoreWithscoresLimit`. Since Redis 1.0.5

zrangebyscoreWithscores

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command `ZRANGEBYSCORE` is split up into `zrangebyscore`, `zrangebyscoreWithscores`, `zrangebyscoreLimit`, `zrangebyscoreWithscoresLimit`. Since Redis 1.0.5

zrangebyscoreLimit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> Integer | offset
-> Integer | count
-> m (f [ByteString]) |

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command `ZRANGEBYSCORE` is split up into `zrangebyscore`, `zrangebyscoreWithscores`, `zrangebyscoreLimit`, `zrangebyscoreWithscoresLimit`. Since Redis 1.0.5

zrangebyscoreWithscoresLimit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> Integer | offset
-> Integer | count
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command `ZRANGEBYSCORE` is split up into `zrangebyscore`, `zrangebyscoreWithscores`, `zrangebyscoreLimit`, `zrangebyscoreWithscoresLimit`. Since Redis 1.0.5

zrank

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | member
-> m (f (Maybe Integer)) |

Determine the index of a member in a sorted set (http://redis.io/commands/zrank). Since Redis 2.0.0

zrem

Arguments

:: RedisCtx m f |
=> ByteString | key
-> [ByteString] | member
-> m (f Integer) |

Remove one or more members from a sorted set (http://redis.io/commands/zrem). Since Redis 1.2.0

zremrangebylex

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | min
-> ByteString | max
-> m (f Integer) |

Remove all members in a sorted set between the given lexicographical range (http://redis.io/commands/zremrangebylex). Since Redis 2.8.9

zremrangebyrank

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f Integer) |

Remove all members in a sorted set within the given indexes (http://redis.io/commands/zremrangebyrank). Since Redis 2.0.0

zremrangebyscore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | min
-> Double | max
-> m (f Integer) |

Remove all members in a sorted set within the given scores (http://redis.io/commands/zremrangebyscore). Since Redis 1.2.0

zrevrange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f [ByteString]) |

Return a range of members in a sorted set, by index, with scores ordered from high to low (http://redis.io/commands/zrevrange). The Redis command `ZREVRANGE` is split up into `zrevrange`, `zrevrangeWithscores`. Since Redis 1.2.0

zrevrangeWithscores

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | stop
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by index, with scores ordered from high to low (http://redis.io/commands/zrevrange). The Redis command `ZREVRANGE` is split up into `zrevrange`, `zrevrangeWithscores`. Since Redis 1.2.0

zrevrangebyscore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | max
-> Double | min
-> m (f [ByteString]) |

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command `ZREVRANGEBYSCORE` is split up into `zrevrangebyscore`, `zrevrangebyscoreWithscores`, `zrevrangebyscoreLimit`, `zrevrangebyscoreWithscoresLimit`. Since Redis 2.2.0

zrevrangebyscoreWithscores

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | max
-> Double | min
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command `ZREVRANGEBYSCORE` is split up into `zrevrangebyscore`, `zrevrangebyscoreWithscores`, `zrevrangebyscoreLimit`, `zrevrangebyscoreWithscoresLimit`. Since Redis 2.2.0

zrevrangebyscoreLimit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | max
-> Double | min
-> Integer | offset
-> Integer | count
-> m (f [ByteString]) |

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command `ZREVRANGEBYSCORE` is split up into `zrevrangebyscore`, `zrevrangebyscoreWithscores`, `zrevrangebyscoreLimit`, `zrevrangebyscoreWithscoresLimit`. Since Redis 2.2.0

zrevrangebyscoreWithscoresLimit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | max
-> Double | min
-> Integer | offset
-> Integer | count
-> m (f [(ByteString, Double)]) |

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command `ZREVRANGEBYSCORE` is split up into `zrevrangebyscore`, `zrevrangebyscoreWithscores`, `zrevrangebyscoreLimit`, `zrevrangebyscoreWithscoresLimit`. Since Redis 2.2.0

zrevrank

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | member
-> m (f (Maybe Integer)) |

Determine the index of a member in a sorted set, with scores ordered from high to low (http://redis.io/commands/zrevrank). Since Redis 2.0.0

zscan

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> m (f (Cursor, [(ByteString, Double)])) | next cursor and values

Incrementally iterate sorted sets elements and associated scores (http://redis.io/commands/zscan). The Redis command `ZSCAN` is split up into `zscan`, `zscanOpts`. Since Redis 2.8.0

zscanOpts

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Cursor |
-> ScanOpts |
-> m (f (Cursor, [(ByteString, Double)])) | next cursor and values

Incrementally iterate sorted sets elements and associated scores (http://redis.io/commands/zscan). The Redis command `ZSCAN` is split up into `zscan`, `zscanOpts`. Since Redis 2.8.0

zscore

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | member
-> m (f (Maybe Double)) |

Get the score associated with the given member in a sorted set (http://redis.io/commands/zscore). Since Redis 1.2.0

zunionstore

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [ByteString] | keys
-> Aggregate |
-> m (f Integer) |

Add multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zunionstore). The Redis command `ZUNIONSTORE` is split up into `zunionstore`, `zunionstoreWeights`. Since Redis 2.0.0

zunionstoreWeights

Arguments

:: RedisCtx m f |
=> ByteString | destination
-> [(ByteString, Double)] | weighted keys
-> Aggregate |
-> m (f Integer) |

Add multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zunionstore). The Redis command `ZUNIONSTORE` is split up into `zunionstore`, `zunionstoreWeights`. Since Redis 2.0.0

## Strings

append

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f Integer) |

Append a value to a key (http://redis.io/commands/append). Since Redis 2.0.0

bitcount

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Count set bits in a string (http://redis.io/commands/bitcount). The Redis command `BITCOUNT` is split up into `bitcount`, `bitcountRange`. Since Redis 2.6.0

bitcountRange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | end
-> m (f Integer) |

Count set bits in a string (http://redis.io/commands/bitcount). The Redis command `BITCOUNT` is split up into `bitcount`, `bitcountRange`. Since Redis 2.6.0

bitopAnd

Arguments

:: RedisCtx m f |
=> ByteString | destkey
-> [ByteString] | srckeys
-> m (f Integer) |

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command `BITOP` is split up into `bitopAnd`, `bitopOr`, `bitopXor`, `bitopNot`. Since Redis 2.6.0

bitopOr

Arguments

:: RedisCtx m f |
=> ByteString | destkey
-> [ByteString] | srckeys
-> m (f Integer) |

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command `BITOP` is split up into `bitopAnd`, `bitopOr`, `bitopXor`, `bitopNot`. Since Redis 2.6.0

bitopXor

Arguments

:: RedisCtx m f |
=> ByteString | destkey
-> [ByteString] | srckeys
-> m (f Integer) |

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command `BITOP` is split up into `bitopAnd`, `bitopOr`, `bitopXor`, `bitopNot`. Since Redis 2.6.0

bitopNot

Arguments

:: RedisCtx m f |
=> ByteString | destkey
-> ByteString | srckey
-> m (f Integer) |

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command `BITOP` is split up into `bitopAnd`, `bitopOr`, `bitopXor`, `bitopNot`. Since Redis 2.6.0

bitpos

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | bit
-> Integer | start
-> Integer | end
-> m (f Integer) |

Find first bit set or clear in a string (http://redis.io/commands/bitpos). Since Redis 2.8.7

decr

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Decrement the integer value of a key by one (http://redis.io/commands/decr). Since Redis 1.0.0

decrby

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | decrement
-> m (f Integer) |

Decrement the integer value of a key by the given number (http://redis.io/commands/decrby). Since Redis 1.0.0

get

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f (Maybe ByteString)) |

Get the value of a key (http://redis.io/commands/get). Since Redis 1.0.0

getbit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | offset
-> m (f Integer) |

Returns the bit value at offset in the string value stored at key (http://redis.io/commands/getbit). Since Redis 2.2.0

getrange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | start
-> Integer | end
-> m (f ByteString) |

Get a substring of the string stored at a key (http://redis.io/commands/getrange). Since Redis 2.4.0

getset

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f (Maybe ByteString)) |

Set the string value of a key and return its old value (http://redis.io/commands/getset). Since Redis 1.0.0

incr

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Increment the integer value of a key by one (http://redis.io/commands/incr). Since Redis 1.0.0

incrby

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | increment
-> m (f Integer) |

Increment the integer value of a key by the given amount (http://redis.io/commands/incrby). Since Redis 1.0.0

incrbyfloat

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Double | increment
-> m (f Double) |

Increment the float value of a key by the given amount (http://redis.io/commands/incrbyfloat). Since Redis 2.6.0

mget

Arguments

:: RedisCtx m f |
=> [ByteString] | key
-> m (f [Maybe ByteString]) |

Get the values of all the given keys (http://redis.io/commands/mget). Since Redis 1.0.0

mset

Arguments

:: RedisCtx m f |
=> [(ByteString, ByteString)] | keyValue
-> m (f Status) |

Set multiple keys to multiple values (http://redis.io/commands/mset). Since Redis 1.0.1

msetnx

Arguments

:: RedisCtx m f |
=> [(ByteString, ByteString)] | keyValue
-> m (f Bool) |

Set multiple keys to multiple values, only if none of the keys exist (http://redis.io/commands/msetnx). Since Redis 1.0.1

psetex

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | milliseconds
-> ByteString | value
-> m (f Status) |

Set the value and expiration in milliseconds of a key (http://redis.io/commands/psetex). Since Redis 2.6.0

data Condition

Constructors

Nx |
Xx |

Instances

Eq Condition |
Show Condition |

data SetOpts

Constructors

SetOpts |

Fields

setSeconds :: Maybe Integer
setMilliseconds :: Maybe Integer
setCondition :: Maybe Condition

Instances

Eq SetOpts |
Show SetOpts |

set

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f Status) |

Set the string value of a key (http://redis.io/commands/set). The Redis command `SET` is split up into `set`, `setOpts`. Since Redis 1.0.0

setOpts

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> SetOpts |
-> m (f Status) |

Set the string value of a key (http://redis.io/commands/set). The Redis command `SET` is split up into `set`, `setOpts`. Since Redis 1.0.0

setbit

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | offset
-> ByteString | value
-> m (f Integer) |

Sets or clears the bit at offset in the string value stored at key (http://redis.io/commands/setbit). Since Redis 2.2.0

setex

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | seconds
-> ByteString | value
-> m (f Status) |

Set the value and expiration of a key (http://redis.io/commands/setex). Since Redis 2.0.0

setnx

Arguments

:: RedisCtx m f |
=> ByteString | key
-> ByteString | value
-> m (f Bool) |

Set the value of a key, only if the key does not exist (http://redis.io/commands/setnx). Since Redis 1.0.0

setrange

Arguments

:: RedisCtx m f |
=> ByteString | key
-> Integer | offset
-> ByteString | value
-> m (f Integer) |

Overwrite part of a string at key starting at the specified offset (http://redis.io/commands/setrange). Since Redis 2.2.0

strlen

Arguments

:: RedisCtx m f |
=> ByteString | key
-> m (f Integer) |

Get the length of the value stored in a key (http://redis.io/commands/strlen). Since Redis 2.2.0

# Unimplemented Commands

These commands are not implemented, as of now. Library users can implement these or other commands from experimental Redis versions by using the `sendRequest` function.

- COMMAND (http://redis.io/commands/command)
- COMMAND GETKEYS (http://redis.io/commands/command-getkeys)
- ROLE (http://redis.io/commands/role)
- CLIENT KILL (http://redis.io/commands/client-kill)
- ZREVRANGEBYLEX (http://redis.io/commands/zrevrangebylex)
- ZRANGEBYSCORE (http://redis.io/commands/zrangebyscore)
- ZREVRANGEBYSCORE (http://redis.io/commands/zrevrangebyscore)
- MONITOR (http://redis.io/commands/monitor)
- SYNC (http://redis.io/commands/sync)
- SHUTDOWN (http://redis.io/commands/shutdown)
- DEBUG SEGFAULT (http://redis.io/commands/debug-segfault)

# Transactions

watch

Arguments

:: [ByteString] | key
-> Redis (Either Reply Status) |

Watch the given keys to determine execution of the MULTI/EXEC block (http://redis.io/commands/watch).

unwatch :: Redis (Either Reply Status)

Forget about all watched keys (http://redis.io/commands/unwatch).

multiExec :: RedisTx (Queued a) -> Redis (TxResult a)

Run commands inside a transaction. For documentation on the semantics of Redis transaction see http://redis.io/topics/transactions.

Inside the transaction block, command functions return their result wrapped in a `Queued`. The `Queued` result is a proxy object for the actual command's result, which will only be available after `EXEC`ing the transaction.

Example usage (note how `Queued` 's `Applicative` instance is used to combine the two individual results):

     runRedis conn $ do
         set "hello" "hello"
         set "world" "world"
         helloworld <- multiExec $ do
             hello <- get "hello"
             world <- get "world"
             return $ (,) <$> hello <*> world
         liftIO (print helloworld)

data Queued a

A `Queued` value represents the result of a command inside a transaction. It is a proxy object for the actual result, which will only be available after returning from a `multiExec` transaction.

`Queued` values are composable by utilizing the `Functor`, `Applicative` or `Monad` interfaces.

Instances

Monad Queued |
Functor Queued |
Applicative Queued |
RedisCtx RedisTx Queued |

data TxResult a

Result of a `multiExec` transaction.

Constructors

TxSuccess a | Transaction completed successfully. The wrapped value corresponds to the `Queued` value returned from the `multiExec` argument action.
TxAborted | Transaction aborted due to an earlier `watch` command.
TxError String | At least one of the commands returned an `Error` reply.

Instances

Eq a => Eq (TxResult a) |
Show a => Show (TxResult a) |
Generic (TxResult a) |
NFData a => NFData (TxResult a) |
type Rep (TxResult a) |

data RedisTx a

Command-context inside of MULTI/EXEC transactions. Use `multiExec` to run actions of this type.

In the `RedisTx` context, all commands return a `Queued` value. It is a proxy object for the actual result, which will only be available after finishing the transaction.

Instances

Monad RedisTx |
Functor RedisTx |
Applicative RedisTx |
MonadIO RedisTx |
MonadRedis RedisTx |
RedisCtx RedisTx Queued |

# Pub/Sub

publish

Arguments

:: RedisCtx m f |
=> ByteString | channel
-> ByteString | message
-> m (f Integer) |

Post a message to a channel (http://redis.io/commands/publish).

## Subscribing to channels

There are two Pub/Sub implementations. First, there is a single-threaded implementation `pubSub` which is simpler to use but has the restriction that subscription changes can only be made in response to a message. Secondly, there is a more complicated Pub/Sub controller `pubSubForever` that uses concurrency to support changing subscriptions at any time but requires more setup. You should only use one or the other. In addition, no types or utility functions (that are part of the public API) are shared, so functions or types in one of the following sections cannot be used for the other. In particular, be aware that they use different utility functions to subscribe and unsubscribe to channels.

### Single-thread Pub/Sub

pubSub

Arguments

:: PubSub | Initial subscriptions.
-> (Message -> IO PubSub) | Callback function.
-> Redis () |

Listens to published messages on subscribed channels and channels matching the subscribed patterns. For documentation on the semantics of Redis Pub/Sub see http://redis.io/topics/pubsub.

The given callback function is called for each received message. Subscription changes are triggered by the returned `PubSub`. To keep subscriptions unchanged, the callback can return `mempty`.

Example: Subscribe to the "news" channel indefinitely.

     pubSub (subscribe ["news"]) $ \msg -> do
         putStrLn $ "Message from " ++ show (msgChannel msg)
         return mempty

Example: Receive a single message from the "chat" channel.

     pubSub (subscribe ["chat"]) $ \msg -> do
         putStrLn $ "Message from " ++ show (msgChannel msg)
         return $ unsubscribe ["chat"]

It should be noted that Redis Pub/Sub by its nature is asynchronous so returning `unsubscribe` does not mean that callback won't be able to receive any further messages. And to guarantee that you won't won't process messages after unsubscription and won't unsubscribe from the same channel more than once you need to use `IORef` or something similar

data Message

Constructors

Message |

Fields

msgChannel, msgMessage :: ByteString

PMessage |

Fields

msgPattern, msgChannel, msgMessage :: ByteString

Instances

Show Message |

data PubSub

Encapsulates subscription changes. Use `subscribe`, `unsubscribe`, `psubscribe`, `punsubscribe` or `mempty` to construct a value. Combine values by using the `Monoid` interface, i.e. `mappend` and `mconcat`.

Instances

Eq PubSub |
Monoid PubSub |

subscribe

Arguments

:: [ByteString] | channel
-> PubSub |

Listen for messages published to the given channels (http://redis.io/commands/subscribe).

unsubscribe

Arguments

:: [ByteString] | channel
-> PubSub |

Stop listening for messages posted to the given channels (http://redis.io/commands/unsubscribe).

psubscribe

Arguments

:: [ByteString] | pattern
-> PubSub |

Listen for messages published to channels matching the given patterns (http://redis.io/commands/psubscribe).

punsubscribe

Arguments

:: [ByteString] | pattern
-> PubSub |

Stop listening for messages posted to channels matching the given patterns (http://redis.io/commands/punsubscribe).

### Continuous Pub/Sub message controller

pubSubForever

Arguments

:: Connection | The connection pool
-> PubSubController | The controller which keeps track of all subscriptions and handlers
-> IO () | This action is executed once Redis acknowledges that all the subscriptions in the controller are now subscribed. You can use this after an exception (such as `ConnectionLost`) to signal that all subscriptions are now reactivated.
-> IO () |

Open a connection to the Redis server, register to all channels in the `PubSubController`, and process messages and subscription change requests forever. The only way this will ever exit is if there is an exception from the network code or an unhandled exception in a `MessageCallback` or `PMessageCallback`. For example, if the network connection to Redis dies, `pubSubForever` will throw a `ConnectionLost`. When such an exception is thrown, you can recall `pubSubForever` with the same `PubSubController` which will open a new connection and resubscribe to all the channels which are tracked in the `PubSubController`.

The general pattern is therefore during program startup create a `PubSubController` and fork a thread which calls `pubSubForever` in a loop (using an exponential backoff algorithm such as the retry package to not hammer the Redis server if it does die). For example,

    myhandler :: ByteString -> IO ()
    myhandler msg = putStrLn $ unpack $ decodeUtf8 msg

    onInitialComplete :: IO ()
    onInitialComplete = putStrLn "Redis acknowledged that mychannel is now subscribed"

    main :: IO ()
    main = do
      conn <- connect defaultConnectInfo
      pubSubCtrl <- newPubSubController [("mychannel", myhandler)] []
      forkIO $ forever $
          pubSubForever conn pubSubCtrl onInitialComplete
            `catch` (\(e :: SomeException) -> do
              putStrLn $ "Got error: " ++ show e
              threadDelay $ 50*1000) -- TODO: use exponential backoff

      {- elsewhere in your program, use pubSubCtrl to change subscriptions -}

At most one active `pubSubForever` can be running against a single `PubSubController` at any time. If two active calls to `pubSubForever` share a single `PubSubController` there will be deadlocks. If you do want to process messages using multiple connections to Redis, you can create more than one `PubSubController`. For example, create one PubSubController for each `getNumCapabilities` and then create a Haskell thread bound to each capability each calling `pubSubForever` in a loop. This will create one network connection per controller/capability and allow you to register separate channels and callbacks for each controller, spreading the load across the capabilities.

type RedisChannel = ByteString

A Redis channel name

type RedisPChannel = ByteString

A Redis pattern channel name

type MessageCallback = ByteString -> IO ()

A handler for a message from a subscribed channel. The callback is passed the message content.

Messages are processed synchronously in the receiving thread, so if the callback takes a long time it will block other callbacks and other messages from being received. If you need to move long-running work to a different thread, we suggest you use `TBQueue` with a reasonable bound, so that if messages are arriving faster than you can process them, you do eventually block.

If the callback throws an exception, the exception will be thrown from `pubSubForever` which will cause the entire Redis connection for all subscriptions to be closed. As long as you call `pubSubForever` in a loop you will reconnect to your subscribed channels, but you should probably add an exception handler to each callback to prevent this.

type PMessageCallback = RedisChannel -> ByteString -> IO ()

A handler for a message from a psubscribed channel. The callback is passed the channel the message was sent on plus the message content.

Similar to `MessageCallback`, callbacks are executed synchronously and any exceptions are rethrown from `pubSubForever`.

data PubSubController

A controller that stores a set of channels, pattern channels, and callbacks. It allows you to manage Pub/Sub subscriptions and pattern subscriptions and alter them at any time throughout the life of your program. You should typically create the controller at the start of your program and then store it through the life of your program, using `addChannels` and `removeChannels` to update the current subscriptions.

newPubSubController

Arguments

:: MonadIO m |
=> [(RedisChannel, MessageCallback)] | the initial subscriptions
-> [(RedisPChannel, PMessageCallback)] | the initial pattern subscriptions
-> m PubSubController |

Create a new `PubSubController`. Note that this does not subscribe to any channels, it just creates the controller. The subscriptions will happen once `pubSubForever` is called.

currentChannels :: MonadIO m => PubSubController -> m [RedisChannel]

Get the list of current channels in the `PubSubController`. WARNING! This might not exactly reflect the subscribed channels in the Redis server, because there is a delay between adding or removing a channel in the `PubSubController` and when Redis receives and processes the subscription change request.

currentPChannels :: MonadIO m => PubSubController -> m [RedisPChannel]

Get the list of current pattern channels in the `PubSubController`. WARNING! This might not exactly reflect the subscribed channels in the Redis server, because there is a delay between adding or removing a channel in the `PubSubController` and when Redis receives and processes the subscription change request.

addChannels

Arguments

:: MonadIO m |
=> PubSubController |
-> [(RedisChannel, MessageCallback)] | the channels to subscribe to
-> [(RedisPChannel, PMessageCallback)] | the channels to pattern subscribe to
-> m UnregisterCallbacksAction |

Add channels into the `PubSubController`, and if there is an active `pubSubForever`, send the subscribe and psubscribe commands to Redis. The `addChannels` function is thread-safe. This function does not wait for Redis to acknowledge that the channels have actually been subscribed; use `addChannelsAndWait` for that.

You can subscribe to the same channel or pattern channel multiple times; the `PubSubController` keeps a list of callbacks and executes each callback in response to a message.

The return value is an action `UnregisterCallbacksAction` which will unregister the callbacks, which should typically used with `bracket`.

addChannelsAndWait

Arguments

:: MonadIO m |
=> PubSubController |
-> [(RedisChannel, MessageCallback)] | the channels to subscribe to
-> [(RedisPChannel, PMessageCallback)] | the channels to psubscribe to
-> m UnregisterCallbacksAction |

Call `addChannels` and then wait for Redis to acknowledge that the channels are actually subscribed.

Note that this function waits for all pending subscription change requests, so if you for example call `addChannelsAndWait` from multiple threads simultaneously, they all will wait for all pending subscription changes to be acknowledged by Redis (this is due to the fact that we just track the total number of pending change requests sent to Redis and just wait until that count reaches zero).

This also correctly waits if the network connection dies during the subscription change. Say that the network connection dies right after we send a subscription change to Redis. `pubSubForever` will throw `ConnectionLost` and `addChannelsAndWait` will continue to wait. Once you recall `pubSubForever` with the same `PubSubController`, `pubSubForever` will open a new connection, send subscription commands for all channels in the `PubSubController` (which include the ones we are waiting for), and wait for the responses from Redis. Only once we receive the response from Redis that it has subscribed to all channels in `PubSubController` will `addChannelsAndWait` unblock and return.

removeChannels :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()

Remove channels from the `PubSubController`, and if there is an active `pubSubForever`, send the unsubscribe commands to Redis. Note that as soon as this function returns, no more callbacks will be executed even if more messages arrive during the period when we request to unsubscribe from the channel and Redis actually processes the unsubscribe request. This function is thread-safe.

If you remove all channels, the connection in `pubSubForever` to redis will stay open and waiting for any new channels from a call to `addChannels`. If you really want to close the connection, use `killThread` or `cancel` to kill the thread running `pubSubForever`.

removeChannelsAndWait :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()

Call `removeChannels` and then wait for all pending subscription change requests to be acknowledged by Redis. This uses the same waiting logic as `addChannelsAndWait`. Since `removeChannels` immediately notifies the `PubSubController` to start discarding messages, you likely don't need this function and can just use `removeChannels`.

type UnregisterCallbacksAction = IO ()

An action that when executed will unregister the callbacks. It is returned from `addChannels` or `addChannelsAndWait` and typically you would use it in `bracket` to guarantee that you unsubscribe from channels. For example, if you are using websockets to distribute messages to clients, you could use something such as:

    websocketConn <- Network.WebSockets.acceptRequest pending
    let mycallback msg = Network.WebSockets.sendTextData websocketConn msg
    bracket (addChannelsAndWait ctrl [("hello", mycallback)] []) id $ const $ do
      {- loop here calling Network.WebSockets.receiveData -}

# Low-Level Command API

sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)

`sendRequest` can be used to implement commands from experimental versions of Redis. An example of how to implement a command is given below.

    -- |Redis DEBUG OBJECT command
    debugObject :: ByteString -> Redis (Either Reply ByteString)
    debugObject key = sendRequest ["DEBUG", "OBJECT", key]

data Reply

Low-level representation of replies from the Redis server.

Constructors

SingleLine ByteString |
Error ByteString |
Integer Integer |
Bulk (Maybe ByteString) |
MultiBulk (Maybe [Reply]) |

Instances

Eq Reply |
Show Reply |
Generic Reply |
NFData Reply |
RedisResult Reply |
RedisCtx Redis (Either Reply) |
type Rep Reply |

data Status

Constructors

Ok |
Pong |
Status ByteString |

Instances

Eq Status |
Show Status |
Generic Status |
NFData Status |
RedisResult Status |
type Rep Status |

class RedisResult a where

Methods

decode :: Reply -> Either Reply a

Instances

RedisResult Bool |
RedisResult Double |
RedisResult Integer |
RedisResult ByteString |
RedisResult Reply |
RedisResult RedisType |
RedisResult Status |
RedisResult Cursor |
RedisResult Slowlog |
(RedisResult k, RedisResult v) => RedisResult [(k, v)] |
RedisResult a => RedisResult [a] |
RedisResult a => RedisResult (Maybe a) |
(RedisResult a, RedisResult b) => RedisResult (a, b) |

data ConnectionLostException

Constructors

ConnectionLost |

Instances

Show ConnectionLostException |
Exception ConnectionLostException |

Solution to Exercise

Type of `expire` inside a transaction:

    expire :: ByteString -> Integer -> RedisTx (Queued Bool)

Type of `lindex` outside of a transaction:

    lindex :: ByteString -> Integer -> Redis (Either Reply ByteString)