Safe Haskell | None |
---|---|
Language | Haskell2010 |
- data Handle
- defaultPort :: Int
- newHandle :: Text -> Int -> Maybe Text -> Exp Database -> IO Handle
- handleDatabase :: Handle -> Exp Database
- close :: Handle -> IO ()
- run :: FromResponse (Result a) => Handle -> Exp a -> IO (Res a)
- nextChunk :: FromResponse (Sequence a) => Handle -> Sequence a -> IO (Either Error (Sequence a))
- collect :: FromDatum a => Handle -> Sequence a -> IO (Either Error (Vector a))
- stop :: Handle -> Token -> IO ()
- wait :: Handle -> Token -> IO ()
- data Error
- = ProtocolError !Text
- | ClientError !Text
- | CompileError !Text
- | RuntimeError !Text
- data Datum
- type Array a = Vector a
- type Object = HashMap Text Datum
- class ToDatum a where
- class FromDatum a where
- parseDatum :: Datum -> Parser a
- (.=) :: ToDatum a => Text -> a -> (Text, Datum)
- (.:) :: FromDatum a => HashMap Text Datum -> Text -> Parser a
- (.:?) :: FromDatum a => HashMap Text Datum -> Text -> Parser (Maybe a)
- object :: [(Text, Datum)] -> Datum
- data Exp a where
- 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 (Array Datum)
- OrderByIndexed :: IsSequence s => Order -> Exp s -> Exp (Array Datum)
- 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
- data SomeExp where
- data Bound
- data Order
- = Ascending !Text
- | Descending !Text
- data Sequence a
- data Table
- data Database
- data SingleSelection
- type Res a = Either Error (Result a)
- type family Result a
- class FromResponse a
- data ConflictResolutionStrategy
- emptyOptions :: Object
- lift :: Lift c e => e -> c (Simplified e)
- call1 :: (Exp a -> Exp r) -> Exp a -> Exp r
- call2 :: (Exp a -> Exp b -> Exp r) -> Exp a -> Exp b -> Exp r
- class IsDatum a
- class IsDatum a => IsObject a
- class IsSequence a
Documentation
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
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'.
wait :: Handle -> Token -> IO () Source
Wait until a previous query (which was started with the noreply
option)
finishes.
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
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 |
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 |
Types which can be converted to or from a Datum
.
ToDatum Bool | |
ToDatum Char | |
ToDatum Double | |
ToDatum Float | |
ToDatum Int | |
ToDatum () | |
ToDatum Text | |
ToDatum UTCTime | |
ToDatum Value | |
ToDatum ZonedTime | |
ToDatum Object | |
ToDatum Datum | |
ToDatum ConflictResolutionStrategy | |
ToDatum [Char] | |
ToDatum a => ToDatum [a] | |
ToDatum a => ToDatum (Maybe a) | |
ToDatum a => ToDatum (Array a) | |
(ToDatum a, ToDatum b) => ToDatum (a, b) | |
(ToDatum a, ToDatum b, ToDatum c) => ToDatum (a, b, c) |
class FromDatum a where Source
parseDatum :: Datum -> Parser a Source
FromDatum Bool | |
FromDatum Char | |
FromDatum Double | |
FromDatum Float | |
FromDatum Int | |
FromDatum () | |
FromDatum Text | |
FromDatum UTCTime | |
FromDatum Value | |
FromDatum ZonedTime | |
FromDatum Object | |
FromDatum Datum | |
FromDatum [Char] | |
FromDatum a => FromDatum [a] | |
FromDatum a => FromDatum (Maybe a) | |
FromDatum a => FromDatum (Array a) | |
FromDatum a => FromDatum (Sequence a) | |
(FromDatum a, FromDatum b) => FromDatum (a, b) | |
(FromDatum a, FromDatum b, FromDatum c) => FromDatum (a, b, c) |
Because the arguments to functions are polymorphic (the individual arguments can, and often have, different types).
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
.
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 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)
The type of result you get when executing a query of 'Exp a'.
type Result Bool = Bool | |
type Result Char = Char | |
type Result Double = Double | |
type Result Int = Int | |
type Result String = String | |
type Result Text = Text | |
type Result ZonedTime = ZonedTime | |
type Result Object = Object | |
type Result Datum = Datum | |
type Result SingleSelection = Maybe Datum | |
type Result Table = Sequence Datum | |
type Result (Array a) = Array a | |
type Result (Sequence a) = Sequence 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.
parseResponse
data ConflictResolutionStrategy Source
ConflictResolutionStrategy
How conflicts should be resolved.
call2 :: (Exp a -> Exp b -> Exp r) -> Exp a -> Exp b -> Exp r Source
Call an binary function with the given arguments.
IsDatum Bool | For a boolean type, we're reusing the standard Haskell |
IsDatum Double | Numbers are |
IsDatum Text | For strings, we're using the Haskell |
IsDatum UTCTime | |
IsDatum ZonedTime | Time in RethinkDB is represented similar to the |
IsDatum Object | |
IsDatum Datum | |
IsDatum SingleSelection | |
IsDatum a => IsDatum (Array a) | Arrays are vectors of |
class IsSequence a Source
IsSequence Table | |
IsDatum a => IsSequence (Array a) | |
IsSequence (Sequence a) |