Database.RethinkDB.Functions

Functions from the ReQL (RethinkDB Query Language)

Numbers, Booleans and Comparisons

signum :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr

signum' :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr

(+) :: HaveValueType a b NumberType => a -> b -> NumberExpr

mod' :: HaveValueType a b NumberType => a -> b -> NumberExpr

mod :: HaveValueType a b NumberType => a -> b -> NumberExpr

div' :: HaveValueType a b NumberType => a -> b -> NumberExpr

(/) :: HaveValueType a b NumberType => a -> b -> NumberExpr

mul :: HaveValueType a b NumberType => a -> b -> NumberExpr

(*) :: HaveValueType a b NumberType => a -> b -> NumberExpr

sub :: HaveValueType a b NumberType => a -> b -> NumberExpr

(-) :: HaveValueType a b NumberType => a -> b -> NumberExpr

add :: HaveValueType a b NumberType => a -> b -> NumberExpr

or :: HaveValueType a b BoolType => a -> b -> BoolExpr

and' :: HaveValueType a b BoolType => a -> b -> BoolExpr

and :: HaveValueType a b BoolType => a -> b -> BoolExpr

or' :: HaveValueType a b BoolType => a -> b -> BoolExpr

(==) :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr

ne :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr

eq :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr

(!=) :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr

(>) :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

le :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

ge :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

lt :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

gt :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

(<=) :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

(<) :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

(>=) :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr

not :: HasValueType a BoolType => a -> BoolExpr

not' :: HasValueType a BoolType => a -> BoolExpr

Lists and Streams

length :: (ToExpr e, Sequence (ExprType e)) => e -> NumberExpr

count :: (ToExpr e, Sequence (ExprType e)) => e -> NumberExpr

(++) :: (HaveValueType a b v, CanConcat v) => a -> b -> Expr (ValueType v)

concat :: (HaveValueType a b v, CanConcat v) => a -> b -> Expr (ValueType v)

map :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (StreamType False (MappingTo m))

map' :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (StreamType False (MappingTo m))

filter' :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (ExprType e)

Get all the documents for which the given predicate is true

filter :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (ExprType e)

Get all the documents for which the given predicate is true

between :: (ToJSON a, ToStream e, ObjectType `HasToStreamValueOf` e) => Maybe a -> Maybe a -> e -> Expr (ExprType e)

Get all documents between two primary keys (both keys are inclusive)

append :: (HasValueType a ArrayType, HasValueType b x) => a -> b -> ArrayExpr

concatMap :: (ToMapping m, MappingTo m ~ ArrayType, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (StreamType False t)

concatMap' :: (ToMapping m, MappingTo m ~ ArrayType, ToStream e, MappingFrom m `HasToStreamValueOf` e) => m -> e -> Expr (StreamType False t)

innerJoin :: (ToStream a, l `HasToStreamValueOf` a, ToStream b, r `HasToStreamValueOf` b) => a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) -> Expr (StreamType False ObjectType)

outerJoin :: (ToStream a, l `HasToStreamValueOf` a, ToStream b, r `HasToStreamValueOf` b) => a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) -> Expr (StreamType False ObjectType)

asArray :: ToExpr e => e -> ArrayExpr

eqJoin :: (ToStream a, ObjectType `HasToStreamValueOf` a, ToExpr b, ExprType b ~ ExprType Selection) => a -> String -> b -> Expr (StreamType False ObjectType)

drop :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

skip :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

drop' :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

take :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

limit :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

take' :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> Expr (StreamType (ExprIsView e) t)

slice :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType, ToExpr m, ExprType m ~ ValueType NumberType) => e -> n -> m -> Expr (StreamType (ExprIsView e) t)

(!!) :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> ValueExpr t

nth :: (ToStream e, t `HasToStreamValueOf` e, ToExpr n, ExprType n ~ ValueType NumberType) => e -> n -> ValueExpr t

nil :: ValueExpr ArrayType

The empty list expression

union :: (ToStream a, t `HasToStreamValueOf` a, ToStream b, t `HasToStreamValueOf` b) => a -> b -> Expr (StreamType False t)

union' :: (ToStream a, t `HasToStreamValueOf` a, ToStream b, t `HasToStreamValueOf` b) => a -> b -> Expr (StreamType False t)

fold :: (ToValue z, ToValueType (ExprType z) ~ a, ToStream e, b `HasToStreamValueOf` e, ToExpr c, ExprIsView c ~ False) => (ValueExpr a -> ValueExpr b -> c) -> z -> e -> Expr (ExprType c)

A fold

>>> run h $ reduce [1,2,3] (0 :: Int) (+)
6

