rethinkdb-client-driver-0.0.20: Client driver for RethinkDB

Safe HaskellNone





defaultPort :: Int Source

The default port where RethinkDB accepts client driver connections.

newHandle :: Text -> Int -> Maybe Text -> Exp Database -> IO Handle Source

Create a new handle to the RethinkDB server.

handleDatabase :: Handle -> Exp Database Source

The Database which some expressions will use when not explicitly given one (eg. Table).

close :: Handle -> IO () Source

Close the given handle. You MUST NOT use the handle after this.

run :: FromResponse (Result a) => Handle -> Exp a -> IO (Res a) Source

Start a new query and wait for its (first) result. If the result is an single value (Datum), then three will be no further results. If it is a sequence, then you must consume results until the sequence ends.

nextChunk :: FromResponse (Sequence a) => Handle -> Sequence a -> IO (Either Error (Sequence a)) Source

Get the next chunk of a sequence. It is an error to request the next chunk if the sequence is already Done,

collect :: FromDatum a => Handle -> Sequence a -> IO (Either Error (Vector a)) Source

Collect all the values in a sequence and make them available as a 'Vector a'.

stop :: Handle -> Token -> IO () Source

Stop (abort?) a query.

wait :: Handle -> Token -> IO () Source

Wait until a previous query (which was started with the noreply option) finishes.

data Error Source

Errors include a plain-text description which includes further details. The RethinkDB protocol also includes a backtrace which we currently don't parse.


ProtocolError !Text

An error on the protocol level. Perhaps the socket was closed unexpectedly, or the server sent a message which the driver could not parse.

ClientError !Text

Means the client is buggy. An example is if the client sends a malformed protobuf, or tries to send [CONTINUE] for an unknown token.

CompileError !Text

Means the query failed during parsing or type checking. For example, if you pass too many arguments to a function.

RuntimeError !Text

Means the query failed at runtime. An example is if you add together two values from a table, but they turn out at runtime to be booleans rather than numbers.


The Datum type

data Datum Source

A sumtype covering all the primitive types which can appear in queries or responses.

It is similar to the aeson Value type, except that RethinkDB has a few more types (like Time), which have a special encoding in JSON.


Eq Datum

We can't automatically derive Eq because ZonedTime does not have an instance of Eq. See the eqTime function for why we can compare times.

Show Datum 
Generic Datum 
ToJSON Datum 
FromJSON Datum 
FromDatum Object 
FromDatum Datum 
ToDatum Object 
ToDatum Datum 
FromResponse Object 
FromResponse Datum 
IsObject Object 
IsDatum Object 
IsDatum Datum 
FromResponse (Maybe Datum) 
type Rep Datum 
type Result Object = Object 
type Result Datum = Datum 

type Array a = Vector a Source

Arrays are vectors of Datum.

type Object = HashMap Text Datum Source

Objects are maps from Text to Datum. Like Aeson, we're using a strict HashMap.

class ToDatum a where Source

Types which can be converted to or from a Datum.


toDatum :: a -> Datum Source

(.=) :: ToDatum a => Text -> a -> (Text, Datum) Source

data Exp a where Source


