Safe Haskell	None
Language	Haskell2010

Database.Redis.Sentinel

Contents

Connection
runRedis with Sentinel support
Re-export Database.Redis

Description

Database.Redis like interface with connection through Redis Sentinel.

More details here: https://redis.io/topics/sentinel.

Example:

conn <- connect SentinelConnectionInfo (("localhost", PortNumber 26379) :| []) "mymaster" defaultConnectInfo

runRedis conn $ do
  set "hello" "world"

When connection is opened, the Sentinels will be queried to get current master. Subsequent runRedis calls will talk to that master.

If runRedis call fails, the next call will choose a new master to talk to.

This implementation is based on Gist by Emanuel Borsboom at https://gist.github.com/borsboom/681d37d273d5c4168723

Synopsis

data SentinelConnectInfo = SentinelConnectInfo {
- connectSentinels :: NonEmpty (HostName, PortID)
- connectMasterName :: ByteString
- connectBaseInfo :: ConnectInfo
}
data SentinelConnection
connect :: SentinelConnectInfo -> IO SentinelConnection
runRedis :: SentinelConnection -> Redis (Either Reply a) -> IO (Either Reply a)
data RedisSentinelException = NoSentinels (NonEmpty (HostName, PortID))
data Reply
- = SingleLine ByteString
- | Error ByteString
- | Integer Integer
- | Bulk (Maybe ByteString)
- | MultiBulk (Maybe [Reply])
data ConnectTimeout = ConnectTimeout ConnectPhase
data ConnectionLostException = ConnectionLost
data PortID
- = PortNumber PortNumber
- | UnixSocket String
data Redis a
data RedisType
- = None
- | String
- | Hash
- | List
- | Set
- | ZSet
data Status
- = Ok
- | Pong
- | Status ByteString
class RedisResult a where
- decode :: Reply -> Either Reply a
data ConnectError
- = ConnectAuthError Reply
- | ConnectSelectError Reply
data ConnectInfo = ConnInfo {
- connectHost :: HostName
- connectPort :: PortID
- connectAuth :: Maybe ByteString
- connectDatabase :: Integer
- connectMaxConnections :: Int
- connectMaxIdleTime :: NominalDiffTime
- connectTimeout :: Maybe NominalDiffTime
- connectTLSParams :: Maybe ClientParams
}
class Monad m => MonadRedis m where
- liftRedis :: Redis a -> m a
class MonadRedis m => RedisCtx m f | m -> f where
- returnDecode :: RedisResult a => Reply -> m (f a)
unRedis :: Redis a -> ReaderT RedisEnv IO a
reRedis :: ReaderT RedisEnv IO a -> Redis a
sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)
defaultConnectInfo :: ConnectInfo
checkedConnect :: ConnectInfo -> IO Connection
disconnect :: Connection -> IO ()
withConnect :: (MonadMask m, MonadIO m) => ConnectInfo -> (Connection -> m c) -> m c
withCheckedConnect :: (MonadMask m, MonadIO m) => ConnectInfo -> (Connection -> m c) -> m c
auth :: ByteString -> Redis (Either Reply Status)
select :: RedisCtx m f => Integer -> m (f Status)
ping :: RedisCtx m f => m (f Status)
data TxResult a
- = TxSuccess a
- | TxAborted
- | TxError String
data Queued a
data RedisTx a
watch :: [ByteString] -> Redis (Either Reply Status)
unwatch :: Redis (Either Reply Status)
multiExec :: RedisTx (Queued a) -> Redis (TxResult a)
data PubSubController
type UnregisterCallbacksAction = IO ()
type PMessageCallback = RedisChannel -> ByteString -> IO ()
type MessageCallback = ByteString -> IO ()
type RedisPChannel = ByteString
type RedisChannel = ByteString
data Message
- = Message {
  - msgChannel, msgMessage :: ByteString
  }
- | PMessage {
  - msgPattern, msgChannel, msgMessage :: ByteString
  }
