Redis.SortedSet

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.

handlerAutoExtendExpire :: Text -> Settings -> Acquire HandlerAutoExtendExpire

Produce a namespaced handler for Redis access. This will ensure that we extend all keys accessed by a query by a configured default time (see Settings.defaultExpiry)

type Handler = Handler' 'NoAutoExtendExpire

This is a type alias of a handler parametrized by a value that indicates that the auto extend feature is disabled. Note: The tick in front of NoAutoExtendExpire is not necessary, but good practice to indicate that we are lifting a value to the type level.

type HandlerAutoExtendExpire = Handler' 'AutoExtendExpire

This is a type alias of a handler parametrized by a value that indicates that the auto extend feature is enabled. Note: The tick in front of AutoExtendExpire is not necessary, but good practice to indicate that we are lifting a value to the type level.

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

Instances

Show Settings

Defined in Redis.Settings

Methods

showsPrec :: Int -> Settings -> ShowS

show :: Settings -> String

showList :: [Settings] -> ShowS

decoder :: Decoder Settings

decodes Settings from environmental variables

Creating a Redis API

jsonApi :: forall a key. (ToJSON a, FromJSON a, Ord a) => (key -> Text) -> Api key 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 :: (key -> Text) -> Api key Text

Creates a Redis API mapping a key to Text

byteStringApi :: (key -> Text) -> Api key ByteString

Creates a Redis API mapping a key to a ByteString

data Api key a

Creating Redis queries

del :: Api key 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 a -> key -> Query Bool

Returns if key exists.

https://redis.io/commands/exists

expire :: Api key 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 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

zadd :: Api key a -> key -> NonEmptyDict a Float -> Query Int

Adds all the specified members with the specified scores to the sorted set. If a specified member is already a member of the sorted set, the score is updated and the element reinserted at the right position to ensure the correct ordering.

https://redis.io/commands/zadd

zrange :: Api key a -> key -> Int -> Int -> Query (List a)

Returns the specified range of elements in the sorted set. The order of elements is from the lowest to the highest score. Elements with the same score are ordered lexicographically. The start and stop arguments represent zero-based indexes, where 0 is the first element, 1 is the next element, and so on. These arguments specify an inclusive range, so for example, ZRANGE myzset 0 1 will return both the first and the second element of the sorted set.

The indexes can also be negative numbers indicating offsets from the end of the sorted set, with -1 being the last element of the sorted set, -2 the penultimate element, and so on.

Out of range indexes do not produce an error.

https://redis.io/commands/zrange

zrangeByScoreWithScores :: Api key a -> key -> Float -> Float -> Query [(a, Float)]

Like zrange, but with the bounds being scores rather than offsets, and with the result including the scores for each returned result.

zrank :: Api key a -> key -> a -> Query (Maybe Int)

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high. The rank (or index) is 0-based, which means that the member with the lowest score has rank 0.

https://redis.io/commands/zrank

zrevrank :: Api key a -> key -> a -> Query (Maybe Int)

Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low. The rank (or index) is 0-based, which means that the member with the highest score has rank 0.

https://redis.io/commands/zrevrank

Running Redis queries

query :: HasCallStack => Handler' x -> 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' x -> 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

ToJSON Error

Defined in Redis.Internal

Methods

toJSON :: Error -> Value

toEncoding :: Error -> Encoding

toJSONList :: [Error] -> Value

toEncodingList :: [Error] -> Encoding

Show Error

Defined in Redis.Internal

Methods

showsPrec :: Int -> Error -> ShowS

show :: Error -> String

showList :: [Error] -> ShowS

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