Redis.Hash

A simple Redis library providing high level access to Redis features we use here at NoRedInk

As with our Ruby Redis access, we enforce working within a "namespace".

Creating a redis handler

handler :: Text -> Settings -> Acquire Handler

Produce a namespaced handler for Redis access.

data Handler

The redis handler allows applications to run scoped IO

data Settings

Settings required to initiate a redis connection.

Constructors

Settings

Fields

• connectionInfo :: ConnectInfo

  Full redis connection string.

  Default env var name is REDIS_CONNECTION_STRING default is "redis://localhost:6379"

• clusterMode :: ClusterMode

  Set to 1 for cluster, everything else is not.

  Default env var name is REDIS_CLUSTER Default is 0

• defaultExpiry :: DefaultExpiry

  Set a default amount of seconds after which all keys touched by this handler will expire. The expire time of a key is reset every time it is read or written. A value of 0 means no default expiry.

  Default env var name is REDIS_DEFAULT_EXPIRY_SECONDS default is 0

• queryTimeout :: QueryTimeout

  0 means no timeout, every other value is a timeout in milliseconds.

  Default env var name is REDIS_QUERY_TIMEOUT_MILLISECONDS default is 1000

• maxKeySize :: MaxKeySize

decoder :: Decoder Settings

decodes Settings from environmental variables

Creating a redis API

jsonApi :: forall a field key. (ToJSON a, FromJSON a, Ord field) => (key -> Text) -> (field -> Text) -> (Text -> Maybe field) -> Api key field a

Creates a json API mapping a key to a json-encodable-decodable type

data Key = Key { fieldA: Text, fieldB: Text }
data Val = Val { ... }

myJsonApi :: Redis.Api Key Val
myJsonApi = Redis.jsonApi (\Key {fieldA,

textApi :: Ord field => (key -> Text) -> (field -> Text) -> (Text -> Maybe field) -> Api key field Text

Creates a Redis API mapping a key to Text

byteStringApi :: Ord field => (key -> Text) -> (field -> Text) -> (Text -> Maybe field) -> Api key field ByteString

Creates a Redis API mapping a key to a ByteString

data Api key field a

a API type can be used to enforce a mapping of keys to values. without an API type, it can be easy to naiively serialize the wrong type into a redis key.

Out of the box, we have helpers to support - jsonApi for json-encodable and decodable values - textApi for Text values - byteStringApi for ByteString values

Creating redis queries

del :: Api key field a -> NonEmpty key -> Query Int

Removes the specified keys. A key is ignored if it does not exist.

https://redis.io/commands/del

exists :: Api key field a -> key -> Query Bool

Returns if key exists.

https://redis.io/commands/exists

expire :: Api key field a -> key -> Int -> Query ()

Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is often said to be volatile in Redis terminology.

https://redis.io/commands/expire

ping :: Api key field a -> Query ()

Returns PONG if no argument is provided, otherwise return a copy of the argument as a bulk. This command is often used to test if a connection is still alive, or to measure latency.

https://redis.io/commands/ping

hdel :: Api key field a -> key -> NonEmpty field -> Query Int

Removes the specified fields from the hash stored at key. Specified fields that do not exist within this hash are ignored. If key does not exist, it is treated as an empty hash and this command returns 0.

https://redis.io/commands/hdel

hget :: Api key field a -> key -> field -> Query (Maybe a)

Get the value of the field of a hash at key. If the key does not exist, or the field in the hash does not exis the special value Nothing is returned An error is returned if the value stored at key is not a hash, because HGET only handles string values.

https://redis.io/commands/hget

hgetall :: Api key field a -> key -> Query (Dict field a)

Returns all fields and values of the hash stored at key. In the returned value, every field name is followed by its value, so the length of the reply is twice the size of the hash. Nothing in the returned value means failed utf8 decoding, not that it doesn't exist

https://redis.io/commands/hgetall

hkeys :: Api key field a -> key -> Query (List field)

Returns all field names in the hash stored at key. Empty list means key doesn't exist

https://redis.io/commands/hkeys

hmget :: Api key field a -> key -> NonEmpty field -> Query (Dict field a)

Returns the values associated with the specified fields in the hash stored at key.--

equivalent to modern hget https://redis.io/commands/hmget

hmset :: Api key field a -> key -> NonEmptyDict field a -> Query ()

Sets fields in the hash stored at key to values. If key does not exist, a new key holding a hash is created. If any fields exists, they are overwritten.

equivalent to modern hset https://redis.io/commands/hmset

hset :: Api key field a -> key -> field -> a -> Query ()

Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

https://redis.io/commands/hset

hsetnx :: Api key field a -> key -> field -> a -> Query Bool

Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.

https://redis.io/commands/hsetnx

Running Redis queries

query :: HasCallStack => Handler -> Query a -> Task Error a

Run a Query. Note: A Query in this library can consist of one or more queries in sequence. if a Query contains multiple queries, it may make more sense, if possible to run them using transaction

transaction :: HasCallStack => Handler -> Query a -> Task Error a

Run a redis Query in a transaction. If the query contains several Redis commands they're all executed together, and Redis will guarantee other requests won't be able change values in between.

In redis terms, this is wrappping the Query in MULTI and `EXEC see redis transaction semantics here: https://redis.io/topics/transactions

data Query a

A Redis query

Instances

Functor Query

Defined in Redis.Internal

Methods

fmap :: (a -> b) -> Query a -> Query b

(<$) :: a -> Query b -> Query a

Show (Query a)

Defined in Redis.Internal

Methods

showsPrec :: Int -> Query a -> ShowS

show :: Query a -> String

showList :: [Query a] -> ShowS

data Error

Redis Errors, scoped by where they originate.

Constructors

RedisError Text

ConnectionLost

DecodingError Text

DecodingFieldError Text

LibraryError Text

TransactionAborted

TimeoutError

KeyExceedsMaxSize Text Int

Instances

Show Error

Defined in Redis.Internal

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

ToJSON Error

Defined in Redis.Internal

Methods

toJSON :: Error -> Value

toEncoding :: Error -> Encoding

toJSONList :: [Error] -> Value

toEncodingList :: [Error] -> Encoding

map :: (a -> b) -> Query a -> Query b

Used to map the type of a query to another type useful in combination with transaction

map2 :: (a -> b -> c) -> Query a -> Query b -> Query c

Used to combine two queries Useful to combine two queries. Redis.map2 (Maybe.map2 (,)) (Redis.get api1 key) (Redis.get api2 key) |> Redis.query redis

map3 :: (a -> b -> c -> d) -> Query a -> Query b -> Query c -> Query d

Used to combine three queries Useful to combine three queries.

sequence :: List (Query a) -> Query (List a)

Used to run a series of queries in sequence. Useful to run a list of queries in sequence. queries |> Redis.sequence |> Redis.query redis