reduce :: (ToValue z, ToValueType (ExprType z) ~ a, ToStream e, b `HasToStreamValueOf` e, ToExpr c, ExprIsView c ~ False) => e -> z -> (ValueExpr a -> ValueExpr b -> c) -> Expr (ExprType c)

distinct :: (ToStream e, v `HasToStreamValueOf` e) => e -> Expr (StreamType False v)

groupedMapReduce :: (ToValue group, ToValue value, ToValue acc, ToValueType (ExprType acc) ~ b, ToValue acc', ToValueType (ExprType acc') ~ b, ToStream e, a `HasToStreamValueOf` e) => (ValueExpr a -> group) -> (ValueExpr a -> value) -> acc -> (ValueExpr b -> ValueExpr v -> acc') -> e -> Expr (StreamType False b)

forEach :: (ToStream a, v `HasToStreamValueOf` a) => a -> (ValueExpr v -> WriteQuery b) -> WriteQuery ()

Execute a write query for each element of the stream

>>> run h $ forEach [1,2,3::Int] (\x -> insert (table "fruits") (obj ["n" := x]))

zip :: (ToStream e, ObjectType `HasToStreamValueOf` e) => e -> Expr (StreamType False ObjectType)

zip' :: (ToStream e, ObjectType `HasToStreamValueOf` e) => e -> Expr (StreamType False ObjectType)

data Order

Constructors

Asc

Fields

orderAttr :: String

Desc

Fields

orderAttr :: String

Instances

ToOrder Order

orderAscending :: Order -> Bool

class ToOrder a where

Methods

toOrder :: a -> Order

Instances

ToOrder String

ToOrder Order

orderBy :: (ToOrder o, ToStream e, a `HasToStreamValueOf` e) => [o] -> e -> Expr (StreamType (ExprIsView e) a)

groupBy :: (ToStream e, ObjectType `HasToStreamValueOf` e) => [String] -> MapReduce ObjectType b c d -> e -> Expr (StreamType False d)

groupBy' :: (ToStream e, ObjectType `HasToStreamValueOf` e) => [String] -> MapReduce ObjectType b c d -> e -> Expr (StreamType False d)

data MapReduce a b c d

Constructors

MapReduce (ValueExpr a -> ValueExpr b) (ValueExpr c) (ValueExpr c -> ValueExpr b -> ValueExpr c) (ValueExpr c -> ValueExpr d)

sum :: String -> MapReduce ObjectType NumberType NumberType NumberType

sum' :: String -> MapReduce ObjectType NumberType NumberType NumberType

count' :: MapReduce ObjectType NoneType NumberType NumberType

avg :: String -> MapReduce ObjectType ArrayType ArrayType NumberType

Accessors

(!) :: (ToExpr a, ExprValueType a ~ ObjectType) => a -> String -> ValueExpr t

Get the value of the field of an object

When GHC thinks the result is ambiguous, it may have to be annotated.

>>> run h $ (get (table "tea") "black" ! "water_temperature" :: NumberExpr)
95

pick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr

unpick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr

(!?) :: HasValueType a ObjectType => a -> String -> BoolExpr

pluck :: (ToStream e, ObjectType `HasToStreamValueOf` e) => [String] -> e -> Expr (StreamType False ObjectType)

without :: (ToStream e, ObjectType `HasToStreamValueOf` e) => [String] -> e -> Expr (StreamType False ObjectType)

merge :: (ToExpr a, ExprType a ~ ValueType ObjectType, ToExpr b, ExprType b ~ ValueType ObjectType) => a -> b -> ObjectExpr

Control Structures, Functions and Javascript

js :: String -> Expr (ValueType any)

A javascript expression

It is often necessary to specify the result type:

>>> run h $ (js "1 + 2" :: NumberExpr)
3

bind :: ToValue e => e -> (ValueExpr (ToValueType (ExprType e)) -> Expr t) -> Expr t

let' :: [Attribute] -> Expr t -> Expr t

var :: ExprIsView (Expr t) ~ False => String -> Expr t

if' :: (ToValue e, ToValueType (ExprType e) ~ BoolType, ToExpr a, ExprTypeNoView (ExprType a) ~ x, ToExpr b, ExprTypeNoView (ExprType b) ~ x, ExprTypeIsView x ~ False) => e -> a -> b -> Expr x

jsfun :: ToValue e => String -> e -> Expr (ValueType y)

A javascript function

>>> let squareRoot = jsfun "Math.sqrt" :: NumberExpr -> NumberExpr
>>> run h $ squareRoot 5 :: IO Double
2.23606797749979

error :: ExprTypeIsView t ~ False => String -> Expr t

error' :: ExprTypeIsView t ~ False => String -> Expr t

class CanConcat a

Instances

CanConcat StringType

CanConcat ArrayType