| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Database.RethinkDB
Synopsis
- 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
- 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
- Lt :: (IsDatum a, IsDatum b) => Exp a -> Exp b -> Exp Bool
- Le :: (IsDatum a, IsDatum b) => Exp a -> Exp b -> Exp Bool
- Gt :: (IsDatum a, IsDatum b) => Exp a -> Exp b -> Exp Bool
- Ge :: (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 #
The default port where RethinkDB accepts client driver connections.
newHandle :: Text -> Int -> Maybe Text -> Exp Database -> IO Handle #
Create a new handle to the RethinkDB server.
handleDatabase :: Handle -> Exp Database #
High-level query API
run :: FromResponse (Result a) => Handle -> Exp a -> IO (Res a) #
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)) #
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)) #
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 #
Start a new query. Returns the Token which can be used to track its
progress.
continue :: Handle -> Token -> IO () #
Let the server know that it can send the next response corresponding to the given token.
wait :: Handle -> Token -> IO () #
Wait until a previous query (which was started with the noreply option)
finishes.
nextResult :: FromResponse a => Handle -> Token -> IO (Either Error a) #
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 #
Constructors
| ChangeNotification | |
Fields
| |
Instances
| Show ChangeNotification # | |
Defined in Database.RethinkDB.Types Methods showsPrec :: Int -> ChangeNotification -> ShowS # show :: ChangeNotification -> String # showList :: [ChangeNotification] -> ShowS # | |
| FromDatum ChangeNotification # | |
Defined in Database.RethinkDB.Types Methods parseDatum :: Datum -> Parser ChangeNotification # | |
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
Types which can be converted to or from a Datum.
Instances
Methods
parseDatum :: Datum -> Parser a #
Instances
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.
Instances
| Show (Sequence a) # | |
| FromDatum a => FromDatum (Sequence a) # | |
Defined in Database.RethinkDB.Types Methods parseDatum :: Datum -> Parser (Sequence a) # | |
| FromDatum a => FromResponse (Sequence a) # | |
Defined in Database.RethinkDB.Types Methods parseResponse :: Response -> Parser (Sequence a) | |
| IsSequence (Sequence a) # | |
Defined in Database.RethinkDB.Types | |
| type Result (Sequence a) # | |
Defined in Database.RethinkDB.Types | |
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.
Instances
| IsSequence Table # | |
Defined in Database.RethinkDB.Types | |
| type Result Table # | |
Defined in Database.RethinkDB.Types | |
data SingleSelection #
SingleSelection is essentially a 'Maybe Object', where Nothing is
represented with Null in the network protocol.
Instances
| Show SingleSelection # | |
Defined in Database.RethinkDB.Types Methods showsPrec :: Int -> SingleSelection -> ShowS # show :: SingleSelection -> String # showList :: [SingleSelection] -> ShowS # | |
| IsObject SingleSelection # | |
Defined in Database.RethinkDB.Types | |
| IsDatum SingleSelection # | |
Defined in Database.RethinkDB.Types | |
| type Result SingleSelection # | |
Defined in Database.RethinkDB.Types | |
type Res a = Either Error (Result a) #
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 # | |
Defined in Database.RethinkDB.Types | |
| type Result Char # | |
Defined in Database.RethinkDB.Types | |
| type Result Double # | |
Defined in Database.RethinkDB.Types | |
| type Result Int # | |
Defined in Database.RethinkDB.Types | |
| type Result Text # | |
Defined in Database.RethinkDB.Types | |
| type Result String # | |
Defined in Database.RethinkDB.Types | |
| type Result ZonedTime # | |
Defined in Database.RethinkDB.Types | |
| type Result Object # | |
Defined in Database.RethinkDB.Types | |
| type Result Datum # | |
Defined in Database.RethinkDB.Types | |
| type Result SingleSelection # | |
Defined in Database.RethinkDB.Types | |
| type Result Table # | |
Defined in Database.RethinkDB.Types | |
| type Result (Array a) # | |
Defined in Database.RethinkDB.Types | |
| type Result (Sequence a) # | |
Defined in Database.RethinkDB.Types | |
class FromResponse a #
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 #
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
| ToDatum ConflictResolutionStrategy # | |
Defined in Database.RethinkDB.Types Methods | |
emptyOptions :: Object #
call2 :: (Exp a -> Exp b -> Exp r) -> Exp a -> Exp b -> Exp r #
Call an binary function with the given arguments.
Instances
| IsDatum Bool # | For a boolean type, we're reusing the standard Haskell |
Defined in Database.RethinkDB.Types | |
| IsDatum Double # | Numbers are |
Defined in Database.RethinkDB.Types | |
| IsDatum Text # | For strings, we're using the Haskell |
Defined in Database.RethinkDB.Types | |
| IsDatum UTCTime # | |
Defined in Database.RethinkDB.Types | |
| IsDatum ZonedTime # | Time in RethinkDB is represented similar to the |
Defined in Database.RethinkDB.Types | |
| IsDatum Object # | |
Defined in Database.RethinkDB.Types | |
| IsDatum Datum # | |
Defined in Database.RethinkDB.Types | |
| IsDatum SingleSelection # | |
Defined in Database.RethinkDB.Types | |
| IsDatum a => IsDatum (Array a) # | Arrays are vectors of |
Defined in Database.RethinkDB.Types | |
class IsDatum a => IsObject a #
Instances
| IsObject UTCTime # | |
Defined in Database.RethinkDB.Types | |
| IsObject ZonedTime # | |
Defined in Database.RethinkDB.Types | |
| IsObject Object # | |
Defined in Database.RethinkDB.Types | |
| IsObject SingleSelection # | |
Defined in Database.RethinkDB.Types | |
class IsSequence a #
Instances
| IsSequence Table # | |
Defined in Database.RethinkDB.Types | |
| IsDatum a => IsSequence (Array a) # | |
Defined in Database.RethinkDB.Types | |
| IsSequence (Sequence a) # | |
Defined in Database.RethinkDB.Types | |