Constant :: ToDatum a => a -> Exp a 
MkArray :: [Exp a] -> Exp (Array a) 
ListDatabases :: Exp (Array Text) 
CreateDatabase :: Exp Text -> Exp Object 
DropDatabase :: Exp Text -> Exp Object 
WaitDatabase :: Exp Database -> Exp Object 
ListTables :: Exp Database -> Exp (Array Text) 
CreateTable :: Exp Database -> Exp Text -> Exp Object 
DropTable :: Exp Database -> Exp Text -> Exp Object 
WaitTable :: Exp Table -> Exp Object 
ListIndices :: Exp Table -> Exp (Array Text) 
CreateIndex :: IsDatum a => Exp Table -> Exp Text -> (Exp Object -> Exp a) -> Exp Object 
DropIndex :: Exp Table -> Exp Text -> Exp Object 
IndexStatus :: Exp Table -> [Exp Text] -> Exp (Array Object) 
WaitIndex :: Exp Table -> [Exp Text] -> Exp (Array Object) 
Database :: Exp Text -> Exp Database 
Table :: Maybe (Exp Database) -> Exp Text -> Exp Table 
Coerce :: Exp a -> Exp Text -> Exp b 
Eq :: (IsDatum a, IsDatum b) => Exp a -> Exp b -> Exp Bool 
Ne :: (IsDatum a, IsDatum b) => Exp a -> Exp b -> Exp Bool 
Not :: Exp Bool -> Exp Bool 
Match :: Exp Text -> Exp Text -> Exp Datum 
Get :: Exp Table -> Exp Text -> Exp SingleSelection 
GetAll :: IsDatum a => Exp Table -> [Exp a] -> Exp (Array Datum) 
GetAllIndexed :: IsDatum a => Exp Table -> [Exp a] -> Text -> Exp (Sequence Datum) 
Add :: Num a => [Exp a] -> Exp a 
Sub :: Num a => [Exp a] -> Exp a 
Multiply :: Num a => [Exp a] -> Exp a 
All :: [Exp Bool] -> Exp Bool 
Any :: [Exp Bool] -> Exp Bool 
GetField :: (IsObject a, IsDatum r) => Exp Text -> Exp a -> Exp r 
HasFields :: IsObject a => [Text] -> Exp a -> Exp Bool 
Take :: IsSequence s => Exp Double -> Exp s -> Exp s 
Append :: IsDatum a => Exp (Array a) -> Exp a -> Exp (Array a) 
Prepend :: IsDatum a => Exp (Array a) -> Exp a -> Exp (Array a) 
IsEmpty :: IsSequence a => Exp a -> Exp Bool 
Delete :: Exp a -> Exp Object 
InsertObject :: ConflictResolutionStrategy -> Exp Table -> Object -> Exp Object 
InsertSequence :: IsSequence s => Exp Table -> Exp s -> Exp Object 
Filter :: IsSequence s => (Exp a -> Exp Bool) -> Exp s -> Exp s 
Map :: IsSequence s => (Exp a -> Exp b) -> Exp s -> Exp (Sequence b) 
Between :: IsSequence s => (Bound, Bound) -> Exp s -> Exp s 
BetweenIndexed :: IsSequence s => Text -> (Bound, Bound) -> Exp s -> Exp s 
OrderBy :: IsSequence s => [Order] -> Exp s -> Exp s 
OrderByIndexed :: IsSequence s => Order -> Exp s -> Exp s 
Keys :: IsObject a => Exp a -> Exp (Array Text) 
Var :: Int -> Exp a 
Function :: State Context ([Int], Exp a) -> Exp f 
Call :: Exp f -> [SomeExp] -> Exp r 
Limit :: IsSequence s => Double -> Exp s -> Exp s 
Nth :: (IsSequence s, IsDatum r) => Double -> Exp s -> Exp r 
UUID :: Exp Text 
Now :: Exp ZonedTime 
Timezone :: Exp ZonedTime -> Exp Text 
RandomInteger :: Exp Int -> Exp Int -> Exp Int 
RandomFloat :: Exp Double -> Exp Double -> Exp Double 
Info :: Exp a -> Exp Object 
Default :: Exp a -> Exp a -> Exp a 
Error :: Exp Text -> Exp a 


Num (Exp Double) 
IsString (Exp Text)

Convenience to for automatically converting a Text to a constant expression.

data SomeExp where Source

Because the arguments to functions are polymorphic (the individual arguments can, and often have, different types).


SomeExp :: Exp a -> SomeExp 

data Bound Source

Bounds are used in Between.


Open !Datum 
Closed !Datum 

data Order Source

Used in OrderBy.


Ascending !Text 
Descending !Text 

data Sequence a Source

Sequences are a bounded list of items. The server may split the sequence into multiple chunks when sending it to the client. When the response is a partial sequence, the client may request additional chunks until it gets a Done.

data Table Source

Tables are something you can select objects from.

This type is not exported, and merely serves as a sort of phantom type. On the client tables are converted to a Sequence.

data Database Source

A Database is something which contains tables. It is a server-only type.

data SingleSelection Source

SingleSelection is essentially a 'Maybe Object', where Nothing is represented with Null in the network protocol.

type Res a = Either Error (Result a) Source

The result of a query. It is either an error or a result (which depends on the type of the query expression). This type is named to be symmetrical to Exp, so we get this nice type for run.

run :: Handle -> Exp a -> IO (Res a)

type family Result a Source

The type of result you get when executing a query of 'Exp a'.


class FromResponse a Source

A value which can be converted from a Response. All types which are defined as being a 'Result a' should have a 'FromResponse a'. Because, uhm.. you really want to be able to extract the result from the response.

There are two parsers defined here, one for atoms and the other for sequences. These are the only two implementations of parseResponse which should be used.

Minimal complete definition


data ConflictResolutionStrategy Source


How conflicts should be resolved.



Do not insert the new document and record the conflict as an error. This is the default.


Replace the old document in its entirety with the new one.


Update fields of the old document with fields from the new one.

lift :: Lift c e => e -> c (Simplified e) Source

call1 :: (Exp a -> Exp r) -> Exp a -> Exp r Source

Call an unary function with the given argument.

call2 :: (Exp a -> Exp b -> Exp r) -> Exp a -> Exp b -> Exp r Source

Call an binary function with the given arguments.

class IsDatum a Source


IsDatum Bool

For a boolean type, we're reusing the standard Haskell Bool type.

IsDatum Double

Numbers are Double (unlike Aeson, which uses Scientific). No particular reason.

IsDatum Text

For strings, we're using the Haskell Text type.

IsDatum UTCTime 
IsDatum ZonedTime

Time in RethinkDB is represented similar to the ZonedTime type. Except that the JSON representation on the wire looks different from the default used by Aeson. Therefore we have a custom FromRSON and ToRSON instances.

IsDatum Object 
IsDatum Datum 
IsDatum SingleSelection 
IsDatum a => IsDatum (Array a)

Arrays are vectors of Datum.

class IsDatum a => IsObject a Source

Objects are maps from Text to Datum. Like Aeson, we're using HashMap.