| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Database.RethinkDB
- data Handle
- defaultPort :: Int
- newHandle :: Text -> Int -> Maybe Text -> Exp Database -> IO Handle
- handleDatabase :: Handle -> Exp Database
- close :: Handle -> IO ()
- serverInfo :: Handle -> IO (Either Error ServerInfo)
- 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))
- start :: Handle -> Exp a -> IO Token
- continue :: Handle -> Token -> IO ()
- stop :: Handle -> Token -> IO ()
- wait :: Handle -> Token -> IO ()
- nextResult :: FromResponse a => Handle -> Token -> IO (Either Error a)
- type Token = Word64
- data Error
- = ProtocolError !Text
- | ClientError !Text
- | CompileError !Text
- | RuntimeError !Text
- data Response = Response {
- responseToken :: !Token
- responseType :: !ResponseType
- responseResult :: !(Vector Value)
- responseNotes :: !(Set ResponseNote)
- data ChangeNotification = ChangeNotification {
- cnOldValue :: !Datum
- cnNewValue :: !Datum
- data Datum
- type Array a = Vector a
- type Object = HashMap Text Datum
- class ToDatum a where
- class FromDatum a where
- (.=) :: 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 s
- OrderByIndexed :: IsSequence s => Order -> Exp s -> Exp s
- 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
- SequenceChanges :: IsSequence s => Exp s -> Exp (Sequence ChangeNotification)
- SingleSelectionChanges :: IsDatum a => Exp a -> Exp (Sequence ChangeNotification)
- 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.
High-level query API
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 there 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'.
Low-level query API
start :: Handle -> Exp a -> IO Token Source #
Start a new query. Returns the Token which can be used to track its
progress.
continue :: Handle -> Token -> IO () Source #
Let the server know that it can send the next response corresponding to the given token.
wait :: Handle -> Token -> IO () Source #
Wait until a previous query (which was started with the noreply option)
finishes.
nextResult :: FromResponse a => Handle -> Token -> IO (Either Error a) Source #
A token is used to refer to queries and the corresponding responses. This driver uses a monotonically increasing counter.
Errors include a plain-text description which includes further details. The RethinkDB protocol also includes a backtrace which we currently don't parse.
Constructors
| 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. |
Constructors
| Response | |
Fields
| |
data ChangeNotification Source #
Constructors
| ChangeNotification | |
Fields
| |
Instances
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.
Constructors
| Null | |
| Bool !Bool | |
| Number !Double | |
| String !Text | |
| Array !(Array Datum) | |
| Object !Object | |
| Time !ZonedTime |
Instances
| Eq Datum Source # | We can't automatically derive |
| Show Datum Source # | |
| Generic Datum Source # | |
| ToJSON Datum Source # | |
| FromJSON Datum Source # | |
| FromDatum Object Source # | |
| FromDatum Datum Source # | |
| ToDatum Object Source # | |
| ToDatum Datum Source # | |
| FromResponse Object Source # | |
| FromResponse Datum Source # | |
| IsObject Object Source # | |
| IsDatum Object Source # | |
| IsDatum Datum Source # | |
| FromResponse (Maybe Datum) Source # | |
| type Rep Datum Source # | |
| type Result Object Source # | |
| type Result Datum Source # | |
class ToDatum a where Source #
Types which can be converted to or from a Datum.
Minimal complete definition
Instances
| ToDatum Bool Source # | |
| ToDatum Char Source # | |
| ToDatum Double Source # | |
| ToDatum Float Source # | |
| ToDatum Int Source # | |
| ToDatum () Source # | |
| ToDatum Text Source # | |
| ToDatum UTCTime Source # | |
| ToDatum Value Source # | |
| ToDatum ZonedTime Source # | |
| ToDatum Object Source # | |
| ToDatum Datum Source # | |
| ToDatum ConflictResolutionStrategy Source # | |
| ToDatum [Char] Source # | |
| ToDatum a => ToDatum [a] Source # | |
| ToDatum a => ToDatum (Maybe a) Source # | |
| ToDatum a => ToDatum (Array a) Source # | |
| (ToDatum a, ToDatum b) => ToDatum (a, b) Source # | |
| (ToDatum a, ToDatum b, ToDatum c) => ToDatum (a, b, c) Source # | |
class FromDatum a where Source #
Minimal complete definition
Methods
parseDatum :: Datum -> Parser a Source #
Instances
| FromDatum Bool Source # | |
| FromDatum Char Source # | |
| FromDatum Double Source # | |
| FromDatum Float Source # | |
| FromDatum Int Source # | |
| FromDatum () Source # | |
| FromDatum Text Source # | |
| FromDatum UTCTime Source # | |
| FromDatum Value Source # | |
| FromDatum ZonedTime Source # | |
| FromDatum Object Source # | |
| FromDatum Datum Source # | |
| FromDatum ChangeNotification Source # | |
| FromDatum [Char] Source # | |
| FromDatum a => FromDatum [a] Source # | |
| FromDatum a => FromDatum (Maybe a) Source # | |
| FromDatum a => FromDatum (Array a) Source # | |
| FromDatum a => FromDatum (Sequence a) Source # | |
| (FromDatum a, FromDatum b) => FromDatum (a, b) Source # | |
| (FromDatum a, FromDatum b, FromDatum c) => FromDatum (a, b, c) Source # | |
Constructors
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.
Instances
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'.
Instances
| type Result Bool Source # | |
| type Result Char Source # | |
| type Result Double Source # | |
| type Result Int Source # | |
| type Result String Source # | |
| type Result Text Source # | |
| type Result ZonedTime Source # | |
| type Result Object Source # | |
| type Result Datum Source # | |
| type Result SingleSelection Source # | |
| type Result Table Source # | |
| type Result (Array a) Source # | |
| type Result (Sequence a) Source # | |
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.
Minimal complete definition
parseResponse
Instances
data ConflictResolutionStrategy Source #
ConflictResolutionStrategy
How conflicts should be resolved.
Constructors
| CRError | Do not insert the new document and record the conflict as an error. This is the default. |
| CRReplace | Replace the old document in its entirety with the new one. |
| CRUpdate | Update fields of the old document with fields from the new one. |
Instances
call2 :: (Exp a -> Exp b -> Exp r) -> Exp a -> Exp b -> Exp r Source #
Call an binary function with the given arguments.
Instances
| IsDatum Bool Source # | For a boolean type, we're reusing the standard Haskell |
| IsDatum Double Source # | Numbers are |
| IsDatum Text Source # | For strings, we're using the Haskell |
| IsDatum UTCTime Source # | |
| IsDatum ZonedTime Source # | Time in RethinkDB is represented similar to the |
| IsDatum Object Source # | |
| IsDatum Datum Source # | |
| IsDatum SingleSelection Source # | |
| IsDatum a => IsDatum (Array a) Source # | Arrays are vectors of |
class IsSequence a Source #
Instances
| IsSequence Table Source # | |
| IsDatum a => IsSequence (Array a) Source # | |
| IsSequence (Sequence a) Source # | |