Database.RethinkDB

Haskell client driver for RethinkDB

Based upon the official Javascript, Python and Ruby API: http://www.rethinkdb.com/api/

How to use

 {-# LANGUAGE OverloadedStrings #-}
 import qualified Database.RethinkDB as R
 import qualified Database.RethinkDB.NoClash

Accessing RethinkDB

data RethinkDBHandle

A connection to the database server

Instances

Show RethinkDBHandle

connect :: HostName -> Integer -> Maybe String -> IO RethinkDBHandle

Create a new connection to the database server

Example: connect using the default port with no passphrase

>>> h <- connect "localhost" 28015 Nothing

close :: RethinkDBHandle -> IO ()

Close an open connection

use :: RethinkDBHandle -> Database -> RethinkDBHandle

Set the default database

The new handle is an alias for the old one. Calling close on either one will close both.

run :: (Expr query, Result r) => RethinkDBHandle -> query -> IO r

Run a given query and return a Result

run' :: Expr query => RethinkDBHandle -> query -> IO [Value]

Run a given query and return a Value

runOpts :: (Expr query, Result r) => RethinkDBHandle -> [RunOptions] -> query -> IO r

Run a query with the given options

next :: Cursor a -> IO (Maybe a)

Get the next value from a cursor

collect :: Cursor a -> IO [a]

A lazy stream of all the elements in the cursor

data RunOptions

Per-query settings

Constructors

UseOutdated

NoReply

SoftDurability Bool

data Cursor a

Instances

Functor Cursor

FromJSON a => Result (Cursor a)

data Response

The raw response to a query

Instances

Show Response

Result Response

class Result r where

Convert the raw query response into useful values

Methods

convertResult :: MVar Response -> IO r

Instances

Result Response

FromJSON a => Result [a]

FromJSON a => Result (Maybe a)

FromJSON a => Result (Cursor a)

data RethinkDBError

Constructors

RethinkDBError

Fields

errorCode :: ErrorCode

errorTerm :: BaseReQL

errorMessage :: String

errorBacktrace :: Backtrace

Instances

Show RethinkDBError

Typeable RethinkDBError

Exception RethinkDBError

data SuccessCode

Constructors

SuccessPartial RethinkDBHandle Int64

Success

Instances

Show SuccessCode

data ErrorCode

Constructors

ErrorBrokenClient

ErrorBadQuery

ErrorRuntime

ErrorUnexpectedResponse

Instances

Show ErrorCode

data ReQL

An RQL term

Instances

Num ReQL

Show ReQL

IsString ReQL

Expr ReQL

Javascript ReQL

Expr (ReQL -> ReQL -> ReQL)

Expr (ReQL -> ReQL)

Javascript (ReQL -> ReQL -> ReQL)

Javascript (ReQL -> ReQL)

Manipulating databases

data Database

A database, referenced by name

Constructors

Database

Fields

databaseName :: Text

Instances

Eq Database

Ord Database

Show Database

Expr Database

db :: Text -> Database

Create a Database reference

dbCreate :: String -> ReQL

Create a database on the server

dbDrop :: Database -> ReQL

Drop a database

dbList :: ReQL

List the databases on the server

Manipulating Tables

data Table

A table description

Constructors

Table

Fields

tableDatabase :: Maybe Database

when Nothing, use the connection's database

tableName :: Text

tablePrimaryKey :: Maybe Key

Instances

Eq Table

Ord Table

Show Table

Expr Table

data TableCreateOptions

Options used to create a table

Constructors

TableCreateOptions

Fields

tableDataCenter :: Maybe Text

tableCacheSize :: Maybe Int64

Instances

Default TableCreateOptions

table :: Text -> Table

Create a simple table refence with no associated database

tableCreate :: Table -> TableCreateOptions -> ReQL

Create a table on the server

tableDrop :: Table -> ReQL

Drop a table

tableList :: Database -> ReQL

List the tables in a database

indexCreate :: Expr fun => String -> fun -> Table -> ReQL

Create an index on the table from the given function

indexDrop :: Key -> Table -> ReQL

Drop an index

indexList :: Table -> ReQL

List the indexes on the table

Writing data

insert :: (Expr table, Expr object) => object -> table -> ReQL

Insert a document or a list of documents into a table

upsert :: (Expr table, Expr object) => object -> table -> ReQL

Like insert, but update existing documents with the same primary key

update :: Expr selection => (ReQL -> ReQL) -> selection -> ReQL

Add to or modify the contents of a document

replace :: Expr selection => (ReQL -> ReQL) -> selection -> ReQL

Replace a document with another

delete :: Expr selection => selection -> ReQL

Delete the documents

returnVals :: ReQL -> ReQL

Include the value of single write operations in the returned object

Selecting data

get :: (Expr s, Expr k) => k -> s -> ReQL

Get a document by primary key

filter :: (Expr predicate, Expr seq) => predicate -> seq -> ReQL

Filter a sequence given a predicate

between :: (Expr left, Expr right, Expr seq) => Key -> left -> right -> seq -> ReQL

Query all the documents whose value for the given index is in a given range

getAll :: Expr value => Key -> [value] -> Table -> ReQL

Retreive documents by their indexed value

Joins

innerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL

SQL-like join of two sequences. Returns each pair of rows that satisfy the 2-ary predicate.

outerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL

SQL-like join of two sequences. Returns each pair of rows that satisfy the 2-ary predicate.

eqJoin :: (Expr a, Expr b) => Key -> a -> Key -> b -> ReQL

An efficient iner_join that uses a key for the first table and an index for the left table.

mergeRightLeft :: Expr a => a -> ReQL

Merge the left and right attributes of the objects in a sequence. Called zip in the official drivers

Transformations

map :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL

Map a function over a sequence

withFields :: (Expr paths, Expr seq) => [paths] -> seq -> ReQL

Like hasFields followed by pluck

concatMap :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL

Map a function of a sequence and concat the results

drop :: (Expr a, Expr b) => a -> b -> ReQL

Drop elements from the head of a sequence. Called skip in the official drivers

take :: (Expr n, Expr seq) => n -> seq -> ReQL

Limit the size of a sequence. Called limit in the official drivers

(!!) :: Expr a => a -> ReQL -> ReQL

Get the nth value of a sequence or array

slice :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL

Cut out part of a sequence

orderBy :: Expr s => [Order] -> s -> ReQL

Order a sequence by the given keys

data Order

Oredering specification for orderBy

Constructors

Asc

Fields

orderAttr :: Key

Desc

Fields

orderAttr :: Key

indexesOf :: (Expr fun, Expr seq) => fun -> seq -> ReQL

The position in the sequence of the elements that match the predicate

isEmpty :: Expr seq => seq -> ReQL

Test if a sequence is empty

(++) :: (Expr a, Expr b) => a -> b -> ReQL

Join two sequences. Called union in the official drivers

sample :: (Expr n, Expr seq) => n -> seq -> ReQL

Select a given number of elements from a sequence with uniform random distribution

Aggregation

reduce :: (Expr base, Expr seq, Expr a) => (ReQL -> ReQL -> a) -> base -> seq -> ReQL

Reduce a sequence to a single value

reduce1 :: (Expr a, Expr s) => (ReQL -> ReQL -> a) -> s -> ReQL

Reduce a non-empty sequence to a single value

distinct :: Expr s => s -> ReQL

Filter out identical elements of the sequence

groupBy :: (Expr group, Expr reduction, Expr seq) => (ReQL -> group) -> (ReQL -> reduction) -> seq -> ReQL

Turn a grouping function and a reduction function into a grouped map reduce operation

member :: Expr o => [ReQL] -> o -> ReQL

Test if an object contains the given attribute. Called contains in the official drivers

Aggregators

length :: Expr a => a -> ReQL

The size of a sequence or an array. Called count in the official drivers

sum :: Expr s => s -> ReQL

The sum of a sequence

avg :: Expr s => s -> ReQL

The average of a sequence

Document manipulation

pluck :: Expr o => [ReQL] -> o -> ReQL

Keep only the given attributes

without :: Expr o => [ReQL] -> o -> ReQL

Remove the given attributes from an object

merge :: (Expr a, Expr b) => a -> b -> ReQL

Merge two objects together

append :: (Expr a, Expr b) => a -> b -> ReQL

Append a datum to a sequence

prepend :: (Expr datum, Expr array) => datum -> array -> ReQL

Prepend an element to an array

(\\) :: (Expr a, Expr b) => a -> b -> ReQL

Called difference in the official drivers

setInsert :: (Expr datum, Expr array) => datum -> array -> ReQL

Insert a datum into an array if it is not yet present

setUnion :: (Expr a, Expr b) => a -> b -> ReQL

The union of two sets

setIntersection :: (Expr a, Expr b) => a -> b -> ReQL

The intersection of two sets

setDifference :: (Expr set, Expr remove) => remove -> set -> ReQL

The difference of two sets

(!) :: Expr s => s -> ReQL -> ReQL

Get a single field form an object

hasFields :: (Expr obj, Expr paths) => paths -> obj -> ReQL

Test if an object has the given fields

insertAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL

Insert a datum at the given position in an array

spliceAt :: (Expr n, Expr replace, Expr array) => n -> replace -> array -> ReQL

Splice an array at a given position inside another array

deleteAt :: (Expr n, Expr array) => n -> array -> ReQL

Delete an element from an array

changeAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL

Change an element in an array

keys :: Expr obj => obj -> ReQL

The list of keys of the given object

Math and logic

(+) :: (Expr a, Expr b) => a -> b -> ReQL

Arithmetic Operator

(-) :: (Expr a, Expr b) => a -> b -> ReQL

Arithmetic Operator

(*) :: (Expr a, Expr b) => a -> b -> ReQL

Arithmetic Operator

(/) :: (Expr a, Expr b) => a -> b -> ReQL

Arithmetic Operator

mod :: (Expr a, Expr b) => a -> b -> ReQL

Arithmetic Operator

(&&) :: (Expr a, Expr b) => a -> b -> ReQL

Boolean operator

(||) :: (Expr a, Expr b) => a -> b -> ReQL

Boolean operator

(==) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

(/=) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

(>) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

(<) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

(<=) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

(>=) :: (Expr a, Expr b) => a -> b -> ReQL

Comparison operator

not :: Expr a => a -> ReQL

Negation

String manipulation

(=~) :: Expr string => string -> ReQL -> ReQL

Match a string to a regular expression. Called match in the official drivers

Dates and times

newtype UTCTime

Time with no time zone The default FromJSON instance for Data.Time.UTCTime is incompatible with ReQL's time type

Constructors

UTCTime UTCTime

Instances

FromJSON UTCTime

Expr UTCTime

newtype ZonedTime

Time with a time zone The default FromJSON instance for Data.Time.ZonedTime is incompatible with ReQL's time type

Constructors

ZonedTime ZonedTime

Instances

FromJSON ZonedTime

Expr ZonedTime

now :: ReQL

The time and date when the query is executed

time :: ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL

Build a time object from the year, month, day, hour, minute, second and timezone fields

epochTime :: ReQL -> ReQL

Build a time object given the number of seconds since the unix epoch

iso8601 :: ReQL -> ReQL

Build a time object given an iso8601 string

inTimezone :: Expr time => ReQL -> time -> ReQL

The same time in a different timezone

during :: (Expr left, Expr right, Expr time) => Bound left -> Bound right -> time -> ReQL

Test if a time is between two other times

timezone :: Expr time => time -> ReQL

Extract part of a time value

date :: Expr time => time -> ReQL

Extract part of a time value

timeOfDay :: Expr time => time -> ReQL

Extract part of a time value

year :: Expr time => time -> ReQL

Extract part of a time value

month :: Expr time => time -> ReQL

Extract part of a time value

day :: Expr time => time -> ReQL

Extract part of a time value

dayOfWeek :: Expr time => time -> ReQL

Extract part of a time value

dayOfYear :: Expr time => time -> ReQL

Extract part of a time value

hours :: Expr time => time -> ReQL

Extract part of a time value

minutes :: Expr time => time -> ReQL

Extract part of a time value

seconds :: Expr time => time -> ReQL

Extract part of a time value

toIso8601 :: Expr t => t -> ReQL

Convert a time to another representation

toEpochTime :: Expr t => t -> ReQL

Convert a time to another representation

Control structures

apply :: (Expr fun, Expr arg) => fun -> [arg] -> ReQL

Apply a function to a list of arguments. Called do in the official drivers

class Javascript r where

Create a javascript expression

Methods

js :: String -> r

Instances

Javascript ReQL

Javascript (ReQL -> ReQL -> ReQL)

Javascript (ReQL -> ReQL)

if' :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL

Called branch in the official drivers

forEach :: (Expr s, Expr a) => s -> (ReQL -> a) -> ReQL

Like map but for write queries

error :: Expr s => s -> ReQL

Abort the query with an error

handle :: (Expr handler, Expr reql) => handler -> reql -> ReQL

Catch some expections inside the query. Called default in the official drivers

class Expr e where

Convert other types into ReqL expressions

Methods

expr :: e -> ReQL

Instances

Expr Bool

Expr Double

Expr Int

Expr Int64

Expr Integer

Expr Rational

Expr ()

Expr Text

Expr UTCTime

Expr Value

Expr ZonedTime

Expr Datum

Expr Table

Expr Database

Expr Object

Expr BaseReQL

Expr ReQL

Expr ZonedTime

Expr UTCTime

Expr a => Expr [a]

Expr x => Expr (Vector x)

Expr (ReQL -> ReQL -> ReQL)

Expr (ReQL -> ReQL)

Expr e => Expr (HashMap Text e)

coerceTo :: Expr x => ReQL -> x -> ReQL

Convert a value to a different type

asArray :: Expr x => x -> ReQL

Convert a value to a different type

asString :: Expr x => x -> ReQL

Convert a value to a different type

asNumber :: Expr x => x -> ReQL

Convert a value to a different type

asObject :: Expr x => x -> ReQL

Convert a value to a different type

asBool :: Expr x => x -> ReQL

Convert a value to a different type

typeOf :: Expr a => a -> ReQL

A string representing the type of an expression

info :: Expr a => a -> ReQL

Get information on a given expression. Useful for tables and databases.

json :: Expr string => string -> ReQL

Parse a json string into an object

Helpers

class Obj o where

Convert into a ReQL object

Methods

obj :: o -> Object

Instances

Obj ()

Obj Object

Obj [BaseAttribute]

Obj [Attribute]

data Object

A list of key/value pairs

Instances

Obj Object

Expr Object

data Attribute

A key/value pair used for building objects

Constructors

forall e . Expr e => Text := e

Instances

Obj [Attribute]

str :: String -> ReQL

A shortcut for inserting strings into ReQL expressions Useful when OverloadedStrings makes the type ambiguous

num :: Double -> ReQL

A shortcut for inserting numbers into ReQL expressions

(.) :: (Expr a, Expr b, Expr c) => (ReQL -> b) -> (ReQL -> a) -> c -> ReQL

Specialised function composition

(#) :: (Expr a, Expr b) => a -> (ReQL -> b) -> ReQL

Flipped function composition

def :: Default a => a

The default value for this type.