module Database.Redis.Simple
(
Key (..)
, itemGet
, itemExists
, itemSet
, itemDelete
, setAdd
, setRemove
, setContains
, setFindAll
) where
import Control.Applicative ((<$>))
import Data.Maybe (catMaybes)
import Data.Monoid (Monoid)
import Data.ByteString (ByteString)
import GHC.Exts (IsString)
import Data.Binary (Binary, encode, decode)
import Database.Redis.Redis
newtype Key = Key {unKey :: ByteString}
deriving (Show, Eq, Ord, IsString, Monoid, Binary)
itemGet :: Binary a
=> Redis
-> Key
-> IO (Maybe a)
itemGet redis key = do
reply <- get redis $ unKey key
return $ case reply of RBulk (Just r) -> Just $ decode r
_ -> Nothing
itemExists :: Redis
-> Key
-> IO Bool
itemExists redis (Key key) = do
reply <- exists redis key
return $ case reply of RInt 1 -> True
_ -> False
itemSet :: Binary a
=> Redis
-> Key
-> a
-> IO ()
itemSet redis (Key key) item = do
_ <- set redis key (encode item)
return ()
itemDelete :: Redis
-> Key
-> IO ()
itemDelete redis (Key key) = do
_ <- del redis key
return ()
setAdd :: Binary a
=> Redis
-> Key
-> a
-> IO ()
setAdd redis (Key s) m = do
_ <- sadd redis s $ encode m
return ()
setRemove :: Binary a
=> Redis
-> Key
-> a
-> IO ()
setRemove redis (Key s) m = do
_ <- srem redis s $ encode m
return ()
setContains :: Binary a
=> Redis
-> Key
-> a
-> IO Bool
setContains redis (Key s) m = do
reply <- sismember redis s $ encode m
return $ case reply of
RInt 1 -> True
_ -> False
setFindAll :: Binary a
=> Redis
-> Key
-> IO [a]
setFindAll redis (Key s) = do
reply <- smembers redis s
case reply of
RMulti (Just replies) ->
return $ catMaybes $ flip map replies $ \r -> case r of
RBulk i -> decode <$> i
_ -> Nothing
_ -> return []