data PubSub
publish :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
subscribe :: [ByteString] -> PubSub
unsubscribe :: [ByteString] -> PubSub
psubscribe :: [ByteString] -> PubSub
punsubscribe :: [ByteString] -> PubSub
pubSub :: PubSub -> (Message -> IO PubSub) -> Redis ()
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 ()
pubSubForever :: Connection -> PubSubController -> IO () -> IO ()
data XInfoStreamResponse = XInfoStreamResponse {
- xinfoStreamLength :: Integer
- xinfoStreamRadixTreeKeys :: Integer
- xinfoStreamRadixTreeNodes :: Integer
- xinfoStreamNumGroups :: Integer
- xinfoStreamLastEntryId :: ByteString
- xinfoStreamFirstEntry :: StreamsRecord
- xinfoStreamLastEntry :: StreamsRecord
}
data XInfoGroupsResponse = XInfoGroupsResponse {
- xinfoGroupsGroupName :: ByteString
- xinfoGroupsNumConsumers :: Integer
- xinfoGroupsNumPendingMessages :: Integer
- xinfoGroupsLastDeliveredMessageId :: ByteString
}
data XInfoConsumersResponse = XInfoConsumersResponse {
- xinfoConsumerName :: ByteString
- xinfoConsumerNumPendingMessages :: Integer
- xinfoConsumerIdleTime :: Integer
}
data XClaimOpts = XClaimOpts {
- xclaimIdle :: Maybe Integer
- xclaimTime :: Maybe Integer
- xclaimRetryCount :: Maybe Integer
- xclaimForce :: Bool
}
data XPendingDetailRecord = XPendingDetailRecord {
- messageId :: ByteString
- consumer :: ByteString
- millisSinceLastDelivered :: Integer
- numTimesDelivered :: Integer
}
data XPendingSummaryResponse = XPendingSummaryResponse {
- numPendingMessages :: Integer
- smallestPendingMessageId :: ByteString
- largestPendingMessageId :: ByteString
- numPendingMessagesByconsumer :: [(ByteString, Integer)]
}
data XReadResponse = XReadResponse {
- stream :: ByteString
- records :: [StreamsRecord]
}
data XReadOpts = XReadOpts {
- block :: Maybe Integer
- recordCount :: Maybe Integer
}
data StreamsRecord = StreamsRecord {
- recordId :: ByteString
- keyValues :: [(ByteString, ByteString)]
}
data TrimOpts
- = NoArgs
- | Maxlen Integer
- | ApproxMaxlen Integer
data RangeLex a
- = Incl a
- | Excl a
- | Minr
- | Maxr
data ScanOpts = ScanOpts {
- scanMatch :: Maybe ByteString
- scanCount :: Maybe Integer
}
data Cursor
data ReplyMode
data ZaddOpts = ZaddOpts {
- zaddCondition :: Maybe Condition
- zaddChange :: Bool
- zaddIncrement :: Bool
}
data DebugMode
data SetOpts = SetOpts {
- setSeconds :: Maybe Integer
- setMilliseconds :: Maybe Integer
- setCondition :: Maybe Condition
}
data Condition
- = Nx
- | Xx
data MigrateOpts = MigrateOpts {
- migrateCopy :: Bool
- migrateReplace :: Bool
}
data Aggregate
- = Sum
- | Min
- | Max
data SortOrder
- = Asc
- | Desc
data SortOpts = SortOpts {
- sortBy :: Maybe ByteString
- sortLimit :: (Integer, Integer)
- sortGet :: [ByteString]
- sortOrder :: SortOrder
- sortAlpha :: Bool
}
data Slowlog = Slowlog {
- slowlogId :: Integer
- slowlogTimestamp :: Integer
- slowlogMicros :: Integer
- slowlogCmd :: [ByteString]
- slowlogClientIpAndPort :: Maybe ByteString
- slowlogClientName :: Maybe ByteString
}
objectRefcount :: RedisCtx m f => ByteString -> m (f Integer)
objectIdletime :: RedisCtx m f => ByteString -> m (f Integer)
objectEncoding :: RedisCtx m f => ByteString -> m (f ByteString)
linsertBefore :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
linsertAfter :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
getType :: RedisCtx m f => ByteString -> m (f RedisType)
slowlogGet :: RedisCtx m f => Integer -> m (f [Slowlog])
slowlogLen :: RedisCtx m f => m (f Integer)
slowlogReset :: RedisCtx m f => m (f Status)
zrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
zrangeWithscores :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [(ByteString, Double)])
zrevrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
zrevrangeWithscores :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [(ByteString, Double)])
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)])
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)])
defaultSortOpts :: SortOpts
sortStore :: RedisCtx m f => ByteString -> ByteString -> SortOpts -> m (f Integer)
sort :: RedisCtx m f => ByteString -> SortOpts -> m (f [ByteString])
zunionstore :: RedisCtx m f => ByteString -> [ByteString] -> Aggregate -> m (f Integer)
zunionstoreWeights :: RedisCtx m f => ByteString -> [(ByteString, Double)] -> Aggregate -> m (f Integer)
zinterstore :: RedisCtx m f => ByteString -> [ByteString] -> Aggregate -> m (f Integer)
zinterstoreWeights :: RedisCtx m f => ByteString -> [(ByteString, Double)] -> Aggregate -> 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)
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)
migrate :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Integer -> Integer -> m (f Status)
defaultMigrateOpts :: MigrateOpts
migrateMultiple :: RedisCtx m f => ByteString -> ByteString -> Integer -> Integer -> MigrateOpts -> [ByteString] -> m (f Status)
restore :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
restoreReplace :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
set :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
setOpts :: RedisCtx m f => ByteString -> ByteString -> SetOpts -> m (f Status)
scriptDebug :: RedisCtx m f => DebugMode -> m (f Bool)
zadd :: RedisCtx m f => ByteString -> [(Double, ByteString)] -> m (f Integer)
defaultZaddOpts :: ZaddOpts
zaddOpts :: RedisCtx m f => ByteString -> [(Double, ByteString)] -> ZaddOpts -> m (f Integer)
clientReply :: RedisCtx m f => ReplyMode -> m (f Bool)
srandmember :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
srandmemberN :: RedisCtx m f => ByteString -> Integer -> m (f [ByteString])
spop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
spopN :: RedisCtx m f => ByteString -> Integer -> m (f [ByteString])
info :: RedisCtx m f => m (f ByteString)
infoSection :: RedisCtx m f => ByteString -> m (f ByteString)
exists :: RedisCtx m f => ByteString -> m (f Bool)
cursor0 :: Cursor
scan :: RedisCtx m f => Cursor -> m (f (Cursor, [ByteString]))
defaultScanOpts :: ScanOpts
scanOpts :: RedisCtx m f => Cursor -> ScanOpts -> m (f (Cursor, [ByteString]))
sscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [ByteString]))
sscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [ByteString]))
hscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [(ByteString, ByteString)]))
hscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [(ByteString, ByteString)]))
zscan :: RedisCtx m f => ByteString -> Cursor -> m (f (Cursor, [(ByteString, Double)]))
zscanOpts :: RedisCtx m f => ByteString -> Cursor -> ScanOpts -> m (f (Cursor, [(ByteString, Double)]))
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])
xaddOpts :: RedisCtx m f => ByteString -> ByteString -> [(ByteString, ByteString)] -> TrimOpts -> m (f ByteString)
xadd :: RedisCtx m f => ByteString -> ByteString -> [(ByteString, ByteString)] -> m (f ByteString)
defaultXreadOpts :: XReadOpts
xreadOpts :: RedisCtx m f => [(ByteString, ByteString)] -> XReadOpts -> m (f (Maybe [XReadResponse]))
xread :: RedisCtx m f => [(ByteString, ByteString)] -> m (f (Maybe [XReadResponse]))
xreadGroupOpts :: RedisCtx m f => ByteString -> ByteString -> [(ByteString, ByteString)] -> XReadOpts -> m (f (Maybe [XReadResponse]))
xreadGroup :: RedisCtx m f => ByteString -> ByteString -> [(ByteString, ByteString)] -> m (f (Maybe [XReadResponse]))
xgroupCreate :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Status)
xgroupSetId :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Status)
xgroupDelConsumer :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
xgroupDestroy :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
xack :: RedisCtx m f => ByteString -> ByteString -> [ByteString] -> m (f Integer)
xrange :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Maybe Integer -> m (f [StreamsRecord])
xrevRange :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Maybe Integer -> m (f [StreamsRecord])
xlen :: RedisCtx m f => ByteString -> m (f Integer)
xpendingSummary :: RedisCtx m f => ByteString -> ByteString -> Maybe ByteString -> m (f XPendingSummaryResponse)
xpendingDetail :: RedisCtx m f => ByteString -> ByteString -> ByteString -> ByteString -> Integer -> Maybe ByteString -> m (f [XPendingDetailRecord])
defaultXClaimOpts :: XClaimOpts
xclaim :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Integer -> XClaimOpts -> [ByteString] -> m (f [StreamsRecord])
xclaimJustIds :: RedisCtx m f => ByteString -> ByteString -> ByteString -> Integer -> XClaimOpts -> [ByteString] -> m (f [ByteString])
xinfoConsumers :: RedisCtx m f => ByteString -> ByteString -> m (f [XInfoConsumersResponse])
xinfoGroups :: RedisCtx m f => ByteString -> m (f [XInfoGroupsResponse])
xinfoStream :: RedisCtx m f => ByteString -> m (f XInfoStreamResponse)
xdel :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
xtrim :: RedisCtx m f => ByteString -> TrimOpts -> m (f Integer)
inf :: RealFloat a => a
ttl :: RedisCtx m f => ByteString -> m (f Integer)
setnx :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
pttl :: RedisCtx m f => ByteString -> m (f Integer)
commandCount :: RedisCtx m f => m (f Integer)
clientSetname :: RedisCtx m f => ByteString -> m (f ByteString)
zrank :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Integer))
zremrangebyscore :: RedisCtx m f => ByteString -> Double -> Double -> m (f Integer)
hkeys :: RedisCtx m f => ByteString -> m (f [ByteString])
slaveof :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
rpushx :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
debugObject :: RedisCtx m f => ByteString -> m (f ByteString)
bgsave :: RedisCtx m f => m (f Status)
hlen :: RedisCtx m f => ByteString -> m (f Integer)
rpoplpush :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
brpop :: RedisCtx m f => [ByteString] -> Integer -> m (f (Maybe (ByteString, ByteString)))
bgrewriteaof :: RedisCtx m f => m (f Status)
zincrby :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Double)
hgetall :: RedisCtx m f => ByteString -> m (f [(ByteString, ByteString)])
hmset :: RedisCtx m f => ByteString -> [(ByteString, ByteString)] -> m (f Status)
sinter :: RedisCtx m f => [ByteString] -> m (f [ByteString])
pfadd :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
zremrangebyrank :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f Integer)
flushdb :: RedisCtx m f => m (f Status)
sadd :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
lindex :: RedisCtx m f => ByteString -> Integer -> m (f (Maybe ByteString))
lpush :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
hstrlen :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
smove :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
zscore :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Double))
configResetstat :: RedisCtx m f => m (f Status)
pfcount :: RedisCtx m f => [ByteString] -> m (f Integer)
hdel :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
incrbyfloat :: RedisCtx m f => ByteString -> Double -> m (f Double)
setbit :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
flushall :: RedisCtx m f => m (f Status)
incrby :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
time :: RedisCtx m f => m (f (Integer, Integer))
smembers :: RedisCtx m f => ByteString -> m (f [ByteString])
zlexcount :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
sunion :: RedisCtx m f => [ByteString] -> m (f [ByteString])
sinterstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
hvals :: RedisCtx m f => ByteString -> m (f [ByteString])
configSet :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
scriptFlush :: RedisCtx m f => m (f Status)
dbsize :: RedisCtx m f => m (f Integer)
wait :: RedisCtx m f => Integer -> Integer -> m (f Integer)
lpop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
clientPause :: RedisCtx m f => Integer -> m (f Status)
expire :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
mget :: RedisCtx m f => [ByteString] -> m (f [Maybe ByteString])
bitpos :: RedisCtx m f => ByteString -> Integer -> Integer -> Integer -> m (f Integer)
lastsave :: RedisCtx m f => m (f Integer)
pexpire :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
clientList :: RedisCtx m f => m (f [ByteString])
renamenx :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
pfmerge :: RedisCtx m f => ByteString -> [ByteString] -> m (f ByteString)
lrem :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
sdiff :: RedisCtx m f => [ByteString] -> m (f [ByteString])
get :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
getrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f ByteString)
sdiffstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
zcount :: RedisCtx m f => ByteString -> Double -> Double -> m (f Integer)
scriptLoad :: RedisCtx m f => ByteString -> m (f ByteString)
getset :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
dump :: RedisCtx m f => ByteString -> m (f ByteString)
keys :: RedisCtx m f => ByteString -> m (f [ByteString])
configGet :: RedisCtx m f => ByteString -> m (f [(ByteString, ByteString)])
rpush :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
randomkey :: RedisCtx m f => m (f (Maybe ByteString))
hsetnx :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
mset :: RedisCtx m f => [(ByteString, ByteString)] -> m (f Status)
setex :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
psetex :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
scard :: RedisCtx m f => ByteString -> m (f Integer)
scriptExists :: RedisCtx m f => [ByteString] -> m (f [Bool])
sunionstore :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
persist :: RedisCtx m f => ByteString -> m (f Bool)
strlen :: RedisCtx m f => ByteString -> m (f Integer)
lpushx :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
hset :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Bool)
brpoplpush :: RedisCtx m f => ByteString -> ByteString -> Integer -> m (f (Maybe ByteString))
zrevrank :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe Integer))
scriptKill :: RedisCtx m f => m (f Status)
setrange :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Integer)
del :: RedisCtx m f => [ByteString] -> m (f Integer)
hincrbyfloat :: RedisCtx m f => ByteString -> ByteString -> Double -> m (f Double)
hincrby :: RedisCtx m f => ByteString -> ByteString -> Integer -> m (f Integer)
zremrangebylex :: RedisCtx m f => ByteString -> ByteString -> ByteString -> m (f Integer)
rpop :: RedisCtx m f => ByteString -> m (f (Maybe ByteString))
rename :: RedisCtx m f => ByteString -> ByteString -> m (f Status)
zrem :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
hexists :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
clientGetname :: RedisCtx m f => m (f Status)
configRewrite :: RedisCtx m f => m (f Status)
decr :: RedisCtx m f => ByteString -> m (f Integer)
hmget :: RedisCtx m f => ByteString -> [ByteString] -> m (f [Maybe ByteString])
lrange :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f [ByteString])
decrby :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
llen :: RedisCtx m f => ByteString -> m (f Integer)
append :: RedisCtx m f => ByteString -> ByteString -> m (f Integer)
incr :: RedisCtx m f => ByteString -> m (f Integer)
hget :: RedisCtx m f => ByteString -> ByteString -> m (f (Maybe ByteString))
pexpireat :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
ltrim :: RedisCtx m f => ByteString -> Integer -> Integer -> m (f Status)
zcard :: RedisCtx m f => ByteString -> m (f Integer)
lset :: RedisCtx m f => ByteString -> Integer -> ByteString -> m (f Status)
expireat :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
save :: RedisCtx m f => m (f Status)
move :: RedisCtx m f => ByteString -> Integer -> m (f Bool)
getbit :: RedisCtx m f => ByteString -> Integer -> m (f Integer)
msetnx :: RedisCtx m f => [(ByteString, ByteString)] -> m (f Bool)
commandInfo :: RedisCtx m f => [ByteString] -> m (f [ByteString])
quit :: RedisCtx m f => m (f Status)
blpop :: RedisCtx m f => [ByteString] -> Integer -> m (f (Maybe (ByteString, ByteString)))
srem :: RedisCtx m f => ByteString -> [ByteString] -> m (f Integer)
echo :: RedisCtx m f => ByteString -> m (f ByteString)
sismember :: RedisCtx m f => ByteString -> ByteString -> m (f Bool)
parseConnectInfo :: String -> Either String ConnectInfo

