Safe Haskell | None |
---|---|
Language | Haskell98 |
ReQL Functions
ReQL was designed for dynamic languages. Many operations take optional positional and named arguments.
Optional named arguments can be added using ex
, for example
`upsert = ex insert ["conflict" := "update"]`
For optional positional arguments this module defines an extra
function if the functionality is not available otherwise. For
example argmax
for max
and splitOn
for split
but skip
instead of sliceFrom
and `avg . (!k)` instead of `avgOf k`.
- tableCreate :: Table -> ReQL
- insert :: Expr object => object -> Table -> ReQL
- update :: (Expr selection, Expr a) => (ReQL -> a) -> selection -> ReQL
- replace :: (Expr selection, Expr a) => (ReQL -> a) -> selection -> ReQL
- delete :: Expr selection => selection -> ReQL
- forEach :: (Expr a, Expr s) => (ReQL -> a) -> s -> ReQL
- table :: Text -> Table
- tableDrop :: Table -> ReQL
- tableList :: Database -> ReQL
- (+) :: (Expr a, Expr b) => a -> b -> ReQL
- (-) :: (Expr a, Expr b) => a -> b -> ReQL
- (*) :: (Expr a, Expr b) => a -> b -> ReQL
- (/) :: (Expr a, Expr b) => a -> b -> ReQL
- mod :: (Expr a, Expr b) => a -> b -> ReQL
- (||) :: (Expr a, Expr b) => a -> b -> ReQL
- (&&) :: (Expr a, Expr b) => a -> b -> ReQL
- (==) :: (Expr a, Expr b) => a -> b -> ReQL
- (/=) :: (Expr a, Expr b) => a -> b -> ReQL
- (>) :: (Expr a, Expr b) => a -> b -> ReQL
- (<) :: (Expr a, Expr b) => a -> b -> ReQL
- (>=) :: (Expr a, Expr b) => a -> b -> ReQL
- (<=) :: (Expr a, Expr b) => a -> b -> ReQL
- not :: Expr a => a -> ReQL
- count :: Expr a => a -> ReQL
- union :: (Expr a, Expr b) => a -> b -> ReQL
- map :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL
- filter :: (Expr predicate, Expr seq) => predicate -> seq -> ReQL
- between :: (Expr left, Expr right, Expr seq) => Index -> Bound left -> Bound right -> seq -> ReQL
- append :: (Expr a, Expr b) => a -> b -> ReQL
- concatMap :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL
- innerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL
- outerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL
- eqJoin :: (Expr fun, Expr right, Expr left) => fun -> right -> Index -> left -> ReQL
- skip :: (Expr n, Expr seq) => n -> seq -> ReQL
- limit :: (Expr n, Expr seq) => n -> seq -> ReQL
- slice :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL
- reduce0 :: (Expr base, Expr seq, Expr a) => (ReQL -> ReQL -> a) -> base -> seq -> ReQL
- reduce :: (Expr a, Expr s) => (ReQL -> ReQL -> a) -> s -> ReQL
- distinct :: Expr s => s -> ReQL
- zip :: Expr a => a -> ReQL
- orderBy :: Expr s => [ReQL] -> s -> ReQL
- asc :: ReQL -> ReQL
- desc :: ReQL -> ReQL
- group :: (Expr group, Expr reduction, Expr seq) => (ReQL -> group) -> (ReQL -> reduction) -> seq -> ReQL
- mapReduce :: (Expr reduction, Expr seq) => (ReQL -> reduction) -> seq -> ReQL
- sum :: Expr s => s -> ReQL
- avg :: Expr s => s -> ReQL
- min :: Expr s => s -> ReQL
- argmin :: (Expr s, Expr a) => (ReQL -> a) -> s -> ReQL
- max :: Expr s => s -> ReQL
- floor :: Expr s => s -> ReQL
- ceil :: Expr s => s -> ReQL
- round :: Expr s => s -> ReQL
- argmax :: (Expr s, Expr a) => (ReQL -> a) -> s -> ReQL
- (!) :: Expr s => s -> ReQL -> ReQL
- (!?) :: Expr s => s -> ReQL -> ReQL
- pluck :: Expr o => [ReQL] -> o -> ReQL
- without :: Expr o => [ReQL] -> o -> ReQL
- contains :: (Expr x, Expr seq) => x -> seq -> ReQL
- merge :: (Expr a, Expr b) => a -> b -> ReQL
- literal :: Expr a => a -> ReQL
- remove :: ReQL
- js :: ReQL -> ReQL
- branch :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL
- error :: Expr s => s -> ReQL
- db :: Text -> Database
- dbCreate :: Text -> ReQL
- dbDrop :: Database -> ReQL
- dbList :: ReQL
- indexCreate :: Expr fun => Text -> fun -> Table -> ReQL
- indexStatus :: Expr table => [ReQL] -> table -> ReQL
- indexWait :: Expr table => [ReQL] -> table -> ReQL
- indexRename :: Expr table => ReQL -> ReQL -> table -> ReQL
- sync :: Expr table => table -> ReQL
- indexList :: Table -> ReQL
- indexDrop :: Key -> Table -> ReQL
- getAll :: Expr values => Index -> values -> Table -> ReQL
- get :: Expr s => ReQL -> s -> ReQL
- coerceTo :: Expr x => ReQL -> x -> ReQL
- asArray :: Expr x => x -> ReQL
- asString :: Expr x => x -> ReQL
- asNumber :: Expr x => x -> ReQL
- asObject :: Expr x => x -> ReQL
- asBool :: Expr x => x -> ReQL
- withFields :: Expr seq => [ReQL] -> seq -> ReQL
- indexesOf :: (Expr fun, Expr seq) => fun -> seq -> ReQL
- isEmpty :: Expr seq => seq -> ReQL
- sample :: (Expr n, Expr seq) => n -> seq -> ReQL
- prepend :: (Expr datum, Expr array) => datum -> array -> ReQL
- difference :: (Expr a, Expr b) => a -> b -> ReQL
- setInsert :: (Expr datum, Expr array) => datum -> array -> ReQL
- setUnion :: (Expr a, Expr b) => a -> b -> ReQL
- setIntersection :: (Expr a, Expr b) => a -> b -> ReQL
- setDifference :: (Expr set, Expr remove) => remove -> set -> ReQL
- hasFields :: Expr obj => ReQL -> obj -> ReQL
- insertAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL
- spliceAt :: (Expr n, Expr replace, Expr array) => n -> replace -> array -> ReQL
- deleteAt :: (Expr n, Expr array) => n -> array -> ReQL
- changeAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL
- keys :: Expr object => object -> ReQL
- match :: Expr string => ReQL -> string -> ReQL
- apply :: (Expr fun, Expr arg) => fun -> [arg] -> ReQL
- handle :: (Expr instead, Expr reql) => (ReQL -> instead) -> reql -> ReQL
- typeOf :: Expr a => a -> ReQL
- info :: Expr a => a -> ReQL
- json :: ReQL -> ReQL
- (#) :: (Expr a, Expr b) => a -> (a -> b) -> ReQL
- upcase :: Expr str => str -> ReQL
- downcase :: Expr str => str -> ReQL
- split :: Expr str => str -> ReQL
- splitOn :: Expr str => ReQL -> str -> ReQL
- splitMax :: Expr str => ReQL -> ReQL -> str -> ReQL
- random :: ReQL
- randomTo :: ReQL -> ReQL
- randomFromTo :: ReQL -> ReQL -> ReQL
- data HttpOptions = HttpOptions {
- httpTimeout :: Maybe Int
- httpReattempts :: Maybe Int
- httpRedirects :: Maybe Int
- httpVerify :: Maybe Bool
- httpResultFormat :: Maybe HttpResultFormat
- httpMethod :: Maybe HttpMethod
- httpAuth :: Maybe [Attribute Dynamic]
- httpParams :: Maybe [Attribute Dynamic]
- httpHeader :: Maybe [Attribute Dynamic]
- httpData :: Maybe ReQL
- httpPage :: Maybe PaginationStrategy
- httpPageLimit :: Maybe Int
- data HttpResultFormat
- data HttpMethod
- data PaginationStrategy
- = LinkNext
- | PaginationFunction (ReQL -> ReQL)
- http :: Expr url => url -> HttpOptions -> ReQL
- args :: Expr array => array -> ReQL
- changes :: Expr seq => seq -> ReQL
- returnChanges :: Attribute a
- includeStates :: Attribute a
- data Durability
- durability :: Durability -> Attribute a
- nonAtomic :: Attribute a
- data ConflictResolution
- conflict :: ConflictResolution -> Attribute a
- uuid :: ReQL
- range :: ReQL -> ReQL
- rangeFromTo :: ReQL -> ReQL -> ReQL
- rangeAll :: ReQL
- wait :: Expr table => table -> ReQL
- toJSON :: Expr a => a -> ReQL
- zipWith :: (Expr left, Expr right, Expr b) => (ReQL -> ReQL -> b) -> left -> right -> ReQL
- zipWithN :: (Arr a, Expr f) => f -> a -> ReQL
- reconfigure :: (Expr table, Expr replicas) => ReQL -> replicas -> table -> ReQL
- rebalance :: Expr table => table -> ReQL
- config :: Expr table => table -> ReQL
- status :: Expr table => table -> ReQL
Documentation
Get the doctests ready
>>>
:load Database.RethinkDB.Doctest
>>>
import qualified Database.RethinkDB as R
>>>
:set -XOverloadedStrings
>>>
default (Datum, ReQL, String, Int, Double)
>>>
h <- doctestConnect
>>>
try' $ run' h $ dbCreate "doctests"
>>>
try' $ run' h $ tableCreate "foo"
>>>
try' $ run' h $ delete $ table "foo"
>>>
try' $ run' h $ tableCreate "bar"
>>>
try' $ run' h $ delete $ table "bar"
>>>
try' $ run' h $ tableDrop "bar"
>>>
try' $ run' h $ tableCreate (table "posts")
>>>
try' $ run' h $ delete $ table "posts"
>>>
try' $ run' h $ tableCreate (table "places")
>>>
try' $ run' h $ delete $ table "places"
>>>
try' $ run' h $ tableCreate (table "users"){ tablePrimaryKey = Just "name" }
>>>
try' $ run' h $ delete $ table "users"
>>>
try' $ run' h $ table "users" # indexDrop "occupation"
>>>
try' $ run' h $ table "users" # indexDrop "location"
>>>
try' $ run' h $ table "users" # indexDrop "friends"
tableCreate :: Table -> ReQL Source
Create a table on the server
>>> run' h $ tableCreate (table "posts") def [{"created":1}] >>> run' h $ tableCreate (table "users"){ tablePrimaryKey = Just "name" } def [{"created":1}] >>> run' h $ tableCreate (Table (Just "doctests") "bar" (Just "name")) def [{"created":1}] >>> run' h $ ex tableCreate ["datacenter":="orion"] (Table (Just "doctests") "bar" (Just "name")) def [{"created":1}]
insert :: Expr object => object -> Table -> ReQL Source
Insert a document or a list of documents into a table
>>>
run h $ table "users" # insert (map (\x -> ["name":=x]) ["bill", "bob", "nancy" :: Text]) :: IO WriteResponse
{inserted:3}>>>
run h $ table "posts" # insert ["author" := str "bill", "message" := str "hi", "id" := 1] :: IO WriteResponse
{inserted:1}>>>
run h $ table "posts" # insert ["author" := str "bill", "message" := str "hello", "id" := 2, "flag" := str "deleted"] :: IO WriteResponse
{inserted:1}>>>
run h $ table "posts" # insert ["author" := str "bob", "message" := str "lorem ipsum", "id" := 3, "flag" := str "pinned"] :: IO WriteResponse
{inserted:1}
update :: (Expr selection, Expr a) => (ReQL -> a) -> selection -> ReQL Source
Add to or modify the contents of a document
>>>
run h $ table "users" # getAll "name" [str "bob"] # update (const ["occupation" := str "tailor"]) :: IO WriteResponse
{replaced:1}
replace :: (Expr selection, Expr a) => (ReQL -> a) -> selection -> ReQL Source
Replace a document with another
>>>
run h $ replace (\user -> ["name" := user!"name", "occupation" := str "clothier"]) . R.filter ((R.== str "tailor") . (!?"occupation")) $ table "users" :: IO WriteResponse
{replaced:1}
delete :: Expr selection => selection -> ReQL Source
Delete the documents
>>>
run h $ delete . getAll "name" [str "bob"] $ table "users" :: IO WriteResponse
{deleted:1}
forEach :: (Expr a, Expr s) => (ReQL -> a) -> s -> ReQL Source
Like map but for write queries
>>>
_ <- run' h $ table "users" # replace (without ["post_count"])
>>>
run h $ forEach (\user -> table "users" # get (user!"name") # ex update [nonAtomic] (const ["post_count" := R.count (table "posts" # R.filter (\post -> post!"author" R.== user!"name"))])) (table "users") :: IO WriteResponse
{replaced:2}
A table
>>>
fmap sort $ run h $ table "users" :: IO [Datum]
[{"post_count":2,"name":"bill"},{"post_count":0,"name":"nancy"}]
tableDrop :: Table -> ReQL Source
Drop a table
>>>
run' h $ tableDrop (table "foo")
{"config_changes":[{"new_val":null,"old_val":{"primary_key":"id","write_acks":"majority","durability":"hard","name":"foo","shards":...,"id":...,"db":"doctests"}}],"tables_dropped":1}
tableList :: Database -> ReQL Source
List the tables in a database
>>>
fmap sort $ run h $ tableList (db "doctests") :: IO [String]
["places","posts","users"]
(+) :: (Expr a, Expr b) => a -> b -> ReQL infixl 6 Source
Addition or concatenation
Use the Num instance, or a qualified operator.
>>>
run h $ 2 + 5
7>>>
run h $ str "foo" R.+ str "bar"
"foobar"
(||) :: (Expr a, Expr b) => a -> b -> ReQL infixr 2 Source
Boolean or
>>>
run h $ True R.|| False
true
(&&) :: (Expr a, Expr b) => a -> b -> ReQL infixr 3 Source
Boolean and
>>>
run h $ True R.&& False
false
(==) :: (Expr a, Expr b) => a -> b -> ReQL infix 4 Source
Test for equality
>>>
run h $ ["a" := 1] R.== ["a" := 1]
true
(/=) :: (Expr a, Expr b) => a -> b -> ReQL infix 4 Source
Test for inequality
>>>
run h $ 1 R./= False
true
(<) :: (Expr a, Expr b) => a -> b -> ReQL infix 4 Source
Lesser than
>>>
run h $ (str "a") R.< (str "b")
true
(>=) :: (Expr a, Expr b) => a -> b -> ReQL infix 4 Source
Greater than or equal to
>>>
run h $ [1] R.>= Null
false
(<=) :: (Expr a, Expr b) => a -> b -> ReQL infix 4 Source
Lesser than or equal to
>>>
run h $ 2 R.<= 2
true
Lists and Streams
count :: Expr a => a -> ReQL Source
The size of a sequence or an array.
>>>
run h $ count (table "users")
2
union :: (Expr a, Expr b) => a -> b -> ReQL Source
Join two sequences.
>>>
run h $ [1,2,3] `union` ["a", "b", "c" :: Text]
[1,2,3,"a","b","c"]
map :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL Source
Map a function over a sequence
>>>
run h $ R.map (!"a") [["a" := 1], ["a" := 2]]
[1,2]
filter :: (Expr predicate, Expr seq) => predicate -> seq -> ReQL Source
Filter a sequence given a predicate
>>>
run h $ R.filter (R.< 4) [3, 1, 4, 1, 5, 9, 2, 6]
[3,1,1,2]
between :: (Expr left, Expr right, Expr seq) => Index -> Bound left -> Bound right -> seq -> ReQL Source
Query all the documents whose value for the given index is in a given range
>>>
run h $ table "users" # between "name" (Closed $ str "a") (Open $ str "c")
[{"post_count":2,"name":"bill"}]
append :: (Expr a, Expr b) => a -> b -> ReQL Source
Append a datum to a sequence
>>>
run h $ append 3 [1, 2]
[1,2,3]
concatMap :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL Source
Map a function of a sequence and concat the results
>>>
run h $ concatMap id [[1, 2], [3], [4, 5]]
[1,2,3,4,5]
innerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL Source
SQL-like inner join of two sequences
>>>
sorted $ run' h $ innerJoin (\user post -> user!"name" R.== post!"author") (table "users") (table "posts") # R.zip # orderBy [asc "id"] # pluck ["name", "message"]
[{"name":"bill","message":"hello"},{"name":"bill","message":"hi"}]
outerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL Source
SQL-like outer join of two sequences
>>>
sorted $ run' h $ outerJoin (\user post -> user!"name" R.== post!"author") (table "users") (table "posts") # R.zip # orderBy [asc "id", asc "name"] # pluck ["name", "message"]
[{"name":"bill","message":"hello"},{"name":"bill","message":"hi"},{"name":"nancy"}]
eqJoin :: (Expr fun, Expr right, Expr left) => fun -> right -> Index -> left -> ReQL Source
An efficient inner_join that uses a key for the left table and an index for the right table.
>>>
sorted $ run' h $ table "posts" # eqJoin "author" (table "users") "name" # R.zip # orderBy [asc "id"] # pluck ["name", "message"]
[{"name":"bill","message":"hello"},{"name":"bill","message":"hi"}]
skip :: (Expr n, Expr seq) => n -> seq -> ReQL Source
Drop elements from the head of a sequence.
>>>
run h $ skip 2 [1, 2, 3, 4]
[3,4]
limit :: (Expr n, Expr seq) => n -> seq -> ReQL Source
Limit the size of a sequence.
>>>
run h $ limit 2 [1, 2, 3, 4]
[1,2]
slice :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL Source
Cut out part of a sequence
>>>
run h $ slice 2 4 [1, 2, 3, 4, 5]
[3,4]
reduce0 :: (Expr base, Expr seq, Expr a) => (ReQL -> ReQL -> a) -> base -> seq -> ReQL Source
Reduce a sequence to a single value
>>>
run h $ reduce0 (+) 0 [1, 2, 3]
6
reduce :: (Expr a, Expr s) => (ReQL -> ReQL -> a) -> s -> ReQL Source
Reduce a non-empty sequence to a single value
>>>
run h $ reduce (+) [1, 2, 3]
6
distinct :: Expr s => s -> ReQL Source
Filter out identical elements of the sequence
>>>
fmap sort $ run h $ distinct (table "posts" ! "flag") :: IO [String]
["deleted","pinned"]
zip :: Expr a => a -> ReQL Source
Merge the "left" and "right" attributes of the objects in a sequence.
>>>
fmap sort $ run h $ table "posts" # eqJoin "author" (table "users") "name" # R.zip :: IO [Datum]
[{"post_count":2,"flag":"deleted","name":"bill","author":"bill","id":2,"message":"hello"},{"post_count":2,"name":"bill","author":"bill","id":1,"message":"hi"}]
orderBy :: Expr s => [ReQL] -> s -> ReQL Source
Order a sequence by the given keys
>>>
run' h $ table "users" # orderBy [desc "post_count", asc "name"] # pluck ["name", "post_count"]
[{"post_count":2,"name":"bill"},{"post_count":0,"name":"nancy"}]
>>>
run' h $ table "users" # ex orderBy ["index":="name"] [] # pluck ["name"]
[{"name":"bill"},{"name":"nancy"}]
group :: (Expr group, Expr reduction, Expr seq) => (ReQL -> group) -> (ReQL -> reduction) -> seq -> ReQL Source
Turn a grouping function and a reduction function into a grouped map reduce operation
>>>
run' h $ table "posts" # orderBy [asc "id"] # group (!"author") (reduce (\a b -> a + "\n" + b) . R.map (!"message"))
[{"group":"bill","reduction":"hi\nhello"},{"group":"bob","reduction":"lorem ipsum"}]>>>
run' h $ table "users" # group ((!0) . splitOn "" . (!"name")) (\users -> let pc = users!"post_count" in [avg pc, R.sum pc])
[{"group":"b","reduction":[2,2]},{"group":"n","reduction":[0,0]}]
mapReduce :: (Expr reduction, Expr seq) => (ReQL -> reduction) -> seq -> ReQL Source
Rewrite multiple reductions into a single map/reduce operation
Accessors
(!) :: Expr s => s -> ReQL -> ReQL infixl 9 Source
Get a single field from an object or an element of an array
>>>
run h $ ["foo" := True] ! "foo"
true
>>>
run h $ [1, 2, 3] ! 0
1
Or a single field from each object in a sequence
>>>
run h $ [["foo" := True], ["foo" := False]] ! "foo"
[true,false]
(!?) :: Expr s => s -> ReQL -> ReQL Source
Get a single field, or null if not present
>>>
run' h $ empty !? "foo"
null
pluck :: Expr o => [ReQL] -> o -> ReQL Source
Keep only the given attributes
>>>
run' h $ [["a" := 1, "b" := 2], ["a" := 2, "c" := 7], ["b" := 4]] # pluck ["a"]
[{"a":1},{"a":2},{}]
without :: Expr o => [ReQL] -> o -> ReQL Source
Remove the given attributes from an object
>>>
run' h $ [["a" := 1, "b" := 2], ["a" := 2, "c" := 7], ["b" := 4]] # without ["a"]
[{"b":2},{"c":7},{"b":4}]
contains :: (Expr x, Expr seq) => x -> seq -> ReQL Source
Test if a sequence contains a given element
>>>
run' h $ [1,2,3] # contains 1
true
merge :: (Expr a, Expr b) => a -> b -> ReQL Source
Merge two objects together
>>>
run' h $ merge ["a" := 1, "b" := 1] ["b" := 1, "c" := 2]
{"a":1,"b":1,"c":2}
literal :: Expr a => a -> ReQL Source
Literal objects, in a merge or update, are not processed recursively.
>>>
run' h $ ["a" := ["b" := 1]] # merge ["a" := literal ["c" := 2]]
{"a":{"c":2}}
Remove fields when doing a merge or update
>>>
run' h $ ["a" := ["b" := 1]] # merge ["a" := remove]
{}
Evaluate a JavaScript expression
>>>
run' h $ js "Math.PI"
3.141592653589793>>>
let r_sin x = js "Math.sin" `apply` [x]
>>>
run h $ R.map r_sin [pi, pi/2]
[1.2246...,1]
branch :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL Source
Server-side if
>>>
run h $ branch (1 R.< 2) 3 4
3
error :: Expr s => s -> ReQL Source
Abort the query with an error
>>>
run' h $ R.error (str "haha") R./ 2 + 1
*** Exception: RethinkDB: Runtime error: "haha" in add(div({- HERE -} error("haha"), 2), 1)
Create a Database reference
>>>
run' h $ db "test" # info
{"name":"test","id":...,"type":"DB"}
dbCreate :: Text -> ReQL Source
Create a database on the server
>>>
run' h $ dbCreate "dev"
{"config_changes":[{"new_val":{"name":"dev","id":...},"old_val":null}],"dbs_created":1}
dbDrop :: Database -> ReQL Source
Drop a database
>>>
run' h $ dbDrop (db "dev")
{"config_changes":[{"new_val":null,"old_val":{"name":"dev","id":...}}],"tables_dropped":0,"dbs_dropped":1}
indexCreate :: Expr fun => Text -> fun -> Table -> ReQL Source
Create an index on the table from the given function
>>>
run' h $ table "users" # indexCreate "occupation" (!"occupation")
{"created":1}>>>
run' h $ table "users" # ex indexCreate ["multi":=True] "friends" (!"friends")
{"created":1}>>>
run' h $ table "users" # ex indexCreate ["geo":=True] "location" (!"location")
{"created":1}
indexStatus :: Expr table => [ReQL] -> table -> ReQL Source
Get the status of the given indexes
run' h $ table "users" # indexStatus []
indexWait :: Expr table => [ReQL] -> table -> ReQL Source
Wait for an index to be built
run' h $ table "users" # indexWait []
sync :: Expr table => table -> ReQL Source
Ensures that writes on a given table are written to permanent storage
>>>
run' h $ sync (table "users")
{"synced":1}
indexList :: Table -> ReQL Source
List the indexes on the table
>>>
run' h $ indexList (table "users")
["friends","location","occupation"]
indexDrop :: Key -> Table -> ReQL Source
Drop an index
>>>
run' h $ table "users" # indexDrop "occupation"
{"dropped":1}
getAll :: Expr values => Index -> values -> Table -> ReQL Source
Retreive documents by their indexed value
>>>
run' h $ table "users" # getAll PrimaryKey [str "bill"]
[{"post_count":2,"name":"bill"}]
get :: Expr s => ReQL -> s -> ReQL Source
Get a document by primary key
>>>
run' h $ table "users" # get "nancy"
{"post_count":0,"name":"nancy"}
coerceTo :: Expr x => ReQL -> x -> ReQL Source
Convert a value to a different type
>>>
run h $ coerceTo "STRING" 1
"1"
asArray :: Expr x => x -> ReQL Source
Convert a value to an array
>>>
run h $ asArray $ ["a" := 1, "b" := 2] :: IO [(String, Int)]
[("a",1),("b",2)]
asString :: Expr x => x -> ReQL Source
Convert a value to a string
>>>
run h $ asString $ ["a" := 1, "b" := 2]
"{\"a\":1,\"b\":2}"
asObject :: Expr x => x -> ReQL Source
Convert a value to an object
>>>
run' h $ asObject $ [(str "a",1),("b",2)]
{"a":1,"b":2}
withFields :: Expr seq => [ReQL] -> seq -> ReQL Source
Like hasFields followed by pluck
>>>
run' h $ [["a" := 1, "b" := 2], ["a" := 2, "c" := 7], ["b" := 4]] # withFields ["a"]
[{"a":1},{"a":2}]
indexesOf :: (Expr fun, Expr seq) => fun -> seq -> ReQL Source
The position in the sequence of the elements that match the predicate
>>>
run h $ indexesOf (match "ba.") [str "foo", "bar", "baz"]
[1,2]
sample :: (Expr n, Expr seq) => n -> seq -> ReQL Source
Select a given number of elements from a sequence with uniform random distribution
>>>
_ <- run' h $ sample 3 [0,1,2,3,4,5,6,7,8,9]
prepend :: (Expr datum, Expr array) => datum -> array -> ReQL Source
Prepend an element to an array
>>>
run h $ prepend 1 [2,3]
[1,2,3]
difference :: (Expr a, Expr b) => a -> b -> ReQL Source
The different of two lists
>>>
run h $ [1,2,3,4,5] # difference [2,5]
[1,3,4]
setInsert :: (Expr datum, Expr array) => datum -> array -> ReQL Source
Insert a datum into an array if it is not yet present
>>>
run h $ setInsert 3 [1,2,4,4,5]
[1,2,4,5,3]
setUnion :: (Expr a, Expr b) => a -> b -> ReQL Source
The union of two sets
>>>
run h $ [1,2] `setUnion` [2,3]
[2,3,1]
setIntersection :: (Expr a, Expr b) => a -> b -> ReQL Source
The intersection of two sets
>>>
run h $ [1,2] `setIntersection` [2,3]
[2]
setDifference :: (Expr set, Expr remove) => remove -> set -> ReQL Source
The difference of two sets
>>>
run h $ [2,3] # setDifference [1,2]
[3]
hasFields :: Expr obj => ReQL -> obj -> ReQL Source
Test if an object has the given fields
>>>
run h $ hasFields "a" $ ["a" := 1]
true
insertAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL Source
Insert a datum at the given position in an array
>>>
run h $ insertAt 1 4 [1,2,3]
[1,4,2,3]
spliceAt :: (Expr n, Expr replace, Expr array) => n -> replace -> array -> ReQL Source
Splice an array at a given position inside another array
>>>
run h $ spliceAt 2 [4,5] [1,2,3]
[1,2,4,5,3]
deleteAt :: (Expr n, Expr array) => n -> array -> ReQL Source
Delete an element from an array
>>>
run h $ deleteAt 1 [1,2,3]
[1,3]
changeAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL Source
Change an element in an array
>>>
run h $ changeAt 1 4 [1,2,3]
[1,4,3]
keys :: Expr object => object -> ReQL Source
The list of keys of the given object
>>>
run h $ keys ["a" := 1, "b" := 2]
["a","b"]
match :: Expr string => ReQL -> string -> ReQL Source
Match a string to a regular expression.
>>>
run' h $ str "foobar" # match "f(.)+[bc](.+)"
{"groups":[{"start":2,"end":3,"str":"o"},{"start":4,"end":6,"str":"ar"}],"start":0,"end":6,"str":"foobar"}
apply :: (Expr fun, Expr arg) => fun -> [arg] -> ReQL Source
Apply a function to a list of arguments.
Called do in the official drivers
>>>
run h $ (\x -> x R.* 2) `apply` [4]
8
handle :: (Expr instead, Expr reql) => (ReQL -> instead) -> reql -> ReQL Source
Catch some expections inside the query.
Called default in the official drivers
>>>
run h $ R.handle (const 0) $ ["a" := 1] ! "b"
0>>>
run h $ R.handle (expr . id) $ ["a" := 1] ! "b"
"No attribute `b` in object:\n{\n\t\"a\":\t1\n}"
typeOf :: Expr a => a -> ReQL Source
A string representing the type of an expression
>>>
run h $ typeOf 1
"NUMBER"
info :: Expr a => a -> ReQL Source
Get information on a given expression. Useful for tables and databases.
>>>
run h $ info $ table "users"
{"primary_key":"name","doc_count_estimates":...,"name":"users","id":...,"indexes":["friends","location"],"type":"TABLE","db":{"name":"doctests","id":...,"type":"DB"}}
downcase :: Expr str => str -> ReQL Source
Convert to lower case
>>>
run h $ downcase (str "Foo")
"foo"
split :: Expr str => str -> ReQL Source
Split a string on whitespace characters
>>>
run' h $ split (str "foo bar")
["foo","bar"]
splitOn :: Expr str => ReQL -> str -> ReQL Source
Split a string on a given delimiter
>>>
run' h $ str "foo, bar" # splitOn ","
["foo"," bar"]
>>>
run' h $ str "foo" # splitOn ""
["f","o","o"]
splitMax :: Expr str => ReQL -> ReQL -> str -> ReQL Source
Split a string up to a given number of times
>>>
run' h $ str "a:b:c:d" # splitMax ":" 2
["a","b","c:d"]
A random float between 0 and 1
>>>
run' h $ (\x -> x R.< 1 R.&& x R.>= 0) `apply` [random]
true
randomTo :: ReQL -> ReQL Source
A random number between 0 and n
>>>
run' h $ (\x -> x R.< 10 R.&& x R.>= 0) `apply` [randomTo 10]
true
randomFromTo :: ReQL -> ReQL -> ReQL Source
A random number between 0 and n
>>>
run' h $ (\x -> x R.< 10 R.&& x R.>= 5) `apply` [randomFromTo 5 10]
true
data HttpOptions Source
HttpOptions | |
|
http :: Expr url => url -> HttpOptions -> ReQL Source
Retrieve data from the specified URL over HTTP
>>>
_ <- run' h $ http "http://httpbin.org/get" def{ httpParams = Just ["foo" := 1] }
>>>
_ <- run' h $ http "http://httpbin.org/put" def{ httpMethod = Just PUT, httpData = Just $ expr ["foo" := "bar"] }
changes :: Expr seq => seq -> ReQL Source
Return an infinite stream of objects representing changes to a table
>>>
cursor <- run h $ table "posts" # changes :: IO (Cursor Datum)
>>>
run h $ table "posts" # insert ["author" := "bill", "message" := "bye", "id" := 4] :: IO WriteResponse
{inserted:1}>>>
next cursor
Just {"new_val":{"author":"bill","id":4,"message":"bye"},"old_val":null}
returnChanges :: Attribute a Source
Optional argument for returning an array of objects describing the changes made
>>>
run h $ table "users" # ex insert [returnChanges] ["name" := "sabrina"] :: IO WriteResponse
{inserted:1,changes:[{"old_val":null,"new_val":{"name":"sabrina"}}]}
includeStates :: Attribute a Source
Optional argument for changes
durability :: Durability -> Attribute a Source
Optional argument for soft durability writes
nonAtomic :: Attribute a Source
Optional argument for non-atomic writes
>>>
run' h $ table "users" # get "sabrina" # update (merge ["lucky_number" := random])
*** Exception: RethinkDB: Runtime error: "Could not prove argument deterministic. Maybe you want to use the non_atomic flag?" in {- HERE -} update( get(table(db("doctests"), "users"), "sabrina"), (\b -> merge(b, {lucky_number: random()})))>>>
run h $ table "users" # get "sabrina" # ex update [nonAtomic] (merge ["lucky_number" := random]) :: IO WriteResponse
{replaced:1}
conflict :: ConflictResolution -> Attribute a Source
New in 1.16
Generate numbers starting from 0
>>>
run h $ range 10
[0,1,2,3,4,5,6,7,8,9]
rangeFromTo :: ReQL -> ReQL -> ReQL Source
Generate numbers within a range
>>>
run h $ rangeFromTo 2 4
[2,3]
wait :: Expr table => table -> ReQL Source
Wait for tables to be ready
>>>
run h $ table "users" # wait
{"ready":1}
toJSON :: Expr a => a -> ReQL Source
Convert an object or value to a JSON string
>>>
run h $ toJSON "a"
"\"a\""
zipWith :: (Expr left, Expr right, Expr b) => (ReQL -> ReQL -> b) -> left -> right -> ReQL Source
Map over two sequences
>>>
run h $ zipWith (+) [1,2] [3,4]
[4,6]
zipWithN :: (Arr a, Expr f) => f -> a -> ReQL Source
Map over multiple sequences
>>>
run' h $ zipWithN (\a b c -> expr $ a + b * c) [[1,2],[3,4],[5,6]]
[16,26]
reconfigure :: (Expr table, Expr replicas) => ReQL -> replicas -> table -> ReQL Source
Change a table's configuration
>>>
run h $ table "users" # reconfigure 2 1
{"config_changes":[{"new_val":{"primary_key":"name","write_acks":"majority","durability":"hard","name":"users","shards":...,"id":...,"db":"doctests"},"old_val":...}],"reconfigured":1,"status_changes":[{"new_val":{"status":{"all_replicas_ready":...,"ready_for_outdated_reads":...,"ready_for_writes":...,"ready_for_reads":...},"name":"users","shards":...,"id":...,"db":"doctests"},"old_val":...}]}
rebalance :: Expr table => table -> ReQL Source
Rebalance a table's shards
>>>
run h $ table "users" # rebalance
{"rebalanced":1,"status_changes":[{"new_val":{"status":{"all_replicas_ready":...,"ready_for_outdated_reads":...,"ready_for_writes":...,"ready_for_reads":...},"name":"users","shards":...,"id":...,"db":"doctests"},"old_val":...}]}