Database.RethinkDB.Functions

Functions from the ReQL (RethinkDB Query Language)

Documentation

(+) :: (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

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

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

Lists and Streams

length :: Expr a => a -> ReQL

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

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

Join two sequences. Called union in the official drivers

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

Map a function over a sequence

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

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

Append a datum to a sequence

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

Map a function of a sequence and concat the results

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.

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

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

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

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

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

Cut out part of a sequence

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

Get the nth value of a sequence or array

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

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

Like map but for write queries

mergeRightLeft :: Expr a => a -> ReQL

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

data Order

Oredering specification for orderBy

Constructors

Asc

Fields

orderAttr :: Key

Desc

Fields

orderAttr :: Key

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

Order a sequence by the given keys

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

sum :: Expr s => s -> ReQL

The sum of a sequence

avg :: Expr s => s -> ReQL

The average of a sequence

Accessors

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

Get a single field form an object

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

Keep only the given attributes

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

Remove the given attributes from an object

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

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

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

Merge two objects together

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

error :: Expr s => s -> ReQL

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

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

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

Retreive documents by their indexed value

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

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

Get a document by primary key

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

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

asBool :: Expr x => x -> ReQL

Convert a value to a different type

asObject :: Expr x => x -> ReQL

Convert a value to a different type

asNumber :: Expr x => x -> ReQL

Convert a value to a different type

asString :: Expr x => x -> ReQL

Convert a value to a different type

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

Like hasFields followed by pluck

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

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

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

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

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

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

Match a string to a regulr expression Called match in the official drivers

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

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

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

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

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

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

Flipped function composition

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

Specialised function composition