Connection

data SentinelConnectInfo Source #

Configuration of Sentinel hosts.

Constructors

SentinelConnectInfo
Fields connectSentinels :: NonEmpty (HostName, PortID) List of sentinels. connectMasterName :: ByteString Name of master to connect to. connectBaseInfo :: ConnectInfo This is used to configure auth and other parameters for Redis connection, but `connectHost` and `connectPort` are ignored.

Instances

Show SentinelConnectInfo Source #
Instance details Defined in Database.Redis.Sentinel Methods showsPrec :: Int -> SentinelConnectInfo -> ShowS # show :: SentinelConnectInfo -> String # showList :: [SentinelConnectInfo] -> ShowS #

data SentinelConnection Source #

connect :: SentinelConnectInfo -> IO SentinelConnection Source #

runRedis with Sentinel support

runRedis :: SentinelConnection -> Redis (Either Reply a) -> IO (Either Reply a) Source #

Interact with a Redis datastore. See runRedis for details.

data RedisSentinelException Source #

Exception thrown by Database.Redis.Sentinel.

Constructors

NoSentinels (NonEmpty (HostName, PortID))

Thrown if no sentinel can be reached.

Instances

Show RedisSentinelException Source #
Instance details Defined in Database.Redis.Sentinel Methods showsPrec :: Int -> RedisSentinelException -> ShowS # show :: RedisSentinelException -> String # showList :: [RedisSentinelException] -> ShowS #
Exception RedisSentinelException Source #
Instance details Defined in Database.Redis.Sentinel Methods toException :: RedisSentinelException -> SomeException # fromException :: SomeException -> Maybe RedisSentinelException # displayException :: RedisSentinelException -> String #

Re-export Database.Redis

data Reply Source #

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 Source #
Instance details Defined in Database.Redis.Protocol Methods (==) :: Reply -> Reply -> Bool # (/=) :: Reply -> Reply -> Bool #
Show Reply Source #
Instance details Defined in Database.Redis.Protocol Methods showsPrec :: Int -> Reply -> ShowS # show :: Reply -> String # showList :: [Reply] -> ShowS #
Generic Reply Source #
Instance details Defined in Database.Redis.Protocol Associated Types type Rep Reply :: Type -> Type # Methods from :: Reply -> Rep Reply x # to :: Rep Reply x -> Reply #
NFData Reply Source #
Instance details Defined in Database.Redis.Protocol Methods rnf :: Reply -> () #
RedisResult Reply Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Reply Source #
RedisCtx Redis (Either Reply) Source #
Instance details Defined in Database.Redis.Core Methods returnDecode :: RedisResult a => Reply -> Redis (Either Reply a) Source #
type Rep Reply Source #
Instance details Defined in Database.Redis.Protocol type Rep Reply = D1 (MetaData "Reply" "Database.Redis.Protocol" "hedis-0.12.15-EN7w4sbQZ8lGcRTd7feWFx" False) ((C1 (MetaCons "SingleLine" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)) :+: C1 (MetaCons "Error" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))) :+: (C1 (MetaCons "Integer" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: (C1 (MetaCons "Bulk" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ByteString))) :+: C1 (MetaCons "MultiBulk" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [Reply]))))))

data ConnectTimeout Source #

Constructors

ConnectTimeout ConnectPhase

Instances

Show ConnectTimeout Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods showsPrec :: Int -> ConnectTimeout -> ShowS # show :: ConnectTimeout -> String # showList :: [ConnectTimeout] -> ShowS #
Exception ConnectTimeout Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods toException :: ConnectTimeout -> SomeException # fromException :: SomeException -> Maybe ConnectTimeout # displayException :: ConnectTimeout -> String #

data ConnectionLostException Source #

Constructors

ConnectionLost

Instances

Show ConnectionLostException Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods showsPrec :: Int -> ConnectionLostException -> ShowS # show :: ConnectionLostException -> String # showList :: [ConnectionLostException] -> ShowS #
Exception ConnectionLostException Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods toException :: ConnectionLostException -> SomeException # fromException :: SomeException -> Maybe ConnectionLostException # displayException :: ConnectionLostException -> String #

data PortID Source #

Constructors

PortNumber PortNumber
UnixSocket String

Instances

Eq PortID Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods (==) :: PortID -> PortID -> Bool # (/=) :: PortID -> PortID -> Bool #
Show PortID Source #
Instance details Defined in Database.Redis.ProtocolPipelining Methods showsPrec :: Int -> PortID -> ShowS # show :: PortID -> String # showList :: [PortID] -> ShowS #

data Redis a Source #

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 Source #
Instance details Defined in Database.Redis.Core.Internal Methods (>>=) :: Redis a -> (a -> Redis b) -> Redis b # (>>) :: Redis a -> Redis b -> Redis b # return :: a -> Redis a # fail :: String -> Redis a #
Functor Redis Source #
Instance details Defined in Database.Redis.Core.Internal Methods fmap :: (a -> b) -> Redis a -> Redis b # (<$) :: a -> Redis b -> Redis a #
MonadFail Redis Source #
Instance details Defined in Database.Redis.Core.Internal Methods fail :: String -> Redis a #
Applicative Redis Source #
Instance details Defined in Database.Redis.Core.Internal Methods pure :: a -> Redis a # (<>) :: Redis (a -> b) -> Redis a -> Redis b # liftA2 :: (a -> b -> c) -> Redis a -> Redis b -> Redis c # (>) :: Redis a -> Redis b -> Redis b # (<*) :: Redis a -> Redis b -> Redis a #
MonadIO Redis Source #
Instance details Defined in Database.Redis.Core.Internal Methods liftIO :: IO a -> Redis a #
MonadRedis Redis Source #
Instance details Defined in Database.Redis.Core Methods liftRedis :: Redis a -> Redis a Source #
RedisCtx Redis (Either Reply) Source #
Instance details Defined in Database.Redis.Core Methods returnDecode :: RedisResult a => Reply -> Redis (Either Reply a) Source #

data RedisType Source #

Constructors

None
String
Hash
List
Set
ZSet

Instances

Eq RedisType Source #
Instance details Defined in Database.Redis.Types Methods (==) :: RedisType -> RedisType -> Bool # (/=) :: RedisType -> RedisType -> Bool #
Show RedisType Source #
Instance details Defined in Database.Redis.Types Methods showsPrec :: Int -> RedisType -> ShowS # show :: RedisType -> String # showList :: [RedisType] -> ShowS #
RedisResult RedisType Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply RedisType Source #

data Status Source #

Constructors

Ok
Pong
Status ByteString

Instances

Eq Status Source #
Instance details Defined in Database.Redis.Types Methods (==) :: Status -> Status -> Bool # (/=) :: Status -> Status -> Bool #
Show Status Source #
Instance details Defined in Database.Redis.Types Methods showsPrec :: Int -> Status -> ShowS # show :: Status -> String # showList :: [Status] -> ShowS #
Generic Status Source #
Instance details Defined in Database.Redis.Types Associated Types type Rep Status :: Type -> Type # Methods from :: Status -> Rep Status x # to :: Rep Status x -> Status #
NFData Status Source #
Instance details Defined in Database.Redis.Types Methods rnf :: Status -> () #
RedisResult Status Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Status Source #
type Rep Status Source #
Instance details Defined in Database.Redis.Types type Rep Status = D1 (MetaData "Status" "Database.Redis.Types" "hedis-0.12.15-EN7w4sbQZ8lGcRTd7feWFx" False) (C1 (MetaCons "Ok" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Pong" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Status" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))

class RedisResult a where Source #

Methods

decode :: Reply -> Either Reply a Source #

Instances

RedisResult Bool Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Bool Source #
RedisResult Double Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Double Source #
RedisResult Integer Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Integer Source #
RedisResult ByteString Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply ByteString Source #
RedisResult Reply Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Reply Source #
RedisResult RedisType Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply RedisType Source #
RedisResult Status Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply Status Source #
RedisResult XInfoStreamResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoStreamResponse Source #
RedisResult XInfoGroupsResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoGroupsResponse Source #
RedisResult XInfoConsumersResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoConsumersResponse Source #
RedisResult XPendingDetailRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XPendingDetailRecord Source #
RedisResult XPendingSummaryResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XPendingSummaryResponse Source #
RedisResult XReadResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XReadResponse Source #
RedisResult StreamsRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply StreamsRecord Source #
RedisResult Cursor Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply Cursor Source #
RedisResult Slowlog Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply Slowlog Source #
(RedisResult k, RedisResult v) => RedisResult [(k, v)] Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply [(k, v)] Source #
RedisResult a => RedisResult [a] Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply [a] Source #
RedisResult a => RedisResult (Maybe a) Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply (Maybe a) Source #
(RedisResult a, RedisResult b) => RedisResult (a, b) Source #
Instance details Defined in Database.Redis.Types Methods decode :: Reply -> Either Reply (a, b) Source #

data ConnectError Source #

Constructors

ConnectAuthError Reply
ConnectSelectError Reply

Instances

Eq ConnectError Source #
Instance details Defined in Database.Redis.Core Methods (==) :: ConnectError -> ConnectError -> Bool # (/=) :: ConnectError -> ConnectError -> Bool #
Show ConnectError Source #
Instance details Defined in Database.Redis.Core Methods showsPrec :: Int -> ConnectError -> ShowS # show :: ConnectError -> String # showList :: [ConnectError] -> ShowS #
Exception ConnectError Source #
Instance details Defined in Database.Redis.Core Methods toException :: ConnectError -> SomeException # fromException :: SomeException -> Maybe ConnectError # displayException :: ConnectError -> String #

data ConnectInfo Source #

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.
connectTimeout :: Maybe NominalDiffTime
Optional timeout until connection to Redis gets established. ConnectTimeoutException gets thrown if no socket get connected in this interval of time.
connectTLSParams :: Maybe ClientParams
Optional TLS parameters. TLS will be enabled if this is provided.

Instances

Show ConnectInfo Source #
Instance details Defined in Database.Redis.Core Methods showsPrec :: Int -> ConnectInfo -> ShowS # show :: ConnectInfo -> String # showList :: [ConnectInfo] -> ShowS #

class Monad m => MonadRedis m where Source #

Methods

liftRedis :: Redis a -> m a Source #

Instances

MonadRedis Redis Source #
Instance details Defined in Database.Redis.Core Methods liftRedis :: Redis a -> Redis a Source #
MonadRedis RedisTx Source #
Instance details Defined in Database.Redis.Transactions Methods liftRedis :: Redis a -> RedisTx a Source #

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

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) Source #

Instances

RedisCtx RedisTx Queued Source #
Instance details Defined in Database.Redis.Transactions Methods returnDecode :: RedisResult a => Reply -> RedisTx (Queued a) Source #
RedisCtx Redis (Either Reply) Source #
Instance details Defined in Database.Redis.Core Methods returnDecode :: RedisResult a => Reply -> Redis (Either Reply a) Source #

unRedis :: Redis a -> ReaderT RedisEnv IO a Source #

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 Source #

Reconstruct Redis constructor.

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

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]

defaultConnectInfo :: ConnectInfo Source #

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
 connectTimeout        = Nothing         -- Don't add timeout logic
 connectTLSParams      = Nothing         -- Do not use TLS

checkedConnect :: ConnectInfo -> IO Connection Source #

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.

disconnect :: Connection -> IO () Source #

Destroy all idle resources in the pool.

withConnect :: (MonadMask m, MonadIO m) => ConnectInfo -> (Connection -> m c) -> m c Source #

Memory bracket around connect and disconnect.

withCheckedConnect :: (MonadMask m, MonadIO m) => ConnectInfo -> (Connection -> m c) -> m c Source #

Memory bracket around checkedConnect and disconnect

auth Source #

Arguments

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

select Source #

Arguments

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

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

data TxResult a Source #

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) Source #
Instance details Defined in Database.Redis.Transactions Methods (==) :: TxResult a -> TxResult a -> Bool # (/=) :: TxResult a -> TxResult a -> Bool #
Show a => Show (TxResult a) Source #
Instance details Defined in Database.Redis.Transactions Methods showsPrec :: Int -> TxResult a -> ShowS # show :: TxResult a -> String # showList :: [TxResult a] -> ShowS #
Generic (TxResult a) Source #
Instance details Defined in Database.Redis.Transactions Associated Types type Rep (TxResult a) :: Type -> Type # Methods from :: TxResult a -> Rep (TxResult a) x # to :: Rep (TxResult a) x -> TxResult a #
NFData a => NFData (TxResult a) Source #
Instance details Defined in Database.Redis.Transactions Methods rnf :: TxResult a -> () #
type Rep (TxResult a) Source #
Instance details Defined in Database.Redis.Transactions type Rep (TxResult a) = D1 (MetaData "TxResult" "Database.Redis.Transactions" "hedis-0.12.15-EN7w4sbQZ8lGcRTd7feWFx" False) (C1 (MetaCons "TxSuccess" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: (C1 (MetaCons "TxAborted" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "TxError" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

data Queued a Source #

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 Source #
Instance details Defined in Database.Redis.Transactions Methods (>>=) :: Queued a -> (a -> Queued b) -> Queued b # (>>) :: Queued a -> Queued b -> Queued b # return :: a -> Queued a # fail :: String -> Queued a #
Functor Queued Source #
Instance details Defined in Database.Redis.Transactions Methods fmap :: (a -> b) -> Queued a -> Queued b # (<$) :: a -> Queued b -> Queued a #
Applicative Queued Source #
Instance details Defined in Database.Redis.Transactions Methods pure :: a -> Queued a # (<>) :: Queued (a -> b) -> Queued a -> Queued b # liftA2 :: (a -> b -> c) -> Queued a -> Queued b -> Queued c # (>) :: Queued a -> Queued b -> Queued b # (<*) :: Queued a -> Queued b -> Queued a #
RedisCtx RedisTx Queued Source #
Instance details Defined in Database.Redis.Transactions Methods returnDecode :: RedisResult a => Reply -> RedisTx (Queued a) Source #

data RedisTx a Source #

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 Source #
Instance details Defined in Database.Redis.Transactions Methods (>>=) :: RedisTx a -> (a -> RedisTx b) -> RedisTx b # (>>) :: RedisTx a -> RedisTx b -> RedisTx b # return :: a -> RedisTx a # fail :: String -> RedisTx a #
Functor RedisTx Source #
Instance details Defined in Database.Redis.Transactions Methods fmap :: (a -> b) -> RedisTx a -> RedisTx b # (<$) :: a -> RedisTx b -> RedisTx a #
Applicative RedisTx Source #
Instance details Defined in Database.Redis.Transactions Methods pure :: a -> RedisTx a # (<>) :: RedisTx (a -> b) -> RedisTx a -> RedisTx b # liftA2 :: (a -> b -> c) -> RedisTx a -> RedisTx b -> RedisTx c # (>) :: RedisTx a -> RedisTx b -> RedisTx b # (<*) :: RedisTx a -> RedisTx b -> RedisTx a #
MonadIO RedisTx Source #
Instance details Defined in Database.Redis.Transactions Methods liftIO :: IO a -> RedisTx a #
MonadRedis RedisTx Source #
Instance details Defined in Database.Redis.Transactions Methods liftRedis :: Redis a -> RedisTx a Source #
RedisCtx RedisTx Queued Source #
Instance details Defined in Database.Redis.Transactions Methods returnDecode :: RedisResult a => Reply -> RedisTx (Queued a) Source #

watch Source #

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) Source #

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

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

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 EXECing 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 PubSubController Source #

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.

type UnregisterCallbacksAction = IO () Source #

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 -}

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

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.

type MessageCallback = ByteString -> IO () Source #

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 RedisPChannel = ByteString Source #

A Redis pattern channel name

type RedisChannel = ByteString Source #

A Redis channel name

data Message Source #

Constructors

Message
Fields msgChannel, msgMessage :: ByteString
PMessage
Fields msgPattern, msgChannel, msgMessage :: ByteString

Instances

Show Message Source #
Instance details Defined in Database.Redis.PubSub Methods showsPrec :: Int -> Message -> ShowS # show :: Message -> String # showList :: [Message] -> ShowS #

data PubSub Source #

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 Source #
Instance details Defined in Database.Redis.PubSub Methods (==) :: PubSub -> PubSub -> Bool # (/=) :: PubSub -> PubSub -> Bool #
Semigroup PubSub Source #
Instance details Defined in Database.Redis.PubSub Methods (<>) :: PubSub -> PubSub -> PubSub # sconcat :: NonEmpty PubSub -> PubSub # stimes :: Integral b => b -> PubSub -> PubSub #
Monoid PubSub Source #
Instance details Defined in Database.Redis.PubSub Methods mempty :: PubSub # mappend :: PubSub -> PubSub -> PubSub # mconcat :: [PubSub] -> PubSub #

publish Source #

Arguments

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

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

subscribe Source #

Arguments

:: [ByteString]	channel
-> PubSub

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

unsubscribe Source #

Arguments

:: [ByteString]	channel
-> PubSub

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

psubscribe Source #

Arguments

:: [ByteString]	pattern
-> PubSub

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

punsubscribe Source #

Arguments

:: [ByteString]	pattern
-> PubSub

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

pubSub Source #

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

newPubSubController Source #

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] Source #

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] Source #

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 Source #

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 Source #

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 () Source #

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 () Source #

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.

pubSubForever Source #

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.

data XInfoStreamResponse Source #

Constructors

XInfoStreamResponse
Fields xinfoStreamLength :: Integer xinfoStreamRadixTreeKeys :: Integer xinfoStreamRadixTreeNodes :: Integer xinfoStreamNumGroups :: Integer xinfoStreamLastEntryId :: ByteString xinfoStreamFirstEntry :: StreamsRecord xinfoStreamLastEntry :: StreamsRecord

Instances

Eq XInfoStreamResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XInfoStreamResponse -> XInfoStreamResponse -> Bool # (/=) :: XInfoStreamResponse -> XInfoStreamResponse -> Bool #
Show XInfoStreamResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XInfoStreamResponse -> ShowS # show :: XInfoStreamResponse -> String # showList :: [XInfoStreamResponse] -> ShowS #
RedisResult XInfoStreamResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoStreamResponse Source #

data XInfoGroupsResponse Source #

Constructors

XInfoGroupsResponse
Fields xinfoGroupsGroupName :: ByteString xinfoGroupsNumConsumers :: Integer xinfoGroupsNumPendingMessages :: Integer xinfoGroupsLastDeliveredMessageId :: ByteString

Instances

Eq XInfoGroupsResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XInfoGroupsResponse -> XInfoGroupsResponse -> Bool # (/=) :: XInfoGroupsResponse -> XInfoGroupsResponse -> Bool #
Show XInfoGroupsResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XInfoGroupsResponse -> ShowS # show :: XInfoGroupsResponse -> String # showList :: [XInfoGroupsResponse] -> ShowS #
RedisResult XInfoGroupsResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoGroupsResponse Source #

data XInfoConsumersResponse Source #

Constructors

XInfoConsumersResponse
Fields xinfoConsumerName :: ByteString xinfoConsumerNumPendingMessages :: Integer xinfoConsumerIdleTime :: Integer

Instances

Eq XInfoConsumersResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XInfoConsumersResponse -> XInfoConsumersResponse -> Bool # (/=) :: XInfoConsumersResponse -> XInfoConsumersResponse -> Bool #
Show XInfoConsumersResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XInfoConsumersResponse -> ShowS # show :: XInfoConsumersResponse -> String # showList :: [XInfoConsumersResponse] -> ShowS #
RedisResult XInfoConsumersResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XInfoConsumersResponse Source #

data XClaimOpts Source #

Constructors

XClaimOpts
Fields xclaimIdle :: Maybe Integer xclaimTime :: Maybe Integer xclaimRetryCount :: Maybe Integer xclaimForce :: Bool

Instances

Eq XClaimOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XClaimOpts -> XClaimOpts -> Bool # (/=) :: XClaimOpts -> XClaimOpts -> Bool #
Show XClaimOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XClaimOpts -> ShowS # show :: XClaimOpts -> String # showList :: [XClaimOpts] -> ShowS #

data XPendingDetailRecord Source #

Constructors

XPendingDetailRecord
Fields messageId :: ByteString consumer :: ByteString millisSinceLastDelivered :: Integer numTimesDelivered :: Integer

Instances

Eq XPendingDetailRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XPendingDetailRecord -> XPendingDetailRecord -> Bool # (/=) :: XPendingDetailRecord -> XPendingDetailRecord -> Bool #
Show XPendingDetailRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XPendingDetailRecord -> ShowS # show :: XPendingDetailRecord -> String # showList :: [XPendingDetailRecord] -> ShowS #
RedisResult XPendingDetailRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XPendingDetailRecord Source #

data XPendingSummaryResponse Source #

Constructors

XPendingSummaryResponse
Fields numPendingMessages :: Integer smallestPendingMessageId :: ByteString largestPendingMessageId :: ByteString numPendingMessagesByconsumer :: [(ByteString, Integer)]

Instances

Eq XPendingSummaryResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XPendingSummaryResponse -> XPendingSummaryResponse -> Bool # (/=) :: XPendingSummaryResponse -> XPendingSummaryResponse -> Bool #
Show XPendingSummaryResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XPendingSummaryResponse -> ShowS # show :: XPendingSummaryResponse -> String # showList :: [XPendingSummaryResponse] -> ShowS #
RedisResult XPendingSummaryResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XPendingSummaryResponse Source #

data XReadResponse Source #

Constructors

XReadResponse
Fields stream :: ByteString records :: [StreamsRecord]

Instances

Eq XReadResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XReadResponse -> XReadResponse -> Bool # (/=) :: XReadResponse -> XReadResponse -> Bool #
Show XReadResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XReadResponse -> ShowS # show :: XReadResponse -> String # showList :: [XReadResponse] -> ShowS #
RedisResult XReadResponse Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply XReadResponse Source #

data XReadOpts Source #

Constructors

XReadOpts
Fields block :: Maybe Integer recordCount :: Maybe Integer

Instances

Eq XReadOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: XReadOpts -> XReadOpts -> Bool # (/=) :: XReadOpts -> XReadOpts -> Bool #
Show XReadOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> XReadOpts -> ShowS # show :: XReadOpts -> String # showList :: [XReadOpts] -> ShowS #

data StreamsRecord Source #

Constructors

StreamsRecord
Fields recordId :: ByteString keyValues :: [(ByteString, ByteString)]

Instances

Eq StreamsRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: StreamsRecord -> StreamsRecord -> Bool # (/=) :: StreamsRecord -> StreamsRecord -> Bool #
Show StreamsRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> StreamsRecord -> ShowS # show :: StreamsRecord -> String # showList :: [StreamsRecord] -> ShowS #
RedisResult StreamsRecord Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply StreamsRecord Source #

data TrimOpts Source #

Constructors

NoArgs
Maxlen Integer
ApproxMaxlen Integer

data RangeLex a Source #

Constructors

Incl a
Excl a
Minr
Maxr

data ScanOpts Source #

Constructors

ScanOpts
Fields scanMatch :: Maybe ByteString scanCount :: Maybe Integer

Instances

Eq ScanOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: ScanOpts -> ScanOpts -> Bool # (/=) :: ScanOpts -> ScanOpts -> Bool #
Show ScanOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> ScanOpts -> ShowS # show :: ScanOpts -> String # showList :: [ScanOpts] -> ShowS #

data Cursor Source #

Instances

Eq Cursor Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: Cursor -> Cursor -> Bool # (/=) :: Cursor -> Cursor -> Bool #
Show Cursor Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> Cursor -> ShowS # show :: Cursor -> String # showList :: [Cursor] -> ShowS #
RedisResult Cursor Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply Cursor Source #

data ReplyMode Source #

Instances

Eq ReplyMode Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: ReplyMode -> ReplyMode -> Bool # (/=) :: ReplyMode -> ReplyMode -> Bool #
Show ReplyMode Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> ReplyMode -> ShowS # show :: ReplyMode -> String # showList :: [ReplyMode] -> ShowS #

data ZaddOpts Source #

Constructors

ZaddOpts
Fields zaddCondition :: Maybe Condition zaddChange :: Bool zaddIncrement :: Bool

Instances

Eq ZaddOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: ZaddOpts -> ZaddOpts -> Bool # (/=) :: ZaddOpts -> ZaddOpts -> Bool #
Show ZaddOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> ZaddOpts -> ShowS # show :: ZaddOpts -> String # showList :: [ZaddOpts] -> ShowS #

data DebugMode Source #

Instances

Eq DebugMode Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: DebugMode -> DebugMode -> Bool # (/=) :: DebugMode -> DebugMode -> Bool #
Show DebugMode Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> DebugMode -> ShowS # show :: DebugMode -> String # showList :: [DebugMode] -> ShowS #

data SetOpts Source #

Constructors

SetOpts
Fields setSeconds :: Maybe Integer setMilliseconds :: Maybe Integer setCondition :: Maybe Condition

Instances

Eq SetOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: SetOpts -> SetOpts -> Bool # (/=) :: SetOpts -> SetOpts -> Bool #
Show SetOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> SetOpts -> ShowS # show :: SetOpts -> String # showList :: [SetOpts] -> ShowS #

data Condition Source #

Constructors

Nx
Xx

Instances

Eq Condition Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: Condition -> Condition -> Bool # (/=) :: Condition -> Condition -> Bool #
Show Condition Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> Condition -> ShowS # show :: Condition -> String # showList :: [Condition] -> ShowS #

data MigrateOpts Source #

Options for the migrate command.

Constructors

MigrateOpts
Fields migrateCopy :: Bool migrateReplace :: Bool

Instances

Eq MigrateOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: MigrateOpts -> MigrateOpts -> Bool # (/=) :: MigrateOpts -> MigrateOpts -> Bool #
Show MigrateOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> MigrateOpts -> ShowS # show :: MigrateOpts -> String # showList :: [MigrateOpts] -> ShowS #

data Aggregate Source #

Constructors

Sum
Min
Max

Instances

Eq Aggregate Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: Aggregate -> Aggregate -> Bool # (/=) :: Aggregate -> Aggregate -> Bool #
Show Aggregate Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> Aggregate -> ShowS # show :: Aggregate -> String # showList :: [Aggregate] -> ShowS #

data SortOrder Source #

Constructors

Asc
Desc

Instances

Eq SortOrder Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: SortOrder -> SortOrder -> Bool # (/=) :: SortOrder -> SortOrder -> Bool #
Show SortOrder Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> SortOrder -> ShowS # show :: SortOrder -> String # showList :: [SortOrder] -> ShowS #

data SortOpts Source #

Options for the sort command.

Constructors

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

Instances

Eq SortOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: SortOpts -> SortOpts -> Bool # (/=) :: SortOpts -> SortOpts -> Bool #
Show SortOpts Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> SortOpts -> ShowS # show :: SortOpts -> String # showList :: [SortOpts] -> ShowS #

data Slowlog Source #

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.
slowlogClientIpAndPort :: Maybe ByteString
slowlogClientName :: Maybe ByteString

Instances

Eq Slowlog Source #
Instance details Defined in Database.Redis.ManualCommands Methods (==) :: Slowlog -> Slowlog -> Bool # (/=) :: Slowlog -> Slowlog -> Bool #
Show Slowlog Source #
Instance details Defined in Database.Redis.ManualCommands Methods showsPrec :: Int -> Slowlog -> ShowS # show :: Slowlog -> String # showList :: [Slowlog] -> ShowS #
RedisResult Slowlog Source #
Instance details Defined in Database.Redis.ManualCommands Methods decode :: Reply -> Either Reply Slowlog Source #

objectRefcount Source #

Arguments

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

objectIdletime Source #

Arguments

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

objectEncoding Source #

Arguments

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

linsertBefore Source #

Arguments

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

linsertAfter Source #

Arguments

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

getType Source #

Arguments

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

slowlogGet Source #

Arguments

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

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

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

zrange Source #

Arguments

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

zrangeWithscores Source #

Arguments

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

zrevrange Source #

Arguments

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

zrevrangeWithscores Source #

Arguments

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

zrangebyscore Source #

Arguments

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

zrangebyscoreWithscores Source #

Arguments

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

zrangebyscoreLimit Source #

Arguments

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

zrangebyscoreWithscoresLimit Source #

Arguments

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

zrevrangebyscore Source #

Arguments

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

zrevrangebyscoreWithscores Source #

Arguments

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

zrevrangebyscoreLimit Source #

Arguments

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

zrevrangebyscoreWithscoresLimit Source #

Arguments

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

defaultSortOpts :: SortOpts Source #

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
    }

sortStore Source #

Arguments

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

sort Source #

Arguments

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

zunionstore Source #

Arguments

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

zunionstoreWeights Source #

Arguments

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

zinterstore Source #

Arguments

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

zinterstoreWeights Source #

Arguments

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

eval Source #

Arguments

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

evalsha Source #

Arguments

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

bitcount Source #

Arguments

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

bitcountRange Source #

Arguments

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

bitopAnd Source #

Arguments

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

bitopOr Source #

Arguments

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

bitopXor Source #

Arguments

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

bitopNot Source #

Arguments

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

migrate Source #

Arguments

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

defaultMigrateOpts :: MigrateOpts Source #

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
    }

migrateMultiple Source #

Arguments

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

restore Source #

Arguments

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

restoreReplace Source #

Arguments

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

set Source #

Arguments

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

setOpts Source #

Arguments

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

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

zadd Source #

Arguments

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

defaultZaddOpts :: ZaddOpts Source #

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
    }

zaddOpts Source #

Arguments

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

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

srandmember Source #

Arguments

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

srandmemberN Source #

Arguments

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

spop Source #

Arguments

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

spopN Source #

Arguments

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

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

infoSection Source #

Arguments

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

exists Source #

Arguments

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

cursor0 :: Cursor Source #

scan Source #

Arguments

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

defaultScanOpts :: ScanOpts Source #

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)
    }

scanOpts Source #

Arguments

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

sscan Source #

Arguments

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

sscanOpts Source #

Arguments

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

hscan Source #

Arguments

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

hscanOpts Source #

Arguments

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

zscan Source #

Arguments

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

zscanOpts Source #

Arguments

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

zrangebylex Source #

Arguments

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

zrangebylexLimit Source #

Arguments

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

xaddOpts Source #

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	id
-> [(ByteString, ByteString)]	(field, value)
-> TrimOpts
-> m (f ByteString)

xadd Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	id
-> [(ByteString, ByteString)]	(field, value)
-> m (f ByteString)

defaultXreadOpts :: XReadOpts Source #

Redis default XReadOpts. Equivalent to omitting all optional parameters.

XReadOpts
    { block = Nothing -- Don't block waiting for more records
    , recordCount    = Nothing   -- no record count
    }

xreadOpts Source #

Arguments

:: RedisCtx m f
=> [(ByteString, ByteString)]	(stream, id) pairs
-> XReadOpts	Options
-> m (f (Maybe [XReadResponse]))

xread Source #

Arguments

:: RedisCtx m f
=> [(ByteString, ByteString)]	(stream, id) pairs
-> m (f (Maybe [XReadResponse]))

xreadGroupOpts Source #

Arguments

:: RedisCtx m f
=> ByteString	group name
-> ByteString	consumer name
-> [(ByteString, ByteString)]	(stream, id) pairs
-> XReadOpts	Options
-> m (f (Maybe [XReadResponse]))

xreadGroup Source #

Arguments

:: RedisCtx m f
=> ByteString	group name
-> ByteString	consumer name
-> [(ByteString, ByteString)]	(stream, id) pairs
-> m (f (Maybe [XReadResponse]))

xgroupCreate Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group name
-> ByteString	start ID
-> m (f Status)

xgroupSetId Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> ByteString	id
-> m (f Status)

xgroupDelConsumer Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> ByteString	consumer
-> m (f Integer)

xgroupDestroy Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> m (f Bool)

xack Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group name
-> [ByteString]	message IDs
-> m (f Integer)

xrange Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	start
-> ByteString	end
-> Maybe Integer	COUNT
-> m (f [StreamsRecord])

xrevRange Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	end
-> ByteString	start
-> Maybe Integer	COUNT
-> m (f [StreamsRecord])

xlen Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> m (f Integer)

xpendingSummary Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> Maybe ByteString	consumer
-> m (f XPendingSummaryResponse)

xpendingDetail Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> ByteString	startId
-> ByteString	endId
-> Integer	count
-> Maybe ByteString	consumer
-> m (f [XPendingDetailRecord])

defaultXClaimOpts :: XClaimOpts Source #

xclaim Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> ByteString	consumer
-> Integer	min idle time
-> XClaimOpts	optional arguments
-> [ByteString]	message IDs
-> m (f [StreamsRecord])

xclaimJustIds Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> ByteString	consumer
-> Integer	min idle time
-> XClaimOpts	optional arguments
-> [ByteString]	message IDs
-> m (f [ByteString])

xinfoConsumers Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> ByteString	group
-> m (f [XInfoConsumersResponse])

xinfoGroups Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> m (f [XInfoGroupsResponse])

xinfoStream Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> m (f XInfoStreamResponse)

xdel Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> [ByteString]	message IDs
-> m (f Integer)

xtrim Source #

Arguments

:: RedisCtx m f
=> ByteString	stream
-> TrimOpts
-> m (f Integer)

inf :: RealFloat a => a Source #

ttl Source #

Arguments

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

setnx Source #

Arguments

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

pttl Source #

Arguments

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

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

clientSetname Source #

Arguments

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

zrank Source #

Arguments

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

zremrangebyscore Source #

Arguments

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

hkeys Source #

Arguments

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

slaveof Source #

Arguments

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

rpushx Source #

Arguments

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

debugObject Source #

Arguments

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

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

hlen Source #

Arguments

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

rpoplpush Source #

Arguments

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

brpop Source #

Arguments

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

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

zincrby Source #

Arguments

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

hgetall Source #

Arguments

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

hmset Source #

Arguments

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

sinter Source #

Arguments

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

pfadd Source #

Arguments

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

zremrangebyrank Source #

Arguments

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

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

sadd Source #

Arguments

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

lindex Source #

Arguments

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

lpush Source #

Arguments

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

hstrlen Source #

Arguments

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

smove Source #

Arguments

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

zscore Source #

Arguments

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

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

pfcount Source #

Arguments

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

hdel Source #

Arguments

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

incrbyfloat Source #

Arguments

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

setbit Source #

Arguments

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

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

incrby Source #

Arguments

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

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

smembers Source #

Arguments

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

zlexcount Source #

Arguments

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

sunion Source #

Arguments

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

sinterstore Source #

Arguments

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

hvals Source #

Arguments

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

configSet Source #

Arguments

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

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

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

wait Source #

Arguments

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

lpop Source #

Arguments

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

clientPause Source #

Arguments

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

expire Source #

Arguments

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

mget Source #

Arguments

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

bitpos Source #

Arguments

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

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

pexpire Source #

Arguments

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

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

renamenx Source #

Arguments

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

pfmerge Source #

Arguments

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

lrem Source #

Arguments

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

sdiff Source #

Arguments

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

get Source #

Arguments

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

getrange Source #

Arguments

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

sdiffstore Source #

Arguments

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

zcount Source #

Arguments

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

scriptLoad Source #

Arguments

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

getset Source #

Arguments

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

dump Source #

Arguments

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

keys Source #

Arguments

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

configGet Source #

Arguments

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

rpush Source #

Arguments

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

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

hsetnx Source #

Arguments

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

mset Source #

Arguments

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

setex Source #

Arguments

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

psetex Source #

Arguments

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

scard Source #

Arguments

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

scriptExists Source #

Arguments

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

sunionstore Source #

Arguments

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

persist Source #

Arguments

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

strlen Source #

Arguments

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

lpushx Source #

Arguments

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

hset Source #

Arguments

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

brpoplpush Source #

Arguments

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

zrevrank Source #

Arguments

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

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

setrange Source #

Arguments

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

del Source #

Arguments

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

hincrbyfloat Source #

Arguments

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

hincrby Source #

Arguments

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

zremrangebylex Source #

Arguments

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

rpop Source #

Arguments

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

rename Source #

Arguments

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

zrem Source #

Arguments

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

hexists Source #

Arguments

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

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

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

decr Source #

Arguments

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

hmget Source #

Arguments

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

lrange Source #

Arguments

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

decrby Source #

Arguments

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

llen Source #

Arguments

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

append Source #

Arguments

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

incr Source #

Arguments

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

hget Source #

Arguments

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

pexpireat Source #

Arguments

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

ltrim Source #

Arguments

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

zcard Source #

Arguments

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

lset Source #

Arguments

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

expireat Source #

Arguments

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

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

move Source #

Arguments

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

getbit Source #

Arguments

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

msetnx Source #

Arguments

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

commandInfo Source #

Arguments

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

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

blpop Source #

Arguments

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

srem Source #

Arguments

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

echo Source #

Arguments

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

sismember Source #

Arguments

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

parseConnectInfo :: String -> Either String ConnectInfo Source #

Parse a ConnectInfo from a URL

Username is ignored, path is used to specify the database:

>>> parseConnectInfo "redis://username:password@host:42/2"
Right (ConnInfo {connectHost = "host", connectPort = PortNumber 42, connectAuth = Just "password", connectDatabase = 2, connectMaxConnections = 50, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing})

>>> parseConnectInfo "redis://username:password@host:42/db"
Left "Invalid port: db"

The scheme is validated, to prevent mixing up configurations:

>>> parseConnectInfo "postgres://"
Left "Wrong scheme"

Beyond that, all values are optional. Omitted values are taken from defaultConnectInfo:

>>> parseConnectInfo "redis://"
Right (ConnInfo {connectHost = "localhost", connectPort = PortNumber 6379, connectAuth = Nothing, connectDatabase = 0, connectMaxConnections = 50, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing})