diff --git a/Database/RethinkDB.hs b/Database/RethinkDB.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB.hs
@@ -0,0 +1,100 @@
+
+-- | RethinkDB client library for Haskell
+--
+-- Modelled upon the official Javascript and Python API:
+--
+-- /How to use/
+--
+-- >>> import Database.RethinkDB
+-- >>> import qualified Database.RethinkDB.Functions as R
+
+module Database.RethinkDB (
+
+ -- * Accessing RethinkDB
+
+ RethinkDBHandle,
+ openConnection,
+ closeConnection,
+ use,
+ run, runMaybe, runEither, runRaw, runJSON, runBatch,
+ next, collect, resultsError,
+
+ -- * Manipulating databases
+
+ Database(..),
+ db, dbCreate, dbDrop, dbList,
+
+ -- * Manipulating Tables
+
+ Table(..), tablePrimaryAttr, TableCreateOptions(..),
+ table, tableCreate, tableDrop, tableList,
+
+ -- * Writing data
+
+ Document(..),
+ insert, insertMany, upsert, upsertMany,
+ update, replace, delete,
+
+ -- * Selecting data
+
+ get, filter', between,
+
+ -- * Joins
+
+ innerJoin, outerJoin, eqJoin, zip',
+
+ -- * Transformations
+
+ map', concatMap', orderBy, skip, limit,
+ slice, nth, pluck, without, union',
+
+ -- * Aggregation
+
+ reduce, count, distinct, groupedMapReduce, groupBy',
+
+ -- * Reductions
+
+ count', sum', avg,
+
+ -- * Document manipulation
+
+ pick, unpick, merge, append, (!), (!?),
+
+ -- * Operators
+
+ concat,
+ add, sub, mul, div', mod, and', or',
+ eq, ne, gt, ge, lt, le, not',
+
+ -- * Control structures
+
+ bind, let', var, if', forEach, error', js, jsfun,
+
+ -- * Sequence conversion
+
+ streamToArray, arrayToStream, asArray,
+
+ -- * Short constructors
+
+ Obj, Attribute(..), obj, str, nil,
+
+ -- * Types and type classes
+
+ Query, ToQuery(..),
+ ValueTypeKind(..), ExprTypeKind(..),
+ ExprIsView, ExprValueType, Expr(..), ToExpr(..), ToValue(..),
+ HasValueType, HaveValueType,
+ NumberExpr, BoolExpr, ObjectExpr, ArrayExpr, StringExpr, ValueExpr,
+ NumberStream, BoolStream, ObjectStream, ArrayStream, StringStream, Selection,
+ CanCompare,
+ Order(..), ToOrder(..),
+ Sequence(..),
+ Mapping(..), ToMapping(..),
+ Results
+ ) where
+
+import Prelude ()
+
+import Database.RethinkDB.Types
+import Database.RethinkDB.Driver
+import Database.RethinkDB.Functions
diff --git a/Database/RethinkDB/Driver.hs b/Database/RethinkDB/Driver.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Driver.hs
@@ -0,0 +1,1224 @@
+{-# LANGUAGE OverloadedStrings, KindSignatures, DataKinds, MultiParamTypeClasses,
+ TypeFamilies, ExistentialQuantification, FlexibleInstances,
+ ConstraintKinds, FlexibleContexts, UndecidableInstances,
+ PolyKinds, FunctionalDependencies, GADTs, ScopedTypeVariables,
+ RankNTypes, RecordWildCards #-}
+
+-- | The core of the haskell client library for RethinkDB
+
+module Database.RethinkDB.Driver where
+
+import {-# SOURCE #-} Database.RethinkDB.Functions
+import Database.RethinkDB.Types
+
+import Control.Arrow
+import Data.Aeson.Types (parseMaybe)
+import Data.String
+import Data.Typeable
+import Data.Data
+import GHC.Prim
+
+import qualified Database.RethinkDB.Internal.Types as QL
+import qualified Database.RethinkDB.Internal.Query_Language.Response as QLResponse
+import qualified Database.RethinkDB.Internal.Query_Language.Query as QLQuery
+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as QLVarTermTuple
+import qualified Database.RethinkDB.Internal.Query_Language.Predicate as QLPredicate
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as QLBuiltin
+import qualified Database.RethinkDB.Internal.Query_Language.ReadQuery as QLReadQuery
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as QLWriteQuery
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as QLMapping
+import qualified Database.RethinkDB.Internal.Query_Language.Term as QL (type')
+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable as QLCreateTable
+
+import Text.ProtocolBuffers.Basic hiding (Default)
+import Text.ProtocolBuffers.WireMessage
+
+import System.IO (Handle, hClose)
+import Network
+
+import Data.List
+import Control.Monad.State as S
+import qualified Data.HashMap.Strict as HM
+import Data.Default
+import qualified Data.Attoparsec.Lazy as Attoparsec
+import Data.Foldable (toList)
+import qualified Data.Text as T
+import Data.Aeson
+import qualified Data.Aeson.Parser (value)
+import qualified Data.Sequence as Seq
+import Data.Monoid
+import Data.Maybe
+import Data.ByteString.Lazy (pack, unpack, hPut, hGet)
+import qualified Data.ByteString.Lazy as B
+import Data.IORef
+import Data.Bits
+
+-- * Network
+
+-- | A connection to the database server
+data RethinkDBHandle = RethinkDBHandle {
+ rdbHandle :: Handle,
+ rdbToken :: IORef Int64, -- ^ The next token to use
+ rdbDatabase :: Database -- ^ When no database is specified, this one will be used
+ }
+
+-- | Create a new connection to the database server
+--
+-- /Example:/ connect using the default port (28015) and specifying the
+-- default database for all queries.
+--
+-- >>> h <- openConnection "localhost" Nothing (Just "test")
+
+openConnection :: HostName -> Maybe PortID -> Maybe String -> IO RethinkDBHandle
+openConnection host port mdb = do
+ h <- connectTo host (fromMaybe (PortNumber 28015) port)
+ hPut h initialMessage
+ r <- newIORef 1
+ -- db' <- maybe (fmap head $ run (RethinkDBHandle h r (Database "")) $ dbList) (return . Database) mdb
+ let db' = Database $ fromMaybe "" mdb
+ return (RethinkDBHandle h r db')
+ where initialMessage = packUInt 0xaf61ba35
+
+-- | Set the default connection
+--
+-- The new handle is an alias for the old one. Calling closeConnection on either one
+-- will close both.
+--
+-- >>> let h' = h `use` (db "players")
+
+use :: RethinkDBHandle -> Database -> RethinkDBHandle
+use h db' = h { rdbDatabase = db' }
+
+-- | Close an open connection
+--
+-- >>> closeConnection h
+
+closeConnection :: RethinkDBHandle -> IO ()
+closeConnection (RethinkDBHandle h _ _) = hClose h
+
+-- | Receive a fixed amoutn of data
+recvAll :: RethinkDBHandle -> Int -> IO ByteString
+recvAll (RethinkDBHandle h _ _) n = hGet h n
+
+-- | Send a bytestring
+sendAll :: RethinkDBHandle -> ByteString -> IO ()
+sendAll (RethinkDBHandle h _ _) s = hPut h s
+
+-- | Get a request token and increment the token counter
+getNewToken :: RethinkDBHandle -> IO Int64
+getNewToken (RethinkDBHandle _ r _) = atomicModifyIORef r $ \t -> (t + 1, t)
+
+data ErrorCode = ErrorBrokenClient
+ | ErrorBadQuery
+ | ErrorRuntime
+ | ErrorNetwork
+
+instance Show ErrorCode where
+ show ErrorBrokenClient = "broken client error"
+ show ErrorBadQuery = "malformed query error"
+ show ErrorRuntime = "runtime error"
+ show ErrorNetwork = "error talking to server"
+
+data SuccessCode = SuccessEmpty
+ | SuccessJson
+ | SuccessPartial
+ | SuccessStream
+ deriving Show
+
+-- | The raw response to a query
+data Response = ErrorResponse {
+ errorCode :: ErrorCode,
+ errorMessage :: String,
+ errorBacktrace :: [String]
+ } | SuccessResponse {
+ successCode :: SuccessCode,
+ successString :: [B.ByteString]
+ }
+
+instance Show Response where
+ show ErrorResponse {..} = show errorCode ++ ": " ++
+ show errorMessage ++ " (" ++
+ showBacktrace errorBacktrace ++ ")"
+ show SuccessResponse {..} = show successCode ++ ": " ++ show successString
+
+convertResponse :: Either String QL.Response -> Response
+convertResponse (Left s) = ErrorResponse ErrorNetwork s []
+convertResponse (Right QL.Response {..}) = case status_code of
+ QL.SUCCESS_EMPTY -> SuccessResponse SuccessEmpty r
+ QL.SUCCESS_JSON -> SuccessResponse SuccessJson r
+ QL.SUCCESS_PARTIAL -> SuccessResponse SuccessPartial r
+ QL.SUCCESS_STREAM -> SuccessResponse SuccessStream r
+ QL.BROKEN_CLIENT -> ErrorResponse ErrorBrokenClient e bt
+ QL.BAD_QUERY -> ErrorResponse ErrorBadQuery e bt
+ QL.RUNTIME_ERROR -> ErrorResponse ErrorRuntime e bt
+ where bt = fromMaybe [] $ fmap (map uToString . toList . QL.frame) backtrace
+ r = map utf8 $ toList response
+ e = fromMaybe "error" $ fmap uToString error_message
+
+showBacktrace :: [String] -> String
+showBacktrace [] = "query"
+showBacktrace bt = ("in " ++ ) . concat . (++ [" query"]) .
+ intersperse " " . map f . reverse $ bt
+ where f x = x ++ " in"
+
+-- | Execute a raw protobuffer query and return the raw response
+runQLQuery :: RethinkDBHandle -> QL.Query -> IO Response
+runQLQuery h query = do
+ let queryS = messagePut query
+ sendAll h $ packUInt (fromIntegral $ B.length queryS) <> queryS
+ fmap convertResponse $ readResponse (QLQuery.token query)
+
+ where readResponse t = do
+ header <- recvAll h 4
+ responseS <- recvAll h (unpackUInt header)
+ let eResponse = messageGet responseS
+ case eResponse of
+ Left errMsg -> return $ Left errMsg
+ Right (response, rest)
+ | B.null rest ->
+ (case QLResponse.token response of
+ n | n == t -> return $ Right response
+ | n > t -> return $ Left "RethinkDB: runQLQuery: invalid response token"
+ | otherwise -> readResponse t)
+ | otherwise -> return $ Left "RethinkDB: runQLQuery: invalid reply length"
+
+-- * CRUD
+
+-- | A database, referenced by name
+data Database = Database {
+ databaseName :: String
+ } deriving (Eq, Ord)
+
+instance Show Database where
+ show (Database d) = show d
+
+-- | Create a Database reference
+db :: String -> Database
+db s = Database s
+
+-- | Create a database on the server
+dbCreate :: String -> Query False Database
+dbCreate db_name = Query
+ (metaQuery $ return $ QL.MetaQuery QL.CREATE_DB (Just $ uFromString db_name) Nothing Nothing)
+ (const $ Right $ Database db_name)
+
+-- | Drop a database
+dbDrop :: Database -> Query False ()
+dbDrop (Database name) = Query
+ (metaQuery $ return $ QL.MetaQuery QL.DROP_DB (Just $ uFromString name) Nothing Nothing)
+ (const $ Right ())
+
+-- | List the databases on the server
+--
+-- >>> run h $ dbList
+-- [test, dev, prod]
+
+dbList :: Query False [Database]
+dbList = Query
+ (metaQuery $ return $ QL.MetaQuery QL.LIST_DBS Nothing Nothing Nothing)
+ (maybe (Left "error") Right . sequence . map (fmap Database . convert))
+
+-- | Options used to create a table
+data TableCreateOptions = TableCreateOptions {
+ tableDataCenter :: Maybe String,
+ tableCacheSize :: Maybe Int64
+ }
+
+instance Default TableCreateOptions where
+ def = TableCreateOptions Nothing Nothing
+
+-- | A table description
+data Table = Table {
+ tableDatabase :: Maybe Database, -- ^ when Nothing, use the rdbDatabase
+ tableName :: String,
+ _tablePrimaryAttr :: Maybe String -- ^ when Nothing, "id" is used
+ } deriving (Eq, Ord)
+
+instance Show Table where
+ show (Table db' nam pa) =
+ maybe "" (\(Database d) -> d++".") db' ++ nam ++ maybe "" (\x -> "{"++x++"}") pa
+
+tablePrimaryAttr :: Table -> String
+tablePrimaryAttr = fromMaybe (uToString defaultPrimaryAttr) . _tablePrimaryAttr
+
+-- | "id"
+defaultPrimaryAttr :: Utf8
+defaultPrimaryAttr = uFromString "id"
+
+-- | Create a simple table refence with no associated database or primary key
+--
+-- >>> table "music"
+--
+-- Another way to create table references is to use the Table constructor:
+--
+-- >>> Table (Just "mydatabase") "music" (Just "tuneid")
+
+table :: String -> Table
+table n = Table Nothing n Nothing
+
+-- | Create a table on the server
+--
+-- @def@ can be imported from Data.Default
+--
+-- >>> t <- run h $ tableCreate (table "fruits") def
+
+tableCreate :: Table -> TableCreateOptions -> Query False Table
+tableCreate (Table mdb table_name primary_key)
+ (TableCreateOptions datacenter cache_size) = Query
+ (metaQuery $ do
+ curdb <- activeDB
+ let create = defaultValue {
+ QLCreateTable.datacenter = fmap uFromString datacenter,
+ QLCreateTable.table_ref = QL.TableRef (uFromString $ databaseName $ fromMaybe curdb mdb)
+ (uFromString table_name) Nothing,
+ QLCreateTable.primary_key = fmap uFromString primary_key,
+ QLCreateTable.cache_size = cache_size
+ }
+ return $ QL.MetaQuery QL.CREATE_TABLE Nothing (Just create) Nothing)
+ (const $ Right $ Table mdb table_name primary_key)
+
+-- | Drop a table
+tableDrop :: Table -> Query False ()
+tableDrop tbl = Query
+ (metaQuery $ do
+ ref <- tableRef tbl
+ return $ QL.MetaQuery QL.DROP_TABLE Nothing Nothing $ Just $ ref)
+ (const $ Right ())
+
+-- | List the tables in a database
+tableList :: Database -> Query False [Table]
+tableList (Database name) = Query
+ (metaQuery $ return $
+ QL.MetaQuery QL.LIST_TABLES (Just $ uFromString name) Nothing Nothing)
+ (maybe (Left "error") Right . sequence .
+ map (fmap (\x -> Table (Just (Database name)) x Nothing) . convert))
+
+-- | Get the primary key of the table as a Utf8, or "id" if there is none
+uTableKey :: Table -> Utf8
+uTableKey (Table _ _ mkey) = fromMaybe defaultPrimaryAttr $ fmap uFromString mkey
+
+-- | A reference to a document
+data Document = Document {
+ documentTable :: Table,
+ documentKey :: Value
+ } deriving (Eq)
+
+instance Show Document where
+ show (Document t k) = show t ++ "[" ++ show k ++ "]"
+
+-- | Get a document by primary key
+get :: (ToExpr e, ExprType e ~ StreamType True ObjectType, ToValue k) =>
+ e -> k -> ObjectExpr
+get e k = Expr $ do
+ (vw, _) <- exprV e
+ let tbl@(Table _ _ mattr) = viewTable vw
+ ref <- tableRef tbl
+ key <- value k
+ withView NoView $ return defaultValue {
+ QL.type' = QL.GETBYKEY,
+ QL.get_by_key = Just $ QL.GetByKey ref (fromMaybe defaultPrimaryAttr $
+ fmap uFromString mattr) key
+ }
+
+insert_or_upsert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>
+ Table -> [a] -> Bool -> WriteQuery [Document]
+insert_or_upsert tbl array overwrite = WriteQuery
+ (do ref <- tableRef tbl
+ as <- mapM value array
+ let write = defaultValue {
+ QLWriteQuery.type' = QL.INSERT,
+ QL.insert = Just $ QL.Insert ref
+ (Seq.fromList $ as) (Just overwrite) }
+ return $ write)
+ (whenSuccess "generated_keys" $ \keys -> Right $ map (\doc -> Document tbl doc) keys)
+
+-- | Insert a document into a table
+--
+-- >>> d <- run h $ insert t (object ["name" .= "banana", "color" .= "red"])
+
+insert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>
+ Table -> a -> WriteQuery Document
+insert tb a = fmap head $ insert_or_upsert tb [a] False
+
+-- | Insert many documents into a table
+insertMany :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>
+ Table -> [a] -> WriteQuery [Document]
+insertMany tb a = insert_or_upsert tb a False
+
+-- | Insert a document into a table, overwriting a document with the
+-- same primary key if one exists.
+
+upsert :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>
+ Table -> a -> WriteQuery Document
+upsert tb a = fmap head $ insert_or_upsert tb [a] True
+
+-- | Insert many documents into a table, overwriting any existing documents
+-- with the same primary key.
+upsertMany :: (ToValue a, ToValueType (ExprType a) ~ ObjectType) =>
+ Table -> [a] -> WriteQuery [Document]
+upsertMany tb a = insert_or_upsert tb a True
+
+-- | Update a table
+--
+-- >>> t <- run h $ tableCreate (table "example") def
+-- >>> run h $ insertMany t [object ["a" .= 1, "b" .= 11], object ["a" .= 2, "b" .= 12]]
+-- >>> run h $ update t (object ["b" .= 20])
+-- >>> run h $ t
+
+update :: (ToExpr sel, ExprType sel ~ StreamType True out, ToMapping map,
+ MappingFrom map ~ out, MappingTo map ~ ObjectType) =>
+ sel -> map -> WriteQuery ()
+update view m = WriteQuery
+ (do mT <- mapping m
+ write <- case toExpr view of
+ Expr _ -> do viewT <- expr view
+ return defaultValue {
+ QLWriteQuery.type' = QL.UPDATE,
+ QL.update = Just $ QL.Update viewT mT }
+ SpotExpr (Document tbl@(Table _ _ k) d) -> do
+ ref <- tableRef tbl
+ return $ defaultValue {
+ QLWriteQuery.type' = QL.POINTUPDATE,
+ QL.point_update = Just $ QL.PointUpdate ref
+ (fromMaybe defaultPrimaryAttr $ fmap uFromString k)
+ (toJsonTerm d) mT }
+ return write)
+ (whenSuccess_ ())
+
+-- | Replace documents in a table
+replace :: (ToExpr sel, ExprIsView sel ~ True, ToJSON a) => sel -> a -> WriteQuery ()
+replace view a = WriteQuery
+ (do fun <- mapping (toJSON a)
+ write <- case toExpr view of
+ Expr f -> do
+ (_, e) <- f
+ return defaultValue {
+ QLWriteQuery.type' = QL.MUTATE,
+ QL.mutate = Just $ QL.Mutate e fun }
+ SpotExpr (Document tbl@(Table _ _ k) d) -> do
+ ref <- tableRef tbl
+ return defaultValue {
+ QLWriteQuery.type' = QL.POINTMUTATE,
+ QL.point_mutate = Just $ QL.PointMutate ref
+ (fromMaybe defaultPrimaryAttr $ fmap uFromString k)
+ (toJsonTerm d) fun }
+ return write)
+ (whenSuccess_ ())
+
+-- | Delete one or more documents from a table
+delete :: (ToExpr sel, ExprIsView sel ~ True) => sel -> WriteQuery ()
+delete view = WriteQuery
+ (do write <- case toExpr view of
+ Expr f -> do
+ (_, ex) <- f
+ return defaultValue {
+ QLWriteQuery.type' = QL.DELETE,
+ QL.delete = Just $ QL.Delete ex }
+ SpotExpr (Document tbl@(Table _ _ k) d) -> do
+ ref <- tableRef tbl
+ return defaultValue {
+ QLWriteQuery.type' = QL.POINTDELETE,
+ QL.point_delete = Just $ QL.PointDelete ref
+ (fromMaybe defaultPrimaryAttr $ fmap uFromString k)
+ (toJsonTerm d) }
+ return write)
+ (whenSuccess_ ())
+
+-- * Queries
+
+-- | A query returning a
+data Query (b :: Bool) a where
+ Query :: { _queryBuild :: QueryM QL.Query,
+ _queryExtract :: [Value] -> Either String a } -> Query False a
+ ViewQuery :: { _viewQueryBuild :: QueryM (Table, QL.Query),
+ _viewQueryExtract :: [(Document, Value)] -> Either String a }
+ -> Query True a
+
+data WriteQuery a = WriteQuery {
+ writeQueryBuild :: QueryM QL.WriteQuery,
+ writeQueryExtract :: [Value] -> Either String a
+ }
+
+queryBuild :: Query w a -> QueryM (MaybeView w, QL.Query)
+queryBuild (Query b _) = fmap ((,) NoView) b
+queryBuild (ViewQuery b _) = fmap (first ViewOf) b
+
+queryExtract :: Query w a -> MaybeView w -> [Value] -> Either String a
+queryExtract (Query _ e) _ vs = e vs
+queryExtract (ViewQuery _ e) (ViewOf tbl) vs = e =<< mapM (addDoc tbl) vs
+queryExtract _ _ _ = error "GHC was right, this branch is reachable!"
+
+instance Functor (Query w) where
+ fmap f (Query a g) = Query a (fmap f . g)
+ fmap f (ViewQuery a g) = ViewQuery a (fmap f . g)
+
+instance Functor WriteQuery where
+ fmap f (WriteQuery a g) = WriteQuery a (fmap f . g)
+
+
+type family If (p :: Bool) (a :: k) (b :: k) :: k
+type instance If True a b = a
+type instance If False a b = b
+
+
+-- | Convert things like tables and documents into queries
+class ToBuildQuery a where
+ type BuildViewQuery a :: Bool
+ buildQuery :: a -> ([If (BuildViewQuery a)
+ (Document, Value) Value]
+ -> Either String b) -> Query (BuildViewQuery a) b
+
+class ToBuildQuery a => ToQuery a b | a -> b where
+ toQuery :: a -> Query (BuildViewQuery a) b
+
+instance ToBuildQuery (Query w a) where
+ type BuildViewQuery (Query w a) = w
+ buildQuery (Query b _) = Query b
+ buildQuery (ViewQuery b _) = ViewQuery b
+
+instance ToQuery (Query w a) a where
+ toQuery q = q
+
+instance ToBuildQuery (WriteQuery a) where
+ type BuildViewQuery (WriteQuery a) = False
+ buildQuery (WriteQuery b _) = Query $ do
+ wq <- b
+ tok <- getToken
+ return $ defaultValue { QLQuery.type' = QL.WRITE, QLQuery.token = tok,
+ QLQuery.write_query = Just $ wq }
+
+instance ToQuery (WriteQuery a) a where
+ toQuery w@(WriteQuery _ e) = buildQuery w e
+
+instance ToBuildQuery Table where
+ type BuildViewQuery Table = True
+ buildQuery = buildQuery . toExpr
+
+instance FromJSON a => ToQuery Table [(Document, a)] where
+ toQuery tbl = buildQuery tbl $
+ (maybe (Left "wrong response type") Right . mapMSnd convert)
+
+mapMSnd :: Monad m => (a -> m b) -> [(c,a)] -> m [(c,b)]
+mapMSnd f = mapM $ \(a,b) -> liftM ((,) a) (f b)
+
+instance ToBuildQuery Document where
+ type BuildViewQuery Document = True
+ buildQuery = buildQuery . toExpr
+
+instance FromJSON a => ToQuery Document a where
+ toQuery doc = buildQuery doc $
+ maybe (Left "empty response") Right . ((convert . snd) <=< listToMaybe)
+
+data Proxy t = Proxy
+
+instance ToBuildQuery (Expr (StreamType False v)) where
+ type BuildViewQuery (Expr (StreamType False v)) = False
+ buildQuery = Query . fmap snd . exprToQLQuery
+
+instance ExtractValue v a => ToQuery (Expr (StreamType False v)) [a] where
+ toQuery e = buildQuery e $
+ maybe (Left "cannot convert response") Right
+ . extractListOf (Proxy :: Proxy v)
+
+instance ToBuildQuery (Expr (StreamType True v)) where
+ type BuildViewQuery (Expr (StreamType True v)) = True
+ buildQuery = ViewQuery . fmap (first viewTable) . exprToQLQuery
+
+instance ExtractValue v a => ToQuery (Expr (StreamType True v)) [(Document, a)] where
+ toQuery e = exprViewQuery (maybe (Left "cannot convert response") Right . extract) e
+ where extract = extractListOf (Proxy :: Proxy v)
+
+instance ToBuildQuery (Expr (ValueType v)) where
+ type BuildViewQuery (Expr (ValueType v)) = False
+ buildQuery = Query . fmap snd . exprToQLQuery
+
+instance ExtractValue v a => ToQuery (Expr (ValueType v)) a where
+ toQuery e = buildQuery e $
+ maybe (Left "empty response")
+ (maybe (Left "cannot convert response") Right .
+ extractValue (Proxy :: Proxy v))
+ . listToMaybe
+
+exprToQLQuery :: Expr t -> QueryM (MaybeView (ExprTypeIsView t), QL.Query)
+exprToQLQuery e = do
+ token <- getToken
+ (vw, ex) <- exprV e
+ return $ (,) vw $ QL.Query QL.READ token (
+ Just $ defaultValue { QLReadQuery.term = ex }) Nothing Nothing
+
+exprViewQuery :: (ExprTypeIsView t ~ True) =>
+ ([Value] -> Either String [a]) -> Expr t -> Query True [(Document, a)]
+exprViewQuery c e = flip ViewQuery (\x -> fmap (zip $ map fst x) (c (map snd x))) $ do
+ token <- getToken
+ (ViewOf tbl, ex) <- exprV e
+ return $ (,) tbl $ QL.Query QL.READ token (
+ Just $ defaultValue { QLReadQuery.term = ex }) Nothing Nothing
+
+extractListOf :: ExtractValue t a => Proxy t -> [Value] -> Maybe [a]
+extractListOf p = sequence . map (extractValue p)
+
+class ExtractValue t v | t -> v where
+ extractValue :: Proxy t -> Value -> Maybe v
+
+instance (Num a, FromJSON a) => ExtractValue NumberType a where extractValue _ = convert
+instance ExtractValue BoolType Bool where extractValue _ = convert
+instance FromJSON a => ExtractValue ObjectType a where extractValue _ = convert
+instance FromJSON a => ExtractValue ArrayType a where extractValue _ = convert
+instance (IsString a, FromJSON a) => ExtractValue StringType a where extractValue _ = convert
+instance ExtractValue NoneType () where extractValue _ = const $ Just ()
+instance FromJSON a => ExtractValue OtherValueType a where extractValue _ = convert
+
+-- | Run a query on the connection
+--
+-- The return value depends on the type of the second argument.
+--
+-- When the return value is polymorphic, type annotations may be required.
+--
+-- >>> run h $ table "fruits" :: IO [(Document, Value)]
+
+run :: ToQuery a v => RethinkDBHandle -> a -> IO v
+run h q = do
+ r <- runEither h q
+ case r of
+ Left e -> error e
+ Right a -> return a
+
+-- | Run a query on the connection, returning (Left message) on error
+runEither :: ToQuery a v => RethinkDBHandle -> a -> IO (Either String v)
+runEither h q = case toQuery q of
+ -- TODO: just call runBatch and get the resultsSeq
+ query -> do
+ tok <- getNewToken h
+ let ((vw, qlq), _) = runQueryM (queryBuild query) $
+ QuerySettings tok (rdbDatabase h) initialVars False
+ r <- runQLQuery h qlq
+ return $ case r of
+ ErrorResponse {} -> Left (show r)
+ SuccessResponse _ strs -> queryExtract query vw =<<
+ (maybe (Left "decode error") Right . sequence . map decodeAny $ strs)
+
+addDoc :: Table -> Value -> Either String (Document, Value)
+addDoc tbl x = do
+ id' <- maybe (Left "missign primary key") Right $ getKey (tablePrimaryAttr tbl) x
+ return (Document tbl id', x)
+ where getKey k (Object o) = parseMaybe (.: str k) o
+ getKey _ _ = Nothing
+
+-- | Run a query on the connection, returning Nothing on error
+runMaybe :: ToQuery a v => RethinkDBHandle -> a -> IO (Maybe v)
+runMaybe h = fmap (either (const Nothing) Just) . runEither h
+
+-- | Run a query on the connection and return the raw response
+runRaw :: (ToBuildQuery q, JSONQuery (BuildViewQuery q)) =>
+ RethinkDBHandle -> q -> IO Response
+runRaw h q = do
+ tok <- getNewToken h
+ let ((_, qlq), _) = runQueryM (queryBuild (jsonQuery (buildQuery q))) $
+ QuerySettings tok (rdbDatabase h) initialVars False
+ runQLQuery h qlq
+
+-- | Run a query on the connection and return the resulting JSON value
+runJSON :: (JSONQuery (BuildViewQuery q), ToBuildQuery q) =>
+ RethinkDBHandle -> q -> IO [Value]
+runJSON h q = run h (jsonQuery (buildQuery q))
+
+class JSONQuery (b :: Bool) where
+ jsonQuery :: (forall a . ([If b (Document, Value) Value] -> Either String a) -> Query b a)
+ -> Query b [Value]
+
+instance JSONQuery False where
+ jsonQuery f = f Right
+
+instance JSONQuery True where
+ jsonQuery f = f (Right . map snd)
+
+data Results a = Results {
+ resultsHandle :: IORef (Maybe (RethinkDBHandle, Int64)),
+ resultsSeq :: IORef (Seq.Seq a),
+ _resultsError :: IORef (Maybe String),
+ resultsQueryView :: QueryViewPair [a]
+ }
+
+data QueryViewPair a where
+ QueryViewPair :: Query w a -> MaybeView w -> QueryViewPair a
+
+-- | Run a query on the connection and a return a lazy result list
+--
+-- >>> res <- runBatch h <- (arrayToStream [1,2,3] :: NumberStream)
+-- >>> next res
+-- Just 1
+-- >>> collect res
+-- [2,3]
+
+runBatch :: ToQuery q [a] => RethinkDBHandle -> q -> IO (Results a)
+runBatch h q = case toQuery q of
+ query -> do
+ tok <- getNewToken h
+ let ((vw, qlq), _) = runQueryM (queryBuild query) $
+ QuerySettings tok (rdbDatabase h) initialVars False
+ r <- runQLQuery h qlq
+ let (han, seq', err) = queryExtractResponse query vw r h tok
+ refHan <- newIORef han
+ refSeq <- newIORef seq'
+ refErr <- newIORef err
+ return $ Results refHan refSeq refErr (QueryViewPair query vw)
+
+queryExtractResponse ::
+ Query w [a] -> MaybeView w -> Response -> RethinkDBHandle -> Int64
+ -> (Maybe (RethinkDBHandle, Int64), Seq a, Maybe String)
+queryExtractResponse query vw r h tok =
+ case r of
+ ErrorResponse {} -> (Nothing, Seq.fromList [], Just $ show r)
+ SuccessResponse typ strs ->
+ let rList = queryExtract query vw =<<
+ (maybe (Left "decode error") Right . sequence . map decodeAny $ strs)
+ in case rList of
+ Left err -> (Nothing, Seq.fromList [], Just err)
+ Right list ->
+ let han = case typ of
+ SuccessPartial -> Just (h, tok)
+ SuccessStream -> Nothing
+ SuccessJson -> Nothing
+ SuccessEmpty -> Nothing
+ in (han, Seq.fromList list, Nothing)
+
+-- | Read the next value from a lazy query. Fetch it from the server if needed.
+next :: Results a -> IO (Maybe a)
+next res = do
+ seq' <- readIORef (resultsSeq res)
+ case Seq.viewl seq' of
+ car Seq.:< cdr -> do
+ writeIORef (resultsSeq res) cdr
+ return (Just car)
+ Seq.EmptyL -> do
+ mh <- readIORef (resultsHandle res)
+ case (mh, resultsQueryView res) of
+ (Nothing, _) -> return Nothing
+ (Just (h, tok), (QueryViewPair query vw)) -> do
+ resp <- runQLQuery h $ defaultValue {
+ QLQuery.type' = QL.CONTINUE, QLQuery.token = tok }
+ let (han, seq'', err) = queryExtractResponse query vw resp h tok
+ writeIORef (resultsHandle res) han
+ modifyIORef (resultsSeq res) (<> seq'')
+ writeIORef (_resultsError res) err
+ next res
+
+-- | Return all the results of a lazy query.
+collect :: Results a -> IO [a]
+collect r = do
+ ma <- next r
+ case ma of
+ Nothing -> return []
+ Just a -> fmap (a:) (collect r)
+
+-- | Get the last error from a lazy query.
+--
+-- If both next and resultsError return Nothing, then
+-- all results have been fetched without error.
+
+resultsError :: Results a -> IO (Maybe String)
+resultsError = readIORef . _resultsError
+
+-- * Expressions
+
+-- | Can the Expr be written to? (updated or deleted)
+type family ExprTypeIsView (expr :: ExprTypeKind) :: Bool
+type instance ExprTypeIsView (StreamType w o) = w
+type instance ExprTypeIsView (ValueType v) = False
+
+type ExprIsView e = ExprTypeIsView (ExprType e)
+
+type family ExprTypeNoView (t :: ExprTypeKind) :: ExprTypeKind
+type instance ExprTypeNoView (StreamType b t) = StreamType False t
+type instance ExprTypeNoView (ValueType t) = ValueType t
+
+-- | The type of the value of an Expr
+type family ExprValueType expr :: ValueTypeKind
+type instance ExprValueType (Expr (ValueType v)) = v
+type instance ExprValueType (Expr (StreamType w v)) = v
+
+-- | The type of the stream of an Expr
+type family ExprTypeStreamType (t :: ExprTypeKind) :: ValueTypeKind
+type instance ExprTypeStreamType (StreamType w t) = t
+
+-- | An RQL expression
+data Expr (t :: ExprTypeKind) where
+ Expr :: QueryM (MaybeView (ExprIsView (Expr t)), QL.Term) -> Expr t
+ SpotExpr :: Document -> Expr (StreamType True ObjectType)
+
+mkExpr :: ExprIsView (Expr t) ~ False => QueryM QL.Term -> Expr t
+mkExpr q = Expr $ fmap ((,) NoView) q
+
+mkView :: ExprIsView (Expr t) ~ True => Table -> QueryM QL.Term -> Expr t
+mkView t q = Expr $ fmap ((,) (ViewOf t)) q
+
+viewKeyAttr :: MaybeView b -> Utf8
+viewKeyAttr v = fromMaybe defaultPrimaryAttr $ fmap uFromString $
+ case v of
+ ViewOf (Table _ _ k) -> k
+ NoView -> Nothing
+
+viewTable :: MaybeView True -> Table
+viewTable v = case v of ViewOf t -> t
+
+data MaybeView (w :: Bool) where
+ NoView :: MaybeView False
+ ViewOf :: Table -> MaybeView True
+
+-- | Convert something into an Expr
+class ToExpr (o :: *) where
+ type ExprType o :: ExprTypeKind
+ toExpr :: o -> Expr (ExprType o)
+
+-- | The result type of toValue
+type family ToValueType (t :: ExprTypeKind) :: ValueTypeKind
+type instance ToValueType (StreamType w t) = ArrayType
+type instance ToValueType (ValueType t) = t
+
+-- | Convert something into a value Expr
+class ToValue e where
+ toValue :: e -> Expr (ValueType (ToValueType (ExprType e)))
+
+type family FromMaybe (a :: k) (m :: Maybe k) :: k
+type instance FromMaybe a Nothing = a
+type instance FromMaybe a (Just b) = b
+
+type HasToStreamValueOf a b = FromMaybe a (ToStreamValue b) ~ a
+
+type ToStreamValue e = ToStreamTypeValue (ExprType e)
+
+type family ToStreamTypeValue (t :: ExprTypeKind) :: Maybe ValueTypeKind
+type instance ToStreamTypeValue (StreamType w t) = Just t
+type instance ToStreamTypeValue (ValueType t) = Nothing
+
+class ToExpr e => ToStream e where
+ toStream :: e -> Expr (StreamType (ExprIsView e) (FromMaybe a (ToStreamValue e)))
+
+instance ToExpr Document where
+ type ExprType Document = StreamType True 'ObjectType
+ toExpr doc = SpotExpr doc
+
+instance ToValue Document where
+ toValue = streamToArray
+
+instance ToStream Document where
+ toStream = toExpr
+
+instance ToExpr Table where
+ type ExprType Table = StreamType True ObjectType
+ toExpr tbl = mkView tbl $ do
+ ref <- tableRef tbl
+ return defaultValue {
+ QL.type' = QL.TABLE,
+ QL.table = Just $ QL.Table ref }
+
+instance ToValue Table where
+ toValue = streamToArray
+
+instance ToStream Table where
+ toStream = toExpr
+
+instance ToExpr (Expr t) where
+ type ExprType (Expr t) = t
+ toExpr e = e
+
+instance ToValue (Expr (ValueType t)) where
+ toValue e = e
+
+instance ToValue (Expr (StreamType w t)) where
+ toValue = streamToArray
+
+instance ToStream (Expr (ValueType ArrayType)) where
+ toStream = arrayToStream
+
+instance ToStream (Expr (StreamType w t)) where
+ toStream e = e
+
+instance ToExpr Int where
+ type ExprType Int = ValueType NumberType
+ toExpr n = mkExpr $ return $ defaultValue {
+ QL.type' = QL.NUMBER, QL.number = Just $ fromIntegral n }
+
+instance ToValue Int where
+ toValue = toExpr
+
+instance ToExpr Integer where
+ type ExprType Integer = ValueType NumberType
+ toExpr n = mkExpr $ return $ defaultValue {
+ QL.type' = QL.NUMBER, QL.number = Just $ fromInteger n }
+
+instance ToValue Integer where
+ toValue = toExpr
+
+instance ToExpr Double where
+ type ExprType Double = ValueType NumberType
+ toExpr n = mkExpr $ return $ defaultValue {
+ QL.type' = QL.NUMBER, QL.number = Just n }
+
+instance ToValue Double where
+ toValue = toExpr
+
+instance ToExpr Char where
+ type ExprType Char = ValueType StringType
+ toExpr c = mkExpr $ return defaultValue {
+ QL.type' = QL.STRING, QL.valuestring = Just $ uFromString [c] }
+
+instance ToExpr T.Text where
+ type ExprType T.Text = ValueType StringType
+ toExpr s = mkExpr $ return defaultValue {
+ QL.type' = QL.STRING, QL.valuestring = Just $ uFromString (T.unpack s) }
+
+instance ToValue T.Text where
+ toValue = toExpr
+
+str :: String -> T.Text
+str = T.pack
+
+instance ToExpr a => ToExpr [a] where
+ type ExprType [a] = ValueType ArrayType
+ toExpr l = mkExpr $ do
+ exs <- sequence $ map (expr . toExpr) l
+ return defaultValue {
+ QL.type' = QL.ARRAY, QL.array = Seq.fromList exs }
+
+instance ToExpr a => ToValue [a] where
+ toValue = toExpr
+
+instance ToExpr a => ToStream [a] where
+ toStream = arrayToStream . toExpr
+
+instance ToExpr () where
+ type ExprType () = ValueType NoneType
+ toExpr () = mkExpr $ return $ defaultValue { QL.type' = QL.JSON_NULL }
+
+instance ToValue () where
+ toValue = toExpr
+
+instance ToExpr Obj where
+ type ExprType Obj = ValueType ObjectType
+ toExpr (Obj o) = mkExpr $ do
+ exs <- sequence $ map go o
+ return defaultValue {
+ QL.type' = QL.OBJECT, QL.object = Seq.fromList exs }
+ where go (k := a) = do
+ ex <- value a
+ return QL.VarTermTuple {
+ QLVarTermTuple.var = uFromString k, QLVarTermTuple.term = ex }
+
+instance ToValue Obj where
+ toValue = toExpr
+
+-- | Aliases for type constraints on expressions
+type HasValueType a v = (ToValue a, ToValueType (ExprType a) ~ v)
+type HaveValueType a b v = (HasValueType a v, HasValueType b v)
+
+-- | Simple aliases for different Expr types
+type NumberExpr = Expr (ValueType NumberType)
+type BoolExpr = Expr (ValueType BoolType)
+type ObjectExpr = Expr (ValueType ObjectType)
+type ArrayExpr = Expr (ValueType ArrayType)
+type StringExpr = Expr (ValueType StringType)
+type ValueExpr t = Expr (ValueType t)
+type NumberStream = Expr (StreamType False NumberType)
+type BoolStream = Expr (StreamType False BoolType)
+type ArrayStream = Expr (StreamType False ArrayType)
+type StringStream = Expr (StreamType False StringType)
+type ObjectStream = Expr (StreamType False ObjectType)
+type Selection = Expr (StreamType True ObjectType)
+
+-- | What values can be compared with eq, ne, lt, gt, le and ge
+class CanCompare (a :: ValueTypeKind)
+instance CanCompare NumberType
+instance CanCompare StringType
+
+instance Num (Expr (ValueType NumberType)) where
+ (+) = add
+ (-) = sub
+ (*) = mul
+ abs = jsfun "abs"
+ signum = signum'
+ fromInteger = toExpr
+
+instance Fractional (Expr (ValueType NumberType)) where
+ fromRational n = toExpr (fromRational n :: Double)
+ (/) = div'
+
+-- | A sequence is either a stream or an array
+class Sequence (e :: ExprTypeKind) where
+ type SequenceType e (t :: ValueTypeKind) :: Constraint
+
+instance Sequence (StreamType w t) where
+ type SequenceType (StreamType w t) tt = t ~ tt
+
+instance a ~ ArrayType => Sequence (ValueType a) where
+ type SequenceType (ValueType a) t = ()
+
+-- | A list of String/Expr pairs
+data Obj = Obj [Attribute]
+data Attribute = forall e . (ToValue e) => String := e
+
+-- | Build an Obj
+obj :: [Attribute] -> Obj
+obj = Obj
+
+-- | Convert a stream into an array
+
+streamToArray :: (ToExpr e, ExprType e ~ StreamType w t) => e -> Expr (ValueType ArrayType)
+streamToArray = simpleOp QL.STREAMTOARRAY . return . expr
+
+-- | Convert an array into a stream
+arrayToStream :: (ToExpr e, ExprType e ~ ValueType ArrayType) => e -> Expr (StreamType False t)
+arrayToStream = simpleOp QL.ARRAYTOSTREAM . return . expr
+
+-- * Mappings
+
+-- | A mapping is a like single-parameter function
+data Mapping (from :: ValueTypeKind) (to :: ValueTypeKind) =
+ Mapping (QueryM QL.Mapping)
+
+-- | Convert objects into mappings
+class ToMapping map where
+ type MappingFrom map :: ValueTypeKind
+ type MappingTo map :: ValueTypeKind
+ toMapping :: map -> Mapping (MappingFrom map) (MappingTo map)
+
+instance ToMapping Obj where
+ type MappingFrom Obj = ObjectType
+ type MappingTo Obj = ObjectType
+ toMapping v = Mapping $ do
+ ex <- expr v
+ return $ defaultValue { QLMapping.body = ex }
+
+instance ToMapping Value where
+ type MappingFrom Value = ObjectType
+ type MappingTo Value = ObjectType
+ toMapping v = Mapping $ return $ defaultValue { QLMapping.body = toJsonTerm v }
+
+instance (ToValue b, a ~ Expr (ValueType t)) => ToMapping (a -> b) where
+ type MappingFrom (a -> b) = ExprValueType a
+ type MappingTo (a -> b) = ToValueType (ExprType b)
+ toMapping f = Mapping $ do
+ v <- newVar
+ ex <- value (f (var v))
+ return $ defaultValue {
+ QLMapping.arg = uFromString v,
+ QLMapping.body = ex }
+
+instance ToMapping (Expr (ValueType t)) where
+ type MappingFrom (Expr (ValueType t)) = ObjectType
+ type MappingTo (Expr (ValueType t)) = t
+ toMapping e = Mapping $ do
+ ex <- expr e
+ return defaultValue { QLMapping.body = ex }
+
+-- * QueryM Monad
+
+data QuerySettings = QuerySettings {
+ _queryToken :: Int64,
+ _queryDB :: Database,
+ _queryVars :: [String],
+ _queryUseOutdated :: Bool
+ }
+
+instance Default QuerySettings where
+ def = QuerySettings 0 (db "") initialVars False
+
+type QueryM = State QuerySettings
+
+runQueryM :: QueryM a -> QuerySettings -> (a, QuerySettings)
+runQueryM = runState
+
+initialVars :: [String]
+initialVars = concat $ zipWith (\n as -> map (++ (if n == 0 then "" else show n)) as)
+ [0 :: Int ..] (map (map return) $ repeat ['a'..'z'])
+
+getToken :: QueryM Int64
+getToken = fmap _queryToken S.get
+
+activeDB :: QueryM Database
+activeDB = fmap _queryDB S.get
+
+newVar :: QueryM String
+newVar = state $ \s -> let (x:xs) = _queryVars s in (x, s { _queryVars = xs} )
+
+setUseOutdated :: ToExpr e => Bool -> e -> Expr (ExprType e)
+setUseOutdated b e = Expr $ do
+ state $ \s -> runQueryM (exprV e) s { _queryUseOutdated = b }
+
+-- * Utilities
+
+-- | Convert a protobuf Mapping into a Predicate
+mappingToPredicate :: QL.Mapping -> QL.Predicate
+mappingToPredicate (QL.Mapping arg body _1) = defaultValue {
+ QLPredicate.arg = arg,
+ QLPredicate.body = body
+ }
+
+-- | Convert a table to a raw protobuf term
+tableToTerm :: Table -> QueryM QL.Term
+tableToTerm tbl = do
+ ref <- tableRef tbl
+ return $ defaultValue {
+ QL.type' = QL.TABLE,
+ QL.table = Just $ QL.Table ref }
+
+-- | Convert into a raw protobuf mapping
+mapping :: ToMapping m => m -> QueryM QL.Mapping
+mapping m = case toMapping m of Mapping f -> f
+
+-- | Convert an Expr to a term
+expr :: ToExpr e => e -> QueryM QL.Term
+expr = fmap snd . exprV
+
+exprV :: ToExpr e => e -> QueryM (MaybeView (ExprIsView e), QL.Term)
+exprV e = case toExpr e of
+ Expr f -> f
+ SpotExpr (Document tbl@(Table _ _ mkey) d) -> do
+ ref <- tableRef tbl
+ return $ ((,) (ViewOf tbl)) defaultValue {
+ QL.type' = QL.GETBYKEY,
+ QL.get_by_key = Just $ QL.GetByKey ref
+ (fromMaybe defaultPrimaryAttr $ fmap uFromString mkey)
+ (toJsonTerm d) }
+
+-- | Convert a stream to a term
+stream :: ToStream a => a -> QueryM QL.Term
+stream = expr . toStream
+
+-- | Convert a value to a term
+value :: ToValue a => a -> QueryM QL.Term
+value = expr . toValue
+
+-- | build a raw protobuf Term
+toJsonTerm :: ToJSON a => a -> QL.Term
+toJsonTerm a = defaultValue {
+ QL.type' = QL.JSON,
+ QL.jsonstring = Just $ Utf8 (encode a)
+ }
+
+-- | Test if a field is present in a json Value and return it
+(.?) :: FromJSON a => Value -> String -> Maybe a
+(.?) (Object h) k = toMaybe . fromJSON =<< HM.lookup (T.pack k) h
+ where toMaybe (Success a) = Just a
+ toMaybe _ = Nothing
+(.?) _ _ = Nothing
+
+-- | Helper function to handle responses to a query
+whenSuccess :: FromJSON a => String -> (a -> Either String b) -> [Value] -> Either String b
+whenSuccess key f response = do
+ info <- maybe (Left "invalid response") Right (convert =<< listToMaybe response)
+ if info .? "errors" /= Just (0 :: Int)
+ then maybe (Left "unknown error") Left $ info .? "first_error"
+ else fromMaybe (Left "key missing in response") (fmap f (info .? key))
+
+-- | same as whenSuccess, but ignore the response when there is no error
+whenSuccess_ :: b -> [Value] -> Either String b
+whenSuccess_ b response = do
+ info <- maybe (Left "invalid response") Right (convert =<< listToMaybe response)
+ if info .? "errors" /= Just (0 :: Int)
+ then maybe (Left "unknown error") Left $ info .? "first_error"
+ else Right b
+
+-- | Like aeson's decode, but but works on numbers and strings, not only objects and arrays
+decodeAny :: FromJSON a => ByteString -> Maybe a
+decodeAny s =
+ case Attoparsec.parse Data.Aeson.Parser.value s of
+ Attoparsec.Done _ v -> convert v
+ _ -> Nothing
+
+-- | Convert a JSON Value into another type
+convert :: FromJSON a => Value -> Maybe a
+convert v = case fromJSON v of
+ Success a -> Just a
+ _ -> Nothing
+
+-- | Extract the error message from a Response if there is an error
+-- | Help build meta queries
+metaQuery :: QueryM QL.MetaQuery -> QueryM QL.Query
+metaQuery q = do
+ t <- getToken
+ mq <- q
+ return $ QL.Query QL.META t Nothing Nothing $ Just mq
+
+-- | Convert an int to a 4-byte bytestring
+packUInt :: Int -> ByteString
+packUInt n = pack $ map fromIntegral $
+ [n `mod` 256, (n `shiftR` 8) `mod` 256,
+ (n `shiftR` 16) `mod` 256, (n `shiftR` 24) `mod` 256]
+
+-- | Convert a 4-bte byestring to an int
+unpackUInt :: ByteString -> Int
+unpackUInt s = case unpack s of
+ [a,b,c,d] -> fromIntegral a .|.
+ fromIntegral b `shiftL` 8 .|.
+ fromIntegral c `shiftL` 16 .|.
+ fromIntegral d `shiftL` 24
+ _ -> error "unpackUInt: lengh is not 4"
+
+op :: QL.BuiltinType -> QLBuiltin.Builtin
+op o = defaultValue { QLBuiltin.type' = o }
+
+apply :: QL.Builtin -> [QueryM QL.Term] -> QueryM QL.Term
+apply o args = do
+ a <- sequence args
+ return $ defaultValue { QL.type' = QL.CALL, QL.call = Just $ QL.Call o (Seq.fromList a) }
+
+rapply :: [QueryM QL.Term] -> QL.Builtin -> QueryM QL.Term
+rapply = flip apply
+
+simpleOp :: ExprIsView (Expr t) ~ False => QL.BuiltinType -> [QueryM QL.Term] -> Expr t
+simpleOp o a = mkExpr $ apply (op o) a
+
+withView :: MaybeView b -> QueryM QL.Term -> QueryM (MaybeView b, QL.Term)
+withView v = fmap ((,) v)
+
+primaryAttr :: (ToExpr e, ExprTypeIsView (ExprType e) ~ True) =>
+ e -> String -> Expr (ExprType e)
+primaryAttr e a = Expr $ do
+ (ViewOf (Table mdb name _), ex) <- exprV e
+ return (ViewOf (Table mdb name (Just a)), ex)
+
+comparison :: ExprTypeIsView t ~ False => QL.Comparison -> [QueryM QL.Term] -> Expr t
+comparison o a = mkExpr $ rapply a (op QL.COMPARE) { QL.comparison = Just o }
+
+-- | Build a protobuf TableRef object
+tableRef :: Table -> QueryM QL.TableRef
+tableRef (Table mdb tb _) = do
+ curdb <- activeDB
+ useOutdated <- fmap _queryUseOutdated S.get
+ return $ QL.TableRef (uFromString $ databaseName $ fromMaybe curdb mdb)
+ (uFromString tb) (Just useOutdated)
+
+extractTerm :: ToExpr e => e -> QL.Term
+extractTerm e = fst $ runQueryM (expr e) def
+
+dumpExpr :: ToExpr e => e -> String
+dumpExpr = dumpTermPart "" . extractTerm
+
+dumpTermPart :: Data a => String -> a -> String
+dumpTermPart p a = case dataTypeName (dataTypeOf a) of
+ name | "Database.RethinkDB.Internal" `isPrefixOf` name ->
+ showConstr (toConstr a) ++ maybeFields a
+ | ".Utf8" `isSuffixOf` name ->
+ show (uToString (fromJust $ cast a))
+ | ".Double" `isSuffixOf` name ->
+ show (fromJust $ cast a :: Double)
+ | ".Seq" `isSuffixOf` name -> dumpSeq a
+ | otherwise -> dataTypeName (dataTypeOf a) -- showConstr (toConstr a)
+ where fieldValues t = gmapQ maybeDump t
+ fields t = catMaybes $ zipWith (\x y -> fmap ((x ++ ": ") ++) y)
+ (constrFields (toConstr t)) (fieldValues t)
+ maybeFields t = let f = fields t in if null f then ""
+ else " {\n" ++ p ++ concat (intersperse (",\n"++p) f) ++ " }"
+ maybeDump :: Data a => a -> Maybe String
+ maybeDump t = case showConstr (toConstr t) of
+ "Nothing" -> Nothing
+ "Just" -> Just $ head (gmapQ (dumpTermPart (p ++ " ")) t)
+ "empty" -> Nothing -- empty Seq
+ "ExtField" -> Nothing
+ _ -> Just $ dumpTermPart (p ++ " ") t
+ dumpSeq t = let elems :: Data a => a -> [String]
+ elems tt = case showConstr (toConstr tt) of
+ "empty" -> []
+ _ -> gmapQi 0 (dumpTermPart (p ++ " ")) tt : gmapQi 1 elems tt
+ in "[" ++ concat (intersperse ", " $ elems t) ++ "]"
diff --git a/Database/RethinkDB/Driver.hs-boot b/Database/RethinkDB/Driver.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Driver.hs-boot
@@ -0,0 +1,13 @@
+{-# LANGUAGE TypeFamilies, ConstraintKinds, DataKinds #-}
+module Database.RethinkDB.Driver where
+import Database.RethinkDB.Types
+class ToExpr a
+class ToValue e
+type family ExprType a :: ExprTypeKind
+type family ToValueType (t :: ExprTypeKind) :: ValueTypeKind
+type HasValueType a v = (ToValue a, ToValueType (ExprType a) ~ v)
+type HaveValueType a b v = (HasValueType a v, HasValueType b v)
+data Expr (a :: ExprTypeKind)
+type NumberExpr = Expr (ValueType NumberType)
+type family ExprTypeIsView (expr :: ExprTypeKind) :: Bool
+type ExprIsView e = ExprTypeIsView (ExprType e)
diff --git a/Database/RethinkDB/Functions.hs b/Database/RethinkDB/Functions.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Functions.hs
@@ -0,0 +1,437 @@
+{-# LANGUAGE DataKinds, TypeFamilies, ConstraintKinds, FlexibleInstances,
+ FlexibleContexts, TypeOperators, ViewPatterns #-}
+
+-- | Functions from the ReQL (RethinkDB Query Language)
+
+module Database.RethinkDB.Functions where
+
+import Database.RethinkDB.Types
+import Database.RethinkDB.Driver
+
+import Text.ProtocolBuffers.Basic hiding (Default)
+import qualified Database.RethinkDB.Internal.Types as QL
+import qualified Database.RethinkDB.Internal.Query_Language.Term as QLTerm
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as QLWriteQuery
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as QLBuiltin
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy as QLOrderBy
+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as QLReduction
+
+import qualified Prelude as P
+import Prelude (Bool(..), ($), Maybe(..), Int, String, flip, undefined, return, (.), mapM)
+
+import Control.Monad (liftM)
+import Data.Maybe
+import Data.Functor
+import Data.Aeson
+import qualified Data.Sequence as Seq
+
+-- * Numbers, Booleans and Comparisons
+
+signum, signum' :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr
+signum x = bind x (\n -> if' (n `lt` (0 :: NumberExpr)) (-1 :: Int)
+ (if' (n `lt` (0 :: NumberExpr)) (1 :: Int) (0 :: Int)))
+signum' = signum
+
+(+), add, (-), sub, (*), mul, (/), div', mod, mod'
+ :: (HaveValueType a b NumberType) => a -> b -> NumberExpr
+
+(+) a b = simpleOp QL.ADD [value a, value b]
+(-) a b = simpleOp QL.SUBTRACT [value a, value b]
+(*) a b = simpleOp QL.MULTIPLY [value a, value b]
+(/) a b = simpleOp QL.DIVIDE [value a, value b]
+add = (+)
+sub = (-)
+mul = (*)
+div' = (/)
+
+mod a b = simpleOp QL.MODULO [value a, value b]
+mod' = mod
+
+or, or', and, and' :: HaveValueType a b BoolType => a -> b -> BoolExpr
+or a b = simpleOp QL.ANY [value a, value b]
+and a b = simpleOp QL.ALL [value a, value b]
+or' = or
+and' = and
+
+(==), (!=), eq, ne :: (HasValueType a x, HasValueType b y) => a -> b -> BoolExpr
+eq a b = comparison QL.EQ [value a, value b]
+ne a b = comparison QL.NE [value a, value b]
+(==) = eq
+(!=) = ne
+
+(>), (>=), (<), (<=), gt, lt, ge, le
+ :: (HaveValueType a b v, CanCompare v) => a -> b -> BoolExpr
+gt a b = comparison QL.GT [value a, value b]
+lt a b = comparison QL.LT [value a, value b]
+ge a b = comparison QL.GE [value a, value b]
+le a b = comparison QL.LE [value a, value b]
+(>) = gt
+(>=) = ge
+(<) = lt
+(<=) = le
+
+not, not' :: HasValueType a BoolType => a -> BoolExpr
+not a = simpleOp QL.NOT [value a]
+not' = not
+
+-- * Lists and Streams
+
+length, count :: (ToExpr e, Sequence (ExprType e)) => e -> NumberExpr
+count e = simpleOp QL.LENGTH [expr e]
+length = count
+
+(++), concat :: (HaveValueType a b v, CanConcat v) => a -> b -> Expr (ValueType v)
+(++) a b = simpleOp QL.ADD [value a, value b]
+concat = (++)
+
+map, map' :: (ToMapping m, ToStream e, MappingFrom m `HasToStreamValueOf` e) =>
+ m -> e -> Expr (StreamType False (MappingTo m))
+map fun a = mkExpr $ do
+ mapp <- mapping fun
+ rapply [expr a] $ (op QL.MAP) {
+ QL.map = Just $ QL.Map mapp }
+
+map' = map
+
+-- | Get all the documents for which the given predicate is true
+filter', filter :: (ToMapping m, ToStream e,
+ MappingFrom m `HasToStreamValueOf` e) =>
+ m -> e -> Expr (ExprType e)
+filter' fil e = Expr $ do
+ mapp <- mapping fil
+ (vw, term) <- exprV e
+ withView vw $ rapply [return term] $ (op QL.FILTER) {
+ QL.filter = Just $ QL.Filter $ mappingToPredicate mapp }
+
+filter = filter'
+
+-- | Get all documents between two primary keys (both keys are inclusive)
+between :: (ToJSON a, ToStream e, ObjectType `HasToStreamValueOf` e) =>
+ (Maybe a) -> (Maybe a) -> e -> Expr (ExprType e)
+between a b e = Expr $ do
+ (vw, term) <- exprV e
+ withView vw $ rapply [return term] (op QL.RANGE) {
+ QL.range = Just $ QL.Range (viewKeyAttr vw)
+ (fmap toJsonTerm a) (fmap toJsonTerm b) }
+
+append :: (HasValueType a ArrayType, HasValueType b x) => a -> b -> ArrayExpr
+append a b = simpleOp QL.ARRAYAPPEND [value a, value b]
+
+concatMap, concatMap' ::
+ (ToMapping m, (MappingTo m) ~ ArrayType,
+ ToStream e, MappingFrom m `HasToStreamValueOf` e) =>
+ m -> e -> Expr (StreamType False t)
+concatMap fun e = mkExpr $ do
+ mapp <- mapping fun
+ rapply [stream e] (op QL.CONCATMAP) {
+ QL.concat_map = Just $ QL.ConcatMap mapp }
+
+concatMap' = concatMap
+
+innerJoin :: (ToStream a, l `HasToStreamValueOf` a,
+ ToStream b, r `HasToStreamValueOf` b) =>
+ a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) ->
+ Expr (StreamType False ObjectType)
+innerJoin self other p =
+ flip concatMap self
+ (\row -> flip concatMap other
+ (\row2 -> if' (p row row2)
+ [obj ["left" := row, "right" := row2]]
+ nil))
+
+outerJoin :: (ToStream a, l `HasToStreamValueOf` a,
+ ToStream b, r `HasToStreamValueOf` b) =>
+ a -> b -> (ValueExpr l -> ValueExpr r -> BoolExpr) ->
+ Expr (StreamType False ObjectType)
+outerJoin self other p =
+ flip concatMap' self
+ (\row -> bind (flip concatMap' other
+ (\row2 -> if' (p row row2)
+ [obj ["left" := row, "right" := row2]]
+ nil))
+ (\matches ->
+ if' (count matches `gt` (0 :: Int)) (asArray matches) [obj ["left" := row]]))
+
+asArray :: ToExpr e => e -> ArrayExpr
+asArray e = mkExpr $ expr e
+
+eqJoin :: (ToStream a, ObjectType `HasToStreamValueOf` a,
+ ToExpr b, ExprType b ~ ExprType Selection) =>
+ a -> String -> b -> Expr (StreamType False ObjectType)
+eqJoin this k1 other =
+ flip concatMap this $ \row ->
+ bind (get other (row ! k1)) $ \right ->
+ if' (right != ()) [obj ["left" := row, "right" := right]] nil
+
+drop, drop', skip :: (ToStream e, t `HasToStreamValueOf` e,
+ ToExpr n, ExprType n ~ ValueType NumberType) =>
+ e -> n -> Expr (StreamType (ExprIsView e) t)
+drop e n = Expr $ do
+ (vw, ex) <- exprV e
+ withView vw $ rapply [return ex, expr (), expr n] (op QL.SLICE)
+drop' = drop
+skip = drop
+
+take, take', limit :: (ToStream e, t `HasToStreamValueOf` e,
+ ToExpr n, ExprType n ~ ValueType NumberType) =>
+ e -> n -> Expr (StreamType (ExprIsView e) t)
+take e n = Expr $ do
+ (vw, ex) <- exprV e
+ withView vw $ rapply [return ex, expr n, expr ()] (op QL.SLICE)
+take' = take
+limit = take
+
+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)
+slice e n m = Expr $ do
+ (vw, ex) <- exprV e
+ withView vw $ rapply [return ex, expr n, expr m] (op QL.SLICE)
+
+(!!), nth :: (ToStream e, t `HasToStreamValueOf` e,
+ ToExpr n, ExprType n ~ ValueType NumberType) =>
+ e -> n -> ValueExpr t
+nth e n = Expr $ withView NoView $ rapply [stream e, expr n] (op QL.NTH)
+(!!) = nth
+
+-- | The empty list expression
+nil :: ValueExpr ArrayType
+nil = toExpr ([] :: [()])
+
+union, union' :: (ToStream a, t `HasToStreamValueOf` a,
+ ToStream b, t `HasToStreamValueOf` b) =>
+ a -> b -> Expr (StreamType False t)
+union a b = simpleOp QL.UNION [stream a, stream b]
+union' = union
+
+-- | A fold
+--
+-- >>> run h $ reduce [1,2,3] (0 :: Int) (+)
+-- 6
+
+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)
+fold f a e = Expr $ do
+ v1 <- newVar
+ v2 <- newVar
+ aq <- value a
+ result <- expr (f (var v1) (var v2))
+ withView NoView $ rapply [stream e] (op QL.REDUCE) {
+ QL.reduce = Just $ QL.Reduction {
+ QL.base = aq,
+ QL.var1 = uFromString v1,
+ QL.var2 = uFromString v2,
+ QLReduction.body = result } }
+
+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)
+reduce this base f = fold f base this
+
+distinct :: (ToStream e, v `HasToStreamValueOf` e) =>
+ e -> Expr (StreamType False v)
+distinct e = simpleOp QL.DISTINCT [stream e]
+
+-- TODO: does not work
+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)
+groupedMapReduce group val base reduction e = Expr $ do
+ g <- mapping group
+ v <- mapping val
+ v1 <- newVar
+ v2 <- newVar
+ b <- value base
+ result <- value (reduction (var v1) (var v2))
+ withView NoView $ rapply [stream e] (op QL.GROUPEDMAPREDUCE) {
+ QL.grouped_map_reduce = Just $ QL.GroupedMapReduce {
+ QL.group_mapping = g,
+ QL.value_mapping = v,
+ QL.reduction = QL.Reduction {
+ QL.base = b,
+ QL.var1 = uFromString v1,
+ QL.var2 = uFromString v2,
+ QLReduction.body = result }} }
+
+-- | Execute a write query for each element of the stream
+--
+-- >>> run h $ forEach [1,2,3::Int] (\x -> insert (table "fruits") (obj ["n" := x]))
+
+forEach :: (ToStream a, v `HasToStreamValueOf` a) =>
+ a -> (ValueExpr v -> WriteQuery b) -> WriteQuery ()
+forEach s mkwq = WriteQuery (do
+ arg <- newVar
+ let wq = mkwq (var arg)
+ qlwq <- writeQueryBuild wq
+ as <- stream s
+ return $ defaultValue {
+ QLWriteQuery.type' = QL.FOREACH,
+ QL.for_each = Just $ QL.ForEach as (uFromString arg) (Seq.singleton qlwq) })
+ (whenSuccess_ ())
+
+zip, zip' :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
+ e -> Expr (StreamType False ObjectType)
+zip = map (\row -> if' (row !? "right")
+ (merge (row ! "left") (row ! "right"))
+ (row ! "left"))
+zip' = zip
+
+data Order = Asc { orderAttr :: String }
+ | Desc { orderAttr :: String }
+
+orderAscending :: Order -> Bool
+orderAscending Asc {} = True
+orderAscending Desc {} = False
+
+class ToOrder a where toOrder :: a -> Order
+instance ToOrder String where toOrder = Asc
+instance ToOrder Order where toOrder o = o
+
+orderBy :: (ToOrder o, ToStream e, a `HasToStreamValueOf` e) =>
+ [o] -> e -> Expr (StreamType (ExprIsView e) a)
+orderBy o e = Expr $ do
+ (vw, ex) <- exprV e
+ withView vw $ rapply [return ex] (op QL.ORDERBY) {
+ QL.order_by = Seq.fromList $ flip P.map o $ \(toOrder -> x) -> QL.OrderBy {
+ QLOrderBy.attr = uFromString (orderAttr x), QL.ascending = Just $ orderAscending x }}
+
+groupBy,groupBy' :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
+ [String] -> MapReduce ObjectType b c d -> e -> Expr (StreamType False d)
+groupBy ks (MapReduce m b r f) e = map f (groupedMapReduce (pick ks) m b r e)
+groupBy' = groupBy
+
+data MapReduce a b c d = MapReduce (ValueExpr a -> ValueExpr b) (ValueExpr c)
+ (ValueExpr c -> ValueExpr b -> ValueExpr c)
+ (ValueExpr c -> ValueExpr d)
+
+sum, sum' :: String -> MapReduce ObjectType NumberType NumberType NumberType
+sum a = MapReduce (! a) 0 (+) P.id
+sum' = sum
+
+count' :: MapReduce ObjectType NoneType NumberType NumberType
+count' = MapReduce (P.const (toExpr ())) 0 (\x _ -> x + (1 :: Int)) P.id
+
+avg :: String -> MapReduce ObjectType ArrayType ArrayType NumberType
+avg k = MapReduce (\x -> toExpr [x ! k :: NumberExpr, 1]) (toExpr [0,0 :: Int])
+ (\a o -> toExpr [(a !! (0 :: Int)) + (o !! (0 :: Int)), (a !! (1 :: Int)) + (o !! (1 :: Int)) :: NumberExpr])
+ (\a -> ((a !! (0 :: Int)) / (a !! (1 :: Int))))
+
+-- * Accessors
+
+-- | 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
+
+(!) :: (ToExpr a, ExprValueType a ~ ObjectType) => a -> String -> ValueExpr t
+(!) a b = mkExpr $ rapply [expr a] (op QL.GETATTR) {
+ QLBuiltin.attr = Just (uFromString b) }
+
+pick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr
+pick ks e = mkExpr $ rapply [value e] (op QL.PICKATTRS) {
+ QL.attrs = Seq.fromList $ P.map uFromString ks }
+
+unpick :: HasValueType e ObjectType => [String] -> e -> ObjectExpr
+unpick ks e = mkExpr $ rapply [value e] (op QL.WITHOUT) {
+ QL.attrs = Seq.fromList $ P.map uFromString ks }
+
+(!?) :: (HasValueType a ObjectType) => a -> String -> BoolExpr
+(!?) a b = mkExpr $ rapply [value a] (op QL.HASATTR) {
+ QLBuiltin.attr = Just $ uFromString b }
+
+pluck :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
+ [String] -> e -> Expr (StreamType False ObjectType)
+pluck ks = map (pick ks)
+
+without :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
+ [String] -> e -> Expr (StreamType False ObjectType)
+without ks = map (unpick ks)
+
+merge :: (ToExpr a, ExprType a ~ ValueType ObjectType,
+ ToExpr b, ExprType b ~ ValueType ObjectType) =>
+ a -> b -> ObjectExpr
+merge this other = simpleOp QL.MAPMERGE [expr this, expr other]
+
+-- * Control Structures, Functions and Javascript
+
+-- | A javascript expression
+--
+-- It is often necessary to specify the result type:
+--
+-- >>> run h $ (js "1 + 2" :: NumberExpr)
+-- 3
+
+js :: String -> Expr (ValueType any)
+js s = mkExpr $ return defaultValue {
+ QLTerm.type' = QL.JAVASCRIPT,
+ QLTerm.javascript = Just $ uFromString ("return (" P.++ s P.++ ")") }
+
+bind :: (ToValue e) => e -> (ValueExpr (ToValueType (ExprType e)) -> Expr t) -> Expr t
+bind val f = Expr $ do
+ arg <- value val
+ v <- newVar
+ (vw, body) <- exprV (f (var v))
+ withView vw $ return defaultValue {
+ QLTerm.type' = QL.LET,
+ QLTerm.let' = Just $ QL.Let (Seq.singleton $ QL.VarTermTuple (uFromString v) arg)
+ body }
+
+let' :: [Attribute] -> Expr t -> Expr t
+let' pairs e = Expr $ do
+ varTerms <- mapM (\(k := v) ->
+ (QL.VarTermTuple (uFromString k)) `liftM` value v) pairs
+ (vw, body) <- exprV e
+ withView vw $ return defaultValue {
+ QLTerm.type' = QL.LET,
+ QLTerm.let' = Just $ QL.Let (Seq.fromList $ varTerms) body }
+
+var :: ExprIsView (Expr t) ~ False => String -> Expr t
+var v = mkExpr $ return defaultValue {
+ QLTerm.type' = QL.VAR,
+ QLTerm.var = Just $ uFromString v
+ }
+
+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
+if' t a b = mkExpr $ do
+ tq <- value t
+ aq <- expr a
+ bq <- expr b
+ return defaultValue {
+ QLTerm.type' = QL.IF, QL.if_ = Just $ QL.If tq aq bq }
+
+-- | A javascript function
+--
+-- >>> let squareRoot = jsfun "Math.sqrt" :: NumberExpr -> NumberExpr
+-- >>> run h $ squareRoot 5 :: IO Double
+-- 2.23606797749979
+
+jsfun :: ToValue e => String -> e -> Expr (ValueType y)
+jsfun f e = mkExpr $ do
+ v <- newVar
+ expr (let' [v := e] $ js $ f P.++ "(" P.++ v P.++ ")")
+
+error, error' :: (ExprTypeIsView t ~ False) => String -> Expr t
+error m = Expr $ withView NoView $ return defaultValue {
+ QLTerm.type' = QL.ERROR, QL.error = Just $ uFromString m }
+error' = error
+
+class CanConcat (a :: ValueTypeKind)
+instance CanConcat StringType
+instance CanConcat ArrayType
diff --git a/Database/RethinkDB/Functions.hs-boot b/Database/RethinkDB/Functions.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Functions.hs-boot
@@ -0,0 +1,9 @@
+{-# LANGUAGE ConstraintKinds, DataKinds, TypeFamilies #-}
+module Database.RethinkDB.Functions where
+import Database.RethinkDB.Types
+import {-# SOURCE #-} Database.RethinkDB.Driver
+add, sub, mul, div'
+ :: (HaveValueType a b NumberType) => a -> b -> NumberExpr
+jsfun :: ToValue e => String -> e -> Expr (ValueType y)
+var :: ExprIsView (Expr t) ~ False => String -> Expr t
+signum' :: (ToValue e, ToValueType (ExprType e) ~ NumberType) => e -> NumberExpr
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin.hs b/Database/RethinkDB/Internal/Query_Language/Builtin.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin.hs
@@ -0,0 +1,123 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin (Builtin(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType as Query_Language.Builtin (BuiltinType)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Comparison as Query_Language.Builtin (Comparison)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap as Query_Language.Builtin (ConcatMap)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Filter as Query_Language.Builtin (Filter)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce as Query_Language.Builtin (GroupedMapReduce)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Map as Query_Language.Builtin (Map)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy as Query_Language.Builtin (OrderBy)
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin.Range as Query_Language.Builtin (Range)
+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as Query_Language (Reduction)
+
+data Builtin = Builtin{type' :: !Query_Language.Builtin.BuiltinType, attr :: !(P'.Maybe P'.Utf8), attrs :: !(P'.Seq P'.Utf8),
+ comparison :: !(P'.Maybe Query_Language.Builtin.Comparison),
+ filter :: !(P'.Maybe Query_Language.Builtin.Filter), map :: !(P'.Maybe Query_Language.Builtin.Map),
+ concat_map :: !(P'.Maybe Query_Language.Builtin.ConcatMap),
+ order_by :: !(P'.Seq Query_Language.Builtin.OrderBy), reduce :: !(P'.Maybe Query_Language.Reduction),
+ grouped_map_reduce :: !(P'.Maybe Query_Language.Builtin.GroupedMapReduce),
+ range :: !(P'.Maybe Query_Language.Builtin.Range)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Builtin where
+ mergeAppend (Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11) (Builtin y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10 y'11)
+ = Builtin (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+ (P'.mergeAppend x'5 y'5)
+ (P'.mergeAppend x'6 y'6)
+ (P'.mergeAppend x'7 y'7)
+ (P'.mergeAppend x'8 y'8)
+ (P'.mergeAppend x'9 y'9)
+ (P'.mergeAppend x'10 y'10)
+ (P'.mergeAppend x'11 y'11)
+
+instance P'.Default Builtin where
+ defaultValue
+ = Builtin P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+
+instance P'.Wire Builtin where
+ wireSize ft' self'@(Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeRep 1 9 x'3 + P'.wireSizeOpt 1 14 x'4 +
+ P'.wireSizeOpt 1 11 x'5
+ + P'.wireSizeOpt 1 11 x'6
+ + P'.wireSizeOpt 1 11 x'7
+ + P'.wireSizeRep 1 11 x'8
+ + P'.wireSizeOpt 1 11 x'9
+ + P'.wireSizeOpt 1 11 x'10
+ + P'.wireSizeOpt 1 11 x'11)
+ wirePut ft' self'@(Builtin x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutOpt 18 9 x'2
+ P'.wirePutRep 26 9 x'3
+ P'.wirePutOpt 32 14 x'4
+ P'.wirePutOpt 42 11 x'5
+ P'.wirePutOpt 50 11 x'6
+ P'.wirePutOpt 58 11 x'7
+ P'.wirePutRep 66 11 x'8
+ P'.wirePutOpt 74 11 x'9
+ P'.wirePutOpt 82 11 x'10
+ P'.wirePutOpt 90 11 x'11
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{attr = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{attrs = P'.append (attrs old'Self) new'Field}) (P'.wireGet 9)
+ 32 -> Prelude'.fmap (\ !new'Field -> old'Self{comparison = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 42 -> Prelude'.fmap (\ !new'Field -> old'Self{filter = P'.mergeAppend (filter old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 50 -> Prelude'.fmap (\ !new'Field -> old'Self{map = P'.mergeAppend (map old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 58 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{concat_map = P'.mergeAppend (concat_map old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 66 -> Prelude'.fmap (\ !new'Field -> old'Self{order_by = P'.append (order_by old'Self) new'Field}) (P'.wireGet 11)
+ 74 -> Prelude'.fmap (\ !new'Field -> old'Self{reduce = P'.mergeAppend (reduce old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 82 -> Prelude'.fmap
+ (\ !new'Field ->
+ old'Self{grouped_map_reduce = P'.mergeAppend (grouped_map_reduce old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 90 -> Prelude'.fmap (\ !new'Field -> old'Self{range = P'.mergeAppend (range old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Builtin) Builtin where
+ getVal m' f' = f' m'
+
+instance P'.GPB Builtin
+
+instance P'.ReflectDescriptor Builtin where
+ getMessageInfo _
+ = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 32, 42, 50, 58, 66, 74, 82, 90])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Builtin\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.BuiltinType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"BuiltinType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.attr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"attr\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.attrs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"attrs\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.comparison\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"comparison\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 32}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Comparison\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Comparison\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.filter\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"filter\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Filter\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Filter\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.map\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"map\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Map\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Map\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.concat_map\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"concat_map\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 58}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.ConcatMap\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"ConcatMap\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.order_by\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"order_by\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.OrderBy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"OrderBy\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.reduce\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"reduce\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.grouped_map_reduce\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"grouped_map_reduce\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 82}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.GroupedMapReduce\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"GroupedMapReduce\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.range\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\"], baseName' = FName \"range\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 90}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin.Range\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Range\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs
@@ -0,0 +1,231 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType (BuiltinType(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data BuiltinType = NOT
+ | GETATTR
+ | IMPLICIT_GETATTR
+ | HASATTR
+ | IMPLICIT_HASATTR
+ | PICKATTRS
+ | IMPLICIT_PICKATTRS
+ | MAPMERGE
+ | ARRAYAPPEND
+ | SLICE
+ | ADD
+ | SUBTRACT
+ | MULTIPLY
+ | DIVIDE
+ | MODULO
+ | COMPARE
+ | FILTER
+ | MAP
+ | CONCATMAP
+ | ORDERBY
+ | DISTINCT
+ | LENGTH
+ | UNION
+ | NTH
+ | STREAMTOARRAY
+ | ARRAYTOSTREAM
+ | REDUCE
+ | GROUPEDMAPREDUCE
+ | ANY
+ | ALL
+ | RANGE
+ | IMPLICIT_WITHOUT
+ | WITHOUT
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable BuiltinType
+
+instance Prelude'.Bounded BuiltinType where
+ minBound = NOT
+ maxBound = WITHOUT
+
+instance P'.Default BuiltinType where
+ defaultValue = NOT
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe BuiltinType
+toMaybe'Enum 1 = Prelude'.Just NOT
+toMaybe'Enum 2 = Prelude'.Just GETATTR
+toMaybe'Enum 3 = Prelude'.Just IMPLICIT_GETATTR
+toMaybe'Enum 4 = Prelude'.Just HASATTR
+toMaybe'Enum 5 = Prelude'.Just IMPLICIT_HASATTR
+toMaybe'Enum 6 = Prelude'.Just PICKATTRS
+toMaybe'Enum 7 = Prelude'.Just IMPLICIT_PICKATTRS
+toMaybe'Enum 8 = Prelude'.Just MAPMERGE
+toMaybe'Enum 9 = Prelude'.Just ARRAYAPPEND
+toMaybe'Enum 11 = Prelude'.Just SLICE
+toMaybe'Enum 14 = Prelude'.Just ADD
+toMaybe'Enum 15 = Prelude'.Just SUBTRACT
+toMaybe'Enum 16 = Prelude'.Just MULTIPLY
+toMaybe'Enum 17 = Prelude'.Just DIVIDE
+toMaybe'Enum 18 = Prelude'.Just MODULO
+toMaybe'Enum 19 = Prelude'.Just COMPARE
+toMaybe'Enum 20 = Prelude'.Just FILTER
+toMaybe'Enum 21 = Prelude'.Just MAP
+toMaybe'Enum 22 = Prelude'.Just CONCATMAP
+toMaybe'Enum 23 = Prelude'.Just ORDERBY
+toMaybe'Enum 24 = Prelude'.Just DISTINCT
+toMaybe'Enum 26 = Prelude'.Just LENGTH
+toMaybe'Enum 27 = Prelude'.Just UNION
+toMaybe'Enum 28 = Prelude'.Just NTH
+toMaybe'Enum 29 = Prelude'.Just STREAMTOARRAY
+toMaybe'Enum 30 = Prelude'.Just ARRAYTOSTREAM
+toMaybe'Enum 31 = Prelude'.Just REDUCE
+toMaybe'Enum 32 = Prelude'.Just GROUPEDMAPREDUCE
+toMaybe'Enum 35 = Prelude'.Just ANY
+toMaybe'Enum 36 = Prelude'.Just ALL
+toMaybe'Enum 37 = Prelude'.Just RANGE
+toMaybe'Enum 38 = Prelude'.Just IMPLICIT_WITHOUT
+toMaybe'Enum 39 = Prelude'.Just WITHOUT
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum BuiltinType where
+ fromEnum NOT = 1
+ fromEnum GETATTR = 2
+ fromEnum IMPLICIT_GETATTR = 3
+ fromEnum HASATTR = 4
+ fromEnum IMPLICIT_HASATTR = 5
+ fromEnum PICKATTRS = 6
+ fromEnum IMPLICIT_PICKATTRS = 7
+ fromEnum MAPMERGE = 8
+ fromEnum ARRAYAPPEND = 9
+ fromEnum SLICE = 11
+ fromEnum ADD = 14
+ fromEnum SUBTRACT = 15
+ fromEnum MULTIPLY = 16
+ fromEnum DIVIDE = 17
+ fromEnum MODULO = 18
+ fromEnum COMPARE = 19
+ fromEnum FILTER = 20
+ fromEnum MAP = 21
+ fromEnum CONCATMAP = 22
+ fromEnum ORDERBY = 23
+ fromEnum DISTINCT = 24
+ fromEnum LENGTH = 26
+ fromEnum UNION = 27
+ fromEnum NTH = 28
+ fromEnum STREAMTOARRAY = 29
+ fromEnum ARRAYTOSTREAM = 30
+ fromEnum REDUCE = 31
+ fromEnum GROUPEDMAPREDUCE = 32
+ fromEnum ANY = 35
+ fromEnum ALL = 36
+ fromEnum RANGE = 37
+ fromEnum IMPLICIT_WITHOUT = 38
+ fromEnum WITHOUT = 39
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error
+ "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType")
+ . toMaybe'Enum
+ succ NOT = GETATTR
+ succ GETATTR = IMPLICIT_GETATTR
+ succ IMPLICIT_GETATTR = HASATTR
+ succ HASATTR = IMPLICIT_HASATTR
+ succ IMPLICIT_HASATTR = PICKATTRS
+ succ PICKATTRS = IMPLICIT_PICKATTRS
+ succ IMPLICIT_PICKATTRS = MAPMERGE
+ succ MAPMERGE = ARRAYAPPEND
+ succ ARRAYAPPEND = SLICE
+ succ SLICE = ADD
+ succ ADD = SUBTRACT
+ succ SUBTRACT = MULTIPLY
+ succ MULTIPLY = DIVIDE
+ succ DIVIDE = MODULO
+ succ MODULO = COMPARE
+ succ COMPARE = FILTER
+ succ FILTER = MAP
+ succ MAP = CONCATMAP
+ succ CONCATMAP = ORDERBY
+ succ ORDERBY = DISTINCT
+ succ DISTINCT = LENGTH
+ succ LENGTH = UNION
+ succ UNION = NTH
+ succ NTH = STREAMTOARRAY
+ succ STREAMTOARRAY = ARRAYTOSTREAM
+ succ ARRAYTOSTREAM = REDUCE
+ succ REDUCE = GROUPEDMAPREDUCE
+ succ GROUPEDMAPREDUCE = ANY
+ succ ANY = ALL
+ succ ALL = RANGE
+ succ RANGE = IMPLICIT_WITHOUT
+ succ IMPLICIT_WITHOUT = WITHOUT
+ succ _
+ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType"
+ pred GETATTR = NOT
+ pred IMPLICIT_GETATTR = GETATTR
+ pred HASATTR = IMPLICIT_GETATTR
+ pred IMPLICIT_HASATTR = HASATTR
+ pred PICKATTRS = IMPLICIT_HASATTR
+ pred IMPLICIT_PICKATTRS = PICKATTRS
+ pred MAPMERGE = IMPLICIT_PICKATTRS
+ pred ARRAYAPPEND = MAPMERGE
+ pred SLICE = ARRAYAPPEND
+ pred ADD = SLICE
+ pred SUBTRACT = ADD
+ pred MULTIPLY = SUBTRACT
+ pred DIVIDE = MULTIPLY
+ pred MODULO = DIVIDE
+ pred COMPARE = MODULO
+ pred FILTER = COMPARE
+ pred MAP = FILTER
+ pred CONCATMAP = MAP
+ pred ORDERBY = CONCATMAP
+ pred DISTINCT = ORDERBY
+ pred LENGTH = DISTINCT
+ pred UNION = LENGTH
+ pred NTH = UNION
+ pred STREAMTOARRAY = NTH
+ pred ARRAYTOSTREAM = STREAMTOARRAY
+ pred REDUCE = ARRAYTOSTREAM
+ pred GROUPEDMAPREDUCE = REDUCE
+ pred ANY = GROUPEDMAPREDUCE
+ pred ALL = ANY
+ pred RANGE = ALL
+ pred IMPLICIT_WITHOUT = RANGE
+ pred WITHOUT = IMPLICIT_WITHOUT
+ pred _
+ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType"
+
+instance P'.Wire BuiltinType where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB BuiltinType
+
+instance P'.MessageAPI msg' (msg' -> BuiltinType) BuiltinType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum BuiltinType where
+ reflectEnum
+ = [(1, "NOT", NOT), (2, "GETATTR", GETATTR), (3, "IMPLICIT_GETATTR", IMPLICIT_GETATTR), (4, "HASATTR", HASATTR),
+ (5, "IMPLICIT_HASATTR", IMPLICIT_HASATTR), (6, "PICKATTRS", PICKATTRS), (7, "IMPLICIT_PICKATTRS", IMPLICIT_PICKATTRS),
+ (8, "MAPMERGE", MAPMERGE), (9, "ARRAYAPPEND", ARRAYAPPEND), (11, "SLICE", SLICE), (14, "ADD", ADD),
+ (15, "SUBTRACT", SUBTRACT), (16, "MULTIPLY", MULTIPLY), (17, "DIVIDE", DIVIDE), (18, "MODULO", MODULO),
+ (19, "COMPARE", COMPARE), (20, "FILTER", FILTER), (21, "MAP", MAP), (22, "CONCATMAP", CONCATMAP), (23, "ORDERBY", ORDERBY),
+ (24, "DISTINCT", DISTINCT), (26, "LENGTH", LENGTH), (27, "UNION", UNION), (28, "NTH", NTH),
+ (29, "STREAMTOARRAY", STREAMTOARRAY), (30, "ARRAYTOSTREAM", ARRAYTOSTREAM), (31, "REDUCE", REDUCE),
+ (32, "GROUPEDMAPREDUCE", GROUPEDMAPREDUCE), (35, "ANY", ANY), (36, "ALL", ALL), (37, "RANGE", RANGE),
+ (38, "IMPLICIT_WITHOUT", IMPLICIT_WITHOUT), (39, "WITHOUT", WITHOUT)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.Builtin.BuiltinType") ["Database", "RethinkDB", "Internal"]
+ ["Query_Language", "Builtin"]
+ "BuiltinType")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "Builtin", "BuiltinType.hs"]
+ [(1, "NOT"), (2, "GETATTR"), (3, "IMPLICIT_GETATTR"), (4, "HASATTR"), (5, "IMPLICIT_HASATTR"), (6, "PICKATTRS"),
+ (7, "IMPLICIT_PICKATTRS"), (8, "MAPMERGE"), (9, "ARRAYAPPEND"), (11, "SLICE"), (14, "ADD"), (15, "SUBTRACT"),
+ (16, "MULTIPLY"), (17, "DIVIDE"), (18, "MODULO"), (19, "COMPARE"), (20, "FILTER"), (21, "MAP"), (22, "CONCATMAP"),
+ (23, "ORDERBY"), (24, "DISTINCT"), (26, "LENGTH"), (27, "UNION"), (28, "NTH"), (29, "STREAMTOARRAY"), (30, "ARRAYTOSTREAM"),
+ (31, "REDUCE"), (32, "GROUPEDMAPREDUCE"), (35, "ANY"), (36, "ALL"), (37, "RANGE"), (38, "IMPLICIT_WITHOUT"), (39, "WITHOUT")]
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs
@@ -0,0 +1,82 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.Comparison (Comparison(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data Comparison = EQ
+ | NE
+ | LT
+ | LE
+ | GT
+ | GE
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Comparison
+
+instance Prelude'.Bounded Comparison where
+ minBound = EQ
+ maxBound = GE
+
+instance P'.Default Comparison where
+ defaultValue = EQ
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe Comparison
+toMaybe'Enum 1 = Prelude'.Just EQ
+toMaybe'Enum 2 = Prelude'.Just NE
+toMaybe'Enum 3 = Prelude'.Just LT
+toMaybe'Enum 4 = Prelude'.Just LE
+toMaybe'Enum 5 = Prelude'.Just GT
+toMaybe'Enum 6 = Prelude'.Just GE
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum Comparison where
+ fromEnum EQ = 1
+ fromEnum NE = 2
+ fromEnum LT = 3
+ fromEnum LE = 4
+ fromEnum GT = 5
+ fromEnum GE = 6
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error
+ "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison")
+ . toMaybe'Enum
+ succ EQ = NE
+ succ NE = LT
+ succ LT = LE
+ succ LE = GT
+ succ GT = GE
+ succ _
+ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison"
+ pred NE = EQ
+ pred LT = NE
+ pred LE = LT
+ pred GT = LE
+ pred GE = GT
+ pred _
+ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Builtin.Comparison"
+
+instance P'.Wire Comparison where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB Comparison
+
+instance P'.MessageAPI msg' (msg' -> Comparison) Comparison where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum Comparison where
+ reflectEnum = [(1, "EQ", EQ), (2, "NE", NE), (3, "LT", LT), (4, "LE", LE), (5, "GT", GT), (6, "GE", GE)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.Builtin.Comparison") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Builtin"]
+ "Comparison")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "Builtin", "Comparison.hs"]
+ [(1, "EQ"), (2, "NE"), (3, "LT"), (4, "LE"), (5, "GT"), (6, "GE")]
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap (ConcatMap(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+
+data ConcatMap = ConcatMap{mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable ConcatMap where
+ mergeAppend (ConcatMap x'1) (ConcatMap y'1) = ConcatMap (P'.mergeAppend x'1 y'1)
+
+instance P'.Default ConcatMap where
+ defaultValue = ConcatMap P'.defaultValue
+
+instance P'.Wire ConcatMap where
+ wireSize ft' self'@(ConcatMap x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1)
+ wirePut ft' self'@(ConcatMap x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> ConcatMap) ConcatMap where
+ getVal m' f' = f' m'
+
+instance P'.GPB ConcatMap
+
+instance P'.ReflectDescriptor ConcatMap where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.ConcatMap\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"ConcatMap\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"ConcatMap.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.ConcatMap.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"ConcatMap\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.Filter (Filter(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Predicate as Query_Language (Predicate)
+
+data Filter = Filter{predicate :: !Query_Language.Predicate}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Filter where
+ mergeAppend (Filter x'1) (Filter y'1) = Filter (P'.mergeAppend x'1 y'1)
+
+instance P'.Default Filter where
+ defaultValue = Filter P'.defaultValue
+
+instance P'.Wire Filter where
+ wireSize ft' self'@(Filter x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1)
+ wirePut ft' self'@(Filter x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{predicate = P'.mergeAppend (predicate old'Self) (new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Filter) Filter where
+ getVal m' f' = f' m'
+
+instance P'.GPB Filter
+
+instance P'.ReflectDescriptor Filter where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Filter\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Filter\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Filter.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Filter.predicate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Filter\"], baseName' = FName \"predicate\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Predicate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Predicate\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs
@@ -0,0 +1,68 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce (GroupedMapReduce(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+import qualified Database.RethinkDB.Internal.Query_Language.Reduction as Query_Language (Reduction)
+
+data GroupedMapReduce = GroupedMapReduce{group_mapping :: !Query_Language.Mapping, value_mapping :: !Query_Language.Mapping,
+ reduction :: !Query_Language.Reduction}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable GroupedMapReduce where
+ mergeAppend (GroupedMapReduce x'1 x'2 x'3) (GroupedMapReduce y'1 y'2 y'3)
+ = GroupedMapReduce (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default GroupedMapReduce where
+ defaultValue = GroupedMapReduce P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire GroupedMapReduce where
+ wireSize ft' self'@(GroupedMapReduce x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeReq 1 11 x'3)
+ wirePut ft' self'@(GroupedMapReduce x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 11 x'2
+ P'.wirePutReq 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{group_mapping = P'.mergeAppend (group_mapping old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{value_mapping = P'.mergeAppend (value_mapping old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{reduction = P'.mergeAppend (reduction old'Self) (new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> GroupedMapReduce) GroupedMapReduce where
+ getVal m' f' = f' m'
+
+instance P'.GPB GroupedMapReduce
+
+instance P'.ReflectDescriptor GroupedMapReduce where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.GroupedMapReduce\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"GroupedMapReduce\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"GroupedMapReduce.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.group_mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"group_mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.value_mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"value_mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.GroupedMapReduce.reduction\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"GroupedMapReduce\"], baseName' = FName \"reduction\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.Map (Map(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+
+data Map = Map{mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Map where
+ mergeAppend (Map x'1) (Map y'1) = Map (P'.mergeAppend x'1 y'1)
+
+instance P'.Default Map where
+ defaultValue = Map P'.defaultValue
+
+instance P'.Wire Map where
+ wireSize ft' self'@(Map x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1)
+ wirePut ft' self'@(Map x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Map) Map where
+ getVal m' f' = f' m'
+
+instance P'.GPB Map
+
+instance P'.ReflectDescriptor Map where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Map\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Map\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Map.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Map.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Map\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy (OrderBy(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data OrderBy = OrderBy{attr :: !P'.Utf8, ascending :: !(P'.Maybe P'.Bool)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable OrderBy where
+ mergeAppend (OrderBy x'1 x'2) (OrderBy y'1 y'2) = OrderBy (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default OrderBy where
+ defaultValue = OrderBy P'.defaultValue (Prelude'.Just Prelude'.True)
+
+instance P'.Wire OrderBy where
+ wireSize ft' self'@(OrderBy x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeOpt 1 8 x'2)
+ wirePut ft' self'@(OrderBy x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutOpt 16 8 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{attr = new'Field}) (P'.wireGet 9)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{ascending = Prelude'.Just new'Field}) (P'.wireGet 8)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> OrderBy) OrderBy where
+ getVal m' f' = f' m'
+
+instance P'.GPB OrderBy
+
+instance P'.ReflectDescriptor OrderBy where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 16])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.OrderBy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"OrderBy\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"OrderBy.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.OrderBy.attr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"OrderBy\"], baseName' = FName \"attr\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.OrderBy.ascending\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"OrderBy\"], baseName' = FName \"ascending\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"true\", hsDefault = Just (HsDef'Bool True)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs b/Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs
@@ -0,0 +1,68 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Builtin.Range (Range(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Range = Range{attrname :: !P'.Utf8, lowerbound :: !(P'.Maybe Query_Language.Term),
+ upperbound :: !(P'.Maybe Query_Language.Term)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Range where
+ mergeAppend (Range x'1 x'2 x'3) (Range y'1 y'2 y'3)
+ = Range (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default Range where
+ defaultValue = Range P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Range where
+ wireSize ft' self'@(Range x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeOpt 1 11 x'2 + P'.wireSizeOpt 1 11 x'3)
+ wirePut ft' self'@(Range x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutOpt 18 11 x'2
+ P'.wirePutOpt 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{lowerbound = P'.mergeAppend (lowerbound old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 26 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{upperbound = P'.mergeAppend (upperbound old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Range) Range where
+ getVal m' f' = f' m'
+
+instance P'.GPB Range
+
+instance P'.ReflectDescriptor Range where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Builtin.Range\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Builtin\"], baseName = MName \"Range\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Builtin\",\"Range.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.lowerbound\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"lowerbound\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Builtin.Range.upperbound\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Builtin\",MName \"Range\"], baseName' = FName \"upperbound\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Mapping.hs b/Database/RethinkDB/Internal/Query_Language/Mapping.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Mapping.hs
@@ -0,0 +1,69 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Mapping (Mapping(..)) where
+import Prelude ((+), (/), (==), (<=), (&&))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Mapping = Mapping{arg :: !P'.Utf8, body :: !Query_Language.Term, ext'field :: !P'.ExtField}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.ExtendMessage Mapping where
+ getExtField = ext'field
+ putExtField e'f msg = msg{ext'field = e'f}
+ validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)
+
+instance P'.Mergeable Mapping where
+ mergeAppend (Mapping x'1 x'2 x'3) (Mapping y'1 y'2 y'3)
+ = Mapping (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default Mapping where
+ defaultValue = Mapping P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Mapping where
+ wireSize ft' self'@(Mapping x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeExtField x'3)
+ wirePut ft' self'@(Mapping x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutReq 18 11 x'2
+ P'.wirePutExtField x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{arg = new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in
+ if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then
+ P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Mapping) Mapping where
+ getVal m' f' = f' m'
+
+instance P'.GPB Mapping
+
+instance P'.ReflectDescriptor Mapping where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Mapping.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Mapping.arg\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Mapping\"], baseName' = FName \"arg\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Mapping.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Mapping\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/MetaQuery.hs b/Database/RethinkDB/Internal/Query_Language/MetaQuery.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/MetaQuery.hs
@@ -0,0 +1,73 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.MetaQuery (MetaQuery(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable as Query_Language.MetaQuery (CreateTable)
+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType as Query_Language.MetaQuery (MetaQueryType)
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+
+data MetaQuery = MetaQuery{type' :: !Query_Language.MetaQuery.MetaQueryType, db_name :: !(P'.Maybe P'.Utf8),
+ create_table :: !(P'.Maybe Query_Language.MetaQuery.CreateTable),
+ drop_table :: !(P'.Maybe Query_Language.TableRef)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable MetaQuery where
+ mergeAppend (MetaQuery x'1 x'2 x'3 x'4) (MetaQuery y'1 y'2 y'3 y'4)
+ = MetaQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default MetaQuery where
+ defaultValue = MetaQuery P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire MetaQuery where
+ wireSize ft' self'@(MetaQuery x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4)
+ wirePut ft' self'@(MetaQuery x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutOpt 18 9 x'2
+ P'.wirePutOpt 26 11 x'3
+ P'.wirePutOpt 34 11 x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{db_name = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{create_table = P'.mergeAppend (create_table old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 34 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{drop_table = P'.mergeAppend (drop_table old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> MetaQuery) MetaQuery where
+ getVal m' f' = f' m'
+
+instance P'.GPB MetaQuery
+
+instance P'.ReflectDescriptor MetaQuery where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.MetaQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"MetaQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"MetaQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery.MetaQueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"MetaQueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.db_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"db_name\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.create_table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"create_table\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery.CreateTable\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"CreateTable\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.drop_table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\"], baseName' = FName \"drop_table\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs b/Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs
@@ -0,0 +1,67 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable (CreateTable(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+
+data CreateTable = CreateTable{datacenter :: !(P'.Maybe P'.Utf8), table_ref :: !Query_Language.TableRef,
+ primary_key :: !(P'.Maybe P'.Utf8), cache_size :: !(P'.Maybe P'.Int64)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable CreateTable where
+ mergeAppend (CreateTable x'1 x'2 x'3 x'4) (CreateTable y'1 y'2 y'3 y'4)
+ = CreateTable (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default CreateTable where
+ defaultValue = CreateTable P'.defaultValue P'.defaultValue (Prelude'.Just (P'.Utf8 (P'.pack "id"))) (Prelude'.Just 1073741824)
+
+instance P'.Wire CreateTable where
+ wireSize ft' self'@(CreateTable x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeOpt 1 9 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeOpt 1 9 x'3 + P'.wireSizeOpt 1 3 x'4)
+ wirePut ft' self'@(CreateTable x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutOpt 10 9 x'1
+ P'.wirePutReq 26 11 x'2
+ P'.wirePutOpt 34 9 x'3
+ P'.wirePutOpt 40 3 x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{datacenter = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{primary_key = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 40 -> Prelude'.fmap (\ !new'Field -> old'Self{cache_size = Prelude'.Just new'Field}) (P'.wireGet 3)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> CreateTable) CreateTable where
+ getVal m' f' = f' m'
+
+instance P'.GPB CreateTable
+
+instance P'.ReflectDescriptor CreateTable where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [26]) (P'.fromDistinctAscList [10, 26, 34, 40])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.MetaQuery.CreateTable\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"MetaQuery\"], baseName = MName \"CreateTable\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"MetaQuery\",\"CreateTable.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.datacenter\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"datacenter\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.primary_key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"primary_key\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Just \"id\", hsDefault = Just (HsDef'ByteString \"id\")},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.MetaQuery.CreateTable.cache_size\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"MetaQuery\",MName \"CreateTable\"], baseName' = FName \"cache_size\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 40}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Just \"1073741824\", hsDefault = Just (HsDef'Integer 1073741824)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs b/Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs
@@ -0,0 +1,87 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType (MetaQueryType(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data MetaQueryType = CREATE_DB
+ | DROP_DB
+ | LIST_DBS
+ | CREATE_TABLE
+ | DROP_TABLE
+ | LIST_TABLES
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable MetaQueryType
+
+instance Prelude'.Bounded MetaQueryType where
+ minBound = CREATE_DB
+ maxBound = LIST_TABLES
+
+instance P'.Default MetaQueryType where
+ defaultValue = CREATE_DB
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe MetaQueryType
+toMaybe'Enum 1 = Prelude'.Just CREATE_DB
+toMaybe'Enum 2 = Prelude'.Just DROP_DB
+toMaybe'Enum 3 = Prelude'.Just LIST_DBS
+toMaybe'Enum 4 = Prelude'.Just CREATE_TABLE
+toMaybe'Enum 5 = Prelude'.Just DROP_TABLE
+toMaybe'Enum 6 = Prelude'.Just LIST_TABLES
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum MetaQueryType where
+ fromEnum CREATE_DB = 1
+ fromEnum DROP_DB = 2
+ fromEnum LIST_DBS = 3
+ fromEnum CREATE_TABLE = 4
+ fromEnum DROP_TABLE = 5
+ fromEnum LIST_TABLES = 6
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error
+ "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType")
+ . toMaybe'Enum
+ succ CREATE_DB = DROP_DB
+ succ DROP_DB = LIST_DBS
+ succ LIST_DBS = CREATE_TABLE
+ succ CREATE_TABLE = DROP_TABLE
+ succ DROP_TABLE = LIST_TABLES
+ succ _
+ = Prelude'.error
+ "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType"
+ pred DROP_DB = CREATE_DB
+ pred LIST_DBS = DROP_DB
+ pred CREATE_TABLE = LIST_DBS
+ pred DROP_TABLE = CREATE_TABLE
+ pred LIST_TABLES = DROP_TABLE
+ pred _
+ = Prelude'.error
+ "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType"
+
+instance P'.Wire MetaQueryType where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB MetaQueryType
+
+instance P'.MessageAPI msg' (msg' -> MetaQueryType) MetaQueryType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum MetaQueryType where
+ reflectEnum
+ = [(1, "CREATE_DB", CREATE_DB), (2, "DROP_DB", DROP_DB), (3, "LIST_DBS", LIST_DBS), (4, "CREATE_TABLE", CREATE_TABLE),
+ (5, "DROP_TABLE", DROP_TABLE), (6, "LIST_TABLES", LIST_TABLES)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.MetaQuery.MetaQueryType") ["Database", "RethinkDB", "Internal"]
+ ["Query_Language", "MetaQuery"]
+ "MetaQueryType")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "MetaQuery", "MetaQueryType.hs"]
+ [(1, "CREATE_DB"), (2, "DROP_DB"), (3, "LIST_DBS"), (4, "CREATE_TABLE"), (5, "DROP_TABLE"), (6, "LIST_TABLES")]
diff --git a/Database/RethinkDB/Internal/Query_Language/Predicate.hs b/Database/RethinkDB/Internal/Query_Language/Predicate.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Predicate.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Predicate (Predicate(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Predicate = Predicate{arg :: !P'.Utf8, body :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Predicate where
+ mergeAppend (Predicate x'1 x'2) (Predicate y'1 y'2) = Predicate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default Predicate where
+ defaultValue = Predicate P'.defaultValue P'.defaultValue
+
+instance P'.Wire Predicate where
+ wireSize ft' self'@(Predicate x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2)
+ wirePut ft' self'@(Predicate x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutReq 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{arg = new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Predicate) Predicate where
+ getVal m' f' = f' m'
+
+instance P'.GPB Predicate
+
+instance P'.ReflectDescriptor Predicate where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Predicate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Predicate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Predicate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Predicate.arg\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Predicate\"], baseName' = FName \"arg\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Predicate.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Predicate\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Query.hs b/Database/RethinkDB/Internal/Query_Language/Query.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Query.hs
@@ -0,0 +1,80 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Query (Query(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.MetaQuery as Query_Language (MetaQuery)
+import qualified Database.RethinkDB.Internal.Query_Language.Query.QueryType as Query_Language.Query (QueryType)
+import qualified Database.RethinkDB.Internal.Query_Language.ReadQuery as Query_Language (ReadQuery)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as Query_Language (WriteQuery)
+
+data Query = Query{type' :: !Query_Language.Query.QueryType, token :: !P'.Int64, read_query :: !(P'.Maybe Query_Language.ReadQuery),
+ write_query :: !(P'.Maybe Query_Language.WriteQuery), meta_query :: !(P'.Maybe Query_Language.MetaQuery)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Query where
+ mergeAppend (Query x'1 x'2 x'3 x'4 x'5) (Query y'1 y'2 y'3 y'4 y'5)
+ = Query (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+ (P'.mergeAppend x'5 y'5)
+
+instance P'.Default Query where
+ defaultValue = Query P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Query where
+ wireSize ft' self'@(Query x'1 x'2 x'3 x'4 x'5)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeReq 1 3 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 +
+ P'.wireSizeOpt 1 11 x'5)
+ wirePut ft' self'@(Query x'1 x'2 x'3 x'4 x'5)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutReq 16 3 x'2
+ P'.wirePutOpt 26 11 x'3
+ P'.wirePutOpt 34 11 x'4
+ P'.wirePutOpt 42 11 x'5
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{token = new'Field}) (P'.wireGet 3)
+ 26 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{read_query = P'.mergeAppend (read_query old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 34 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{write_query = P'.mergeAppend (write_query old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 42 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{meta_query = P'.mergeAppend (meta_query old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Query) Query where
+ getVal m' f' = f' m'
+
+instance P'.GPB Query
+
+instance P'.ReflectDescriptor Query where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8, 16]) (P'.fromDistinctAscList [8, 16, 26, 34, 42])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Query\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Query\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Query.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Query.QueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Query\"], baseName = MName \"QueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"token\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.read_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"read_query\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.ReadQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"ReadQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.write_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"write_query\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Query.meta_query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Query\"], baseName' = FName \"meta_query\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.MetaQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"MetaQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs b/Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs
@@ -0,0 +1,74 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Query.QueryType (QueryType(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data QueryType = READ
+ | WRITE
+ | CONTINUE
+ | STOP
+ | META
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable QueryType
+
+instance Prelude'.Bounded QueryType where
+ minBound = READ
+ maxBound = META
+
+instance P'.Default QueryType where
+ defaultValue = READ
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe QueryType
+toMaybe'Enum 1 = Prelude'.Just READ
+toMaybe'Enum 2 = Prelude'.Just WRITE
+toMaybe'Enum 3 = Prelude'.Just CONTINUE
+toMaybe'Enum 4 = Prelude'.Just STOP
+toMaybe'Enum 5 = Prelude'.Just META
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum QueryType where
+ fromEnum READ = 1
+ fromEnum WRITE = 2
+ fromEnum CONTINUE = 3
+ fromEnum STOP = 4
+ fromEnum META = 5
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType")
+ . toMaybe'Enum
+ succ READ = WRITE
+ succ WRITE = CONTINUE
+ succ CONTINUE = STOP
+ succ STOP = META
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType"
+ pred WRITE = READ
+ pred CONTINUE = WRITE
+ pred STOP = CONTINUE
+ pred META = STOP
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Query.QueryType"
+
+instance P'.Wire QueryType where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB QueryType
+
+instance P'.MessageAPI msg' (msg' -> QueryType) QueryType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum QueryType where
+ reflectEnum = [(1, "READ", READ), (2, "WRITE", WRITE), (3, "CONTINUE", CONTINUE), (4, "STOP", STOP), (5, "META", META)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.Query.QueryType") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Query"]
+ "QueryType")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "Query", "QueryType.hs"]
+ [(1, "READ"), (2, "WRITE"), (3, "CONTINUE"), (4, "STOP"), (5, "META")]
diff --git a/Database/RethinkDB/Internal/Query_Language/ReadQuery.hs b/Database/RethinkDB/Internal/Query_Language/ReadQuery.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/ReadQuery.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.ReadQuery (ReadQuery(..)) where
+import Prelude ((+), (/), (==), (<=), (&&))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data ReadQuery = ReadQuery{term :: !Query_Language.Term, max_chunk_size :: !(P'.Maybe P'.Int64), max_age :: !(P'.Maybe P'.Int64),
+ ext'field :: !P'.ExtField}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.ExtendMessage ReadQuery where
+ getExtField = ext'field
+ putExtField e'f msg = msg{ext'field = e'f}
+ validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)
+
+instance P'.Mergeable ReadQuery where
+ mergeAppend (ReadQuery x'1 x'2 x'3 x'4) (ReadQuery y'1 y'2 y'3 y'4)
+ = ReadQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default ReadQuery where
+ defaultValue = ReadQuery P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire ReadQuery where
+ wireSize ft' self'@(ReadQuery x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeOpt 1 3 x'2 + P'.wireSizeOpt 1 3 x'3 + P'.wireSizeExtField x'4)
+ wirePut ft' self'@(ReadQuery x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutOpt 16 3 x'2
+ P'.wirePutOpt 24 3 x'3
+ P'.wirePutExtField x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{term = P'.mergeAppend (term old'Self) (new'Field)}) (P'.wireGet 11)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{max_chunk_size = Prelude'.Just new'Field}) (P'.wireGet 3)
+ 24 -> Prelude'.fmap (\ !new'Field -> old'Self{max_age = Prelude'.Just new'Field}) (P'.wireGet 3)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in
+ if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then
+ P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> ReadQuery) ReadQuery where
+ getVal m' f' = f' m'
+
+instance P'.GPB ReadQuery
+
+instance P'.ReflectDescriptor ReadQuery where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 16, 24])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.ReadQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"ReadQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"ReadQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.term\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"term\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.max_chunk_size\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"max_chunk_size\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.ReadQuery.max_age\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"ReadQuery\"], baseName' = FName \"max_age\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Reduction.hs b/Database/RethinkDB/Internal/Query_Language/Reduction.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Reduction.hs
@@ -0,0 +1,65 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Reduction (Reduction(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Reduction = Reduction{base :: !Query_Language.Term, var1 :: !P'.Utf8, var2 :: !P'.Utf8, body :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Reduction where
+ mergeAppend (Reduction x'1 x'2 x'3 x'4) (Reduction y'1 y'2 y'3 y'4)
+ = Reduction (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default Reduction where
+ defaultValue = Reduction P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Reduction where
+ wireSize ft' self'@(Reduction x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 9 x'3 + P'.wireSizeReq 1 11 x'4)
+ wirePut ft' self'@(Reduction x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutReq 26 9 x'3
+ P'.wirePutReq 34 11 x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{base = P'.mergeAppend (base old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{var1 = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{var2 = new'Field}) (P'.wireGet 9)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{body = P'.mergeAppend (body old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Reduction) Reduction where
+ getVal m' f' = f' m'
+
+instance P'.GPB Reduction
+
+instance P'.ReflectDescriptor Reduction where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Reduction\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Reduction\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Reduction.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.base\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"base\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.var1\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"var1\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.var2\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"var2\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Reduction.body\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Reduction\"], baseName' = FName \"body\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Response.hs b/Database/RethinkDB/Internal/Query_Language/Response.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Response.hs
@@ -0,0 +1,74 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Response (Response(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Response.Backtrace as Query_Language.Response (Backtrace)
+import qualified Database.RethinkDB.Internal.Query_Language.Response.StatusCode as Query_Language.Response (StatusCode)
+
+data Response = Response{status_code :: !Query_Language.Response.StatusCode, token :: !P'.Int64, response :: !(P'.Seq P'.Utf8),
+ error_message :: !(P'.Maybe P'.Utf8), backtrace :: !(P'.Maybe Query_Language.Response.Backtrace)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Response where
+ mergeAppend (Response x'1 x'2 x'3 x'4 x'5) (Response y'1 y'2 y'3 y'4 y'5)
+ = Response (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+ (P'.mergeAppend x'5 y'5)
+
+instance P'.Default Response where
+ defaultValue = Response P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Response where
+ wireSize ft' self'@(Response x'1 x'2 x'3 x'4 x'5)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeReq 1 3 x'2 + P'.wireSizeRep 1 9 x'3 + P'.wireSizeOpt 1 9 x'4 +
+ P'.wireSizeOpt 1 11 x'5)
+ wirePut ft' self'@(Response x'1 x'2 x'3 x'4 x'5)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutReq 16 3 x'2
+ P'.wirePutRep 26 9 x'3
+ P'.wirePutOpt 34 9 x'4
+ P'.wirePutOpt 42 11 x'5
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{status_code = new'Field}) (P'.wireGet 14)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{token = new'Field}) (P'.wireGet 3)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{response = P'.append (response old'Self) new'Field}) (P'.wireGet 9)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{error_message = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 42 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{backtrace = P'.mergeAppend (backtrace old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Response) Response where
+ getVal m' f' = f' m'
+
+instance P'.GPB Response
+
+instance P'.ReflectDescriptor Response where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8, 16]) (P'.fromDistinctAscList [8, 16, 26, 34, 42])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Response\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Response\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Response.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.status_code\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"status_code\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Response.StatusCode\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"StatusCode\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"token\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 16}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 3}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.response\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"response\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.error_message\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"error_message\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.backtrace\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\"], baseName' = FName \"backtrace\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Response.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"Backtrace\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs b/Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Response.Backtrace (Backtrace(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data Backtrace = Backtrace{frame :: !(P'.Seq P'.Utf8)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Backtrace where
+ mergeAppend (Backtrace x'1) (Backtrace y'1) = Backtrace (P'.mergeAppend x'1 y'1)
+
+instance P'.Default Backtrace where
+ defaultValue = Backtrace P'.defaultValue
+
+instance P'.Wire Backtrace where
+ wireSize ft' self'@(Backtrace x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeRep 1 9 x'1)
+ wirePut ft' self'@(Backtrace x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutRep 10 9 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{frame = P'.append (frame old'Self) new'Field}) (P'.wireGet 9)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Backtrace) Backtrace where
+ getVal m' f' = f' m'
+
+instance P'.GPB Backtrace
+
+instance P'.ReflectDescriptor Backtrace where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Response.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Response\"], baseName = MName \"Backtrace\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Response\",\"Backtrace.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Response.Backtrace.frame\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Response\",MName \"Backtrace\"], baseName' = FName \"frame\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs b/Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs
@@ -0,0 +1,92 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Response.StatusCode (StatusCode(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data StatusCode = SUCCESS_EMPTY
+ | SUCCESS_JSON
+ | SUCCESS_PARTIAL
+ | SUCCESS_STREAM
+ | BROKEN_CLIENT
+ | BAD_QUERY
+ | RUNTIME_ERROR
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable StatusCode
+
+instance Prelude'.Bounded StatusCode where
+ minBound = SUCCESS_EMPTY
+ maxBound = RUNTIME_ERROR
+
+instance P'.Default StatusCode where
+ defaultValue = SUCCESS_EMPTY
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe StatusCode
+toMaybe'Enum 0 = Prelude'.Just SUCCESS_EMPTY
+toMaybe'Enum 1 = Prelude'.Just SUCCESS_JSON
+toMaybe'Enum 2 = Prelude'.Just SUCCESS_PARTIAL
+toMaybe'Enum 3 = Prelude'.Just SUCCESS_STREAM
+toMaybe'Enum 101 = Prelude'.Just BROKEN_CLIENT
+toMaybe'Enum 102 = Prelude'.Just BAD_QUERY
+toMaybe'Enum 103 = Prelude'.Just RUNTIME_ERROR
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum StatusCode where
+ fromEnum SUCCESS_EMPTY = 0
+ fromEnum SUCCESS_JSON = 1
+ fromEnum SUCCESS_PARTIAL = 2
+ fromEnum SUCCESS_STREAM = 3
+ fromEnum BROKEN_CLIENT = 101
+ fromEnum BAD_QUERY = 102
+ fromEnum RUNTIME_ERROR = 103
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error
+ "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode")
+ . toMaybe'Enum
+ succ SUCCESS_EMPTY = SUCCESS_JSON
+ succ SUCCESS_JSON = SUCCESS_PARTIAL
+ succ SUCCESS_PARTIAL = SUCCESS_STREAM
+ succ SUCCESS_STREAM = BROKEN_CLIENT
+ succ BROKEN_CLIENT = BAD_QUERY
+ succ BAD_QUERY = RUNTIME_ERROR
+ succ _
+ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode"
+ pred SUCCESS_JSON = SUCCESS_EMPTY
+ pred SUCCESS_PARTIAL = SUCCESS_JSON
+ pred SUCCESS_STREAM = SUCCESS_PARTIAL
+ pred BROKEN_CLIENT = SUCCESS_STREAM
+ pred BAD_QUERY = BROKEN_CLIENT
+ pred RUNTIME_ERROR = BAD_QUERY
+ pred _
+ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Response.StatusCode"
+
+instance P'.Wire StatusCode where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB StatusCode
+
+instance P'.MessageAPI msg' (msg' -> StatusCode) StatusCode where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum StatusCode where
+ reflectEnum
+ = [(0, "SUCCESS_EMPTY", SUCCESS_EMPTY), (1, "SUCCESS_JSON", SUCCESS_JSON), (2, "SUCCESS_PARTIAL", SUCCESS_PARTIAL),
+ (3, "SUCCESS_STREAM", SUCCESS_STREAM), (101, "BROKEN_CLIENT", BROKEN_CLIENT), (102, "BAD_QUERY", BAD_QUERY),
+ (103, "RUNTIME_ERROR", RUNTIME_ERROR)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.Response.StatusCode") ["Database", "RethinkDB", "Internal"]
+ ["Query_Language", "Response"]
+ "StatusCode")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "Response", "StatusCode.hs"]
+ [(0, "SUCCESS_EMPTY"), (1, "SUCCESS_JSON"), (2, "SUCCESS_PARTIAL"), (3, "SUCCESS_STREAM"), (101, "BROKEN_CLIENT"),
+ (102, "BAD_QUERY"), (103, "RUNTIME_ERROR")]
diff --git a/Database/RethinkDB/Internal/Query_Language/TableRef.hs b/Database/RethinkDB/Internal/Query_Language/TableRef.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/TableRef.hs
@@ -0,0 +1,62 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.TableRef (TableRef(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data TableRef = TableRef{db_name :: !P'.Utf8, table_name :: !P'.Utf8, use_outdated :: !(P'.Maybe P'.Bool)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable TableRef where
+ mergeAppend (TableRef x'1 x'2 x'3) (TableRef y'1 y'2 y'3)
+ = TableRef (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default TableRef where
+ defaultValue = TableRef P'.defaultValue P'.defaultValue (Prelude'.Just Prelude'.False)
+
+instance P'.Wire TableRef where
+ wireSize ft' self'@(TableRef x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeOpt 1 8 x'3)
+ wirePut ft' self'@(TableRef x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutOpt 24 8 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{db_name = new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{table_name = new'Field}) (P'.wireGet 9)
+ 24 -> Prelude'.fmap (\ !new'Field -> old'Self{use_outdated = Prelude'.Just new'Field}) (P'.wireGet 8)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> TableRef) TableRef where
+ getVal m' f' = f' m'
+
+instance P'.GPB TableRef
+
+instance P'.ReflectDescriptor TableRef where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18, 24])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"TableRef.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.db_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"db_name\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.table_name\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"table_name\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.TableRef.use_outdated\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"TableRef\"], baseName' = FName \"use_outdated\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"false\", hsDefault = Just (HsDef'Bool False)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term.hs b/Database/RethinkDB/Internal/Query_Language/Term.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term.hs
@@ -0,0 +1,150 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term (Term(..)) where
+import Prelude ((+), (/), (==), (<=), (&&))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Term.Call as Query_Language.Term (Call)
+import qualified Database.RethinkDB.Internal.Query_Language.Term.GetByKey as Query_Language.Term (GetByKey)
+import qualified Database.RethinkDB.Internal.Query_Language.Term.If as Query_Language.Term (If)
+import qualified Database.RethinkDB.Internal.Query_Language.Term.Let as Query_Language.Term (Let)
+import qualified Database.RethinkDB.Internal.Query_Language.Term.Table as Query_Language.Term (Table)
+import qualified Database.RethinkDB.Internal.Query_Language.Term.TermType as Query_Language.Term (TermType)
+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as Query_Language (VarTermTuple)
+
+data Term = Term{type' :: !Query_Language.Term.TermType, var :: !(P'.Maybe P'.Utf8), let' :: !(P'.Maybe Query_Language.Term.Let),
+ call :: !(P'.Maybe Query_Language.Term.Call), if_ :: !(P'.Maybe Query_Language.Term.If),
+ error :: !(P'.Maybe P'.Utf8), number :: !(P'.Maybe P'.Double), valuestring :: !(P'.Maybe P'.Utf8),
+ jsonstring :: !(P'.Maybe P'.Utf8), valuebool :: !(P'.Maybe P'.Bool), array :: !(P'.Seq Term),
+ object :: !(P'.Seq Query_Language.VarTermTuple), get_by_key :: !(P'.Maybe Query_Language.Term.GetByKey),
+ table :: !(P'.Maybe Query_Language.Term.Table), javascript :: !(P'.Maybe P'.Utf8), ext'field :: !P'.ExtField}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.ExtendMessage Term where
+ getExtField = ext'field
+ putExtField e'f msg = msg{ext'field = e'f}
+ validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)
+
+instance P'.Mergeable Term where
+ mergeAppend (Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)
+ (Term y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10 y'11 y'12 y'13 y'14 y'15 y'16)
+ = Term (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+ (P'.mergeAppend x'5 y'5)
+ (P'.mergeAppend x'6 y'6)
+ (P'.mergeAppend x'7 y'7)
+ (P'.mergeAppend x'8 y'8)
+ (P'.mergeAppend x'9 y'9)
+ (P'.mergeAppend x'10 y'10)
+ (P'.mergeAppend x'11 y'11)
+ (P'.mergeAppend x'12 y'12)
+ (P'.mergeAppend x'13 y'13)
+ (P'.mergeAppend x'14 y'14)
+ (P'.mergeAppend x'15 y'15)
+ (P'.mergeAppend x'16 y'16)
+
+instance P'.Default Term where
+ defaultValue
+ = Term P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+
+instance P'.Wire Term where
+ wireSize ft' self'@(Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 +
+ P'.wireSizeOpt 1 11 x'5
+ + P'.wireSizeOpt 1 9 x'6
+ + P'.wireSizeOpt 1 1 x'7
+ + P'.wireSizeOpt 1 9 x'8
+ + P'.wireSizeOpt 1 9 x'9
+ + P'.wireSizeOpt 1 8 x'10
+ + P'.wireSizeRep 1 11 x'11
+ + P'.wireSizeRep 1 11 x'12
+ + P'.wireSizeOpt 1 11 x'13
+ + P'.wireSizeOpt 1 11 x'14
+ + P'.wireSizeOpt 2 9 x'15
+ + P'.wireSizeExtField x'16)
+ wirePut ft' self'@(Term x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10 x'11 x'12 x'13 x'14 x'15 x'16)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutOpt 18 9 x'2
+ P'.wirePutOpt 26 11 x'3
+ P'.wirePutOpt 34 11 x'4
+ P'.wirePutOpt 42 11 x'5
+ P'.wirePutOpt 50 9 x'6
+ P'.wirePutOpt 57 1 x'7
+ P'.wirePutOpt 66 9 x'8
+ P'.wirePutOpt 74 9 x'9
+ P'.wirePutOpt 80 8 x'10
+ P'.wirePutRep 90 11 x'11
+ P'.wirePutRep 98 11 x'12
+ P'.wirePutOpt 114 11 x'13
+ P'.wirePutOpt 122 11 x'14
+ P'.wirePutOpt 130 9 x'15
+ P'.wirePutExtField x'16
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{var = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{let' = P'.mergeAppend (let' old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{call = P'.mergeAppend (call old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 42 -> Prelude'.fmap (\ !new'Field -> old'Self{if_ = P'.mergeAppend (if_ old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 50 -> Prelude'.fmap (\ !new'Field -> old'Self{error = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 57 -> Prelude'.fmap (\ !new'Field -> old'Self{number = Prelude'.Just new'Field}) (P'.wireGet 1)
+ 66 -> Prelude'.fmap (\ !new'Field -> old'Self{valuestring = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 74 -> Prelude'.fmap (\ !new'Field -> old'Self{jsonstring = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 80 -> Prelude'.fmap (\ !new'Field -> old'Self{valuebool = Prelude'.Just new'Field}) (P'.wireGet 8)
+ 90 -> Prelude'.fmap (\ !new'Field -> old'Self{array = P'.append (array old'Self) new'Field}) (P'.wireGet 11)
+ 98 -> Prelude'.fmap (\ !new'Field -> old'Self{object = P'.append (object old'Self) new'Field}) (P'.wireGet 11)
+ 114 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{get_by_key = P'.mergeAppend (get_by_key old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 122 -> Prelude'.fmap (\ !new'Field -> old'Self{table = P'.mergeAppend (table old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 130 -> Prelude'.fmap (\ !new'Field -> old'Self{javascript = Prelude'.Just new'Field}) (P'.wireGet 9)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in
+ if Prelude'.or [1000 <= field'Number && field'Number <= 1099] then
+ P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Term) Term where
+ getVal m' f' = f' m'
+
+instance P'.GPB Term
+
+instance P'.ReflectDescriptor Term where
+ getMessageInfo _
+ = P'.GetMessageInfo (P'.fromDistinctAscList [8])
+ (P'.fromDistinctAscList [8, 18, 26, 34, 42, 50, 57, 66, 74, 80, 90, 98, 114, 122, 130])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.TermType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"TermType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.let\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"let'\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Let\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Let\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.call\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"call\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Call\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Call\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.if_\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"if_\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.If\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"If\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.error\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"error\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.number\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"number\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 57}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 1}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.valuestring\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"valuestring\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.jsonstring\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"jsonstring\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.valuebool\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"valuebool\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 80}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.array\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"array\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 90}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.object\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"object\"}, fieldNumber = FieldId {getFieldId = 12}, wireTag = WireTag {getWireTag = 98}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.get_by_key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"get_by_key\"}, fieldNumber = FieldId {getFieldId = 14}, wireTag = WireTag {getWireTag = 114}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.GetByKey\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"GetByKey\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.table\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"table\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term.Table\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Table\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.javascript\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\"], baseName' = FName \"javascript\"}, fieldNumber = FieldId {getFieldId = 16}, wireTag = WireTag {getWireTag = 130}, packedTag = Nothing, wireTagLength = 2, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 1000},FieldId {getFieldId = 1099})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term.hs-boot b/Database/RethinkDB/Internal/Query_Language/Term.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term.hs-boot
@@ -0,0 +1,32 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term (Term) where
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data Term
+
+instance P'.MessageAPI msg' (msg' -> Term) Term
+
+instance Prelude'.Show Term
+
+instance Prelude'.Eq Term
+
+instance Prelude'.Ord Term
+
+instance Prelude'.Typeable Term
+
+instance Prelude'.Data Term
+
+instance P'.Mergeable Term
+
+instance P'.Default Term
+
+instance P'.Wire Term
+
+instance P'.GPB Term
+
+instance P'.ReflectDescriptor Term
+
+instance P'.ExtendMessage Term
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/Call.hs b/Database/RethinkDB/Internal/Query_Language/Term/Call.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/Call.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.Call (Call(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Builtin as Query_Language (Builtin)
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Call = Call{builtin :: !Query_Language.Builtin, args :: !(P'.Seq Query_Language.Term)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Call where
+ mergeAppend (Call x'1 x'2) (Call y'1 y'2) = Call (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default Call where
+ defaultValue = Call P'.defaultValue P'.defaultValue
+
+instance P'.Wire Call where
+ wireSize ft' self'@(Call x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeRep 1 11 x'2)
+ wirePut ft' self'@(Call x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutRep 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{builtin = P'.mergeAppend (builtin old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{args = P'.append (args old'Self) new'Field}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Call) Call where
+ getVal m' f' = f' m'
+
+instance P'.GPB Call
+
+instance P'.ReflectDescriptor Call where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Call\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Call\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Call.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Call.builtin\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Call\"], baseName' = FName \"builtin\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Builtin\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Builtin\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Call.args\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Call\"], baseName' = FName \"args\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs b/Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs
@@ -0,0 +1,65 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.GetByKey (GetByKey(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data GetByKey = GetByKey{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable GetByKey where
+ mergeAppend (GetByKey x'1 x'2 x'3) (GetByKey y'1 y'2 y'3)
+ = GetByKey (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default GetByKey where
+ defaultValue = GetByKey P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire GetByKey where
+ wireSize ft' self'@(GetByKey x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3)
+ wirePut ft' self'@(GetByKey x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutReq 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> GetByKey) GetByKey where
+ getVal m' f' = f' m'
+
+instance P'.GPB GetByKey
+
+instance P'.ReflectDescriptor GetByKey where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.GetByKey\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"GetByKey\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"GetByKey.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.GetByKey.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"GetByKey\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/If.hs b/Database/RethinkDB/Internal/Query_Language/Term/If.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/If.hs
@@ -0,0 +1,64 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.If (If(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data If = If{test :: !Query_Language.Term, true_branch :: !Query_Language.Term, false_branch :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable If where
+ mergeAppend (If x'1 x'2 x'3) (If y'1 y'2 y'3) = If (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default If where
+ defaultValue = If P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire If where
+ wireSize ft' self'@(If x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2 + P'.wireSizeReq 1 11 x'3)
+ wirePut ft' self'@(If x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 11 x'2
+ P'.wirePutReq 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{test = P'.mergeAppend (test old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{true_branch = P'.mergeAppend (true_branch old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{false_branch = P'.mergeAppend (false_branch old'Self) (new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> If) If where
+ getVal m' f' = f' m'
+
+instance P'.GPB If
+
+instance P'.ReflectDescriptor If where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.If\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"If\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"If.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.test\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"test\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.true_branch\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"true_branch\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.If.false_branch\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"If\"], baseName' = FName \"false_branch\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/Let.hs b/Database/RethinkDB/Internal/Query_Language/Term/Let.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/Let.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.Let (Let(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+import qualified Database.RethinkDB.Internal.Query_Language.VarTermTuple as Query_Language (VarTermTuple)
+
+data Let = Let{binds :: !(P'.Seq Query_Language.VarTermTuple), expr :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Let where
+ mergeAppend (Let x'1 x'2) (Let y'1 y'2) = Let (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default Let where
+ defaultValue = Let P'.defaultValue P'.defaultValue
+
+instance P'.Wire Let where
+ wireSize ft' self'@(Let x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeRep 1 11 x'1 + P'.wireSizeReq 1 11 x'2)
+ wirePut ft' self'@(Let x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutRep 10 11 x'1
+ P'.wirePutReq 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{binds = P'.append (binds old'Self) new'Field}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{expr = P'.mergeAppend (expr old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Let) Let where
+ getVal m' f' = f' m'
+
+instance P'.GPB Let
+
+instance P'.ReflectDescriptor Let where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Let\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Let\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Let.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Let.binds\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Let\"], baseName' = FName \"binds\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Let.expr\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Let\"], baseName' = FName \"expr\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/Table.hs b/Database/RethinkDB/Internal/Query_Language/Term/Table.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/Table.hs
@@ -0,0 +1,59 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.Table (Table(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+
+data Table = Table{table_ref :: !Query_Language.TableRef}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Table where
+ mergeAppend (Table x'1) (Table y'1) = Table (P'.mergeAppend x'1 y'1)
+
+instance P'.Default Table where
+ defaultValue = Table P'.defaultValue
+
+instance P'.Wire Table where
+ wireSize ft' self'@(Table x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1)
+ wirePut ft' self'@(Table x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Table) Table where
+ getVal m' f' = f' m'
+
+instance P'.GPB Table
+
+instance P'.ReflectDescriptor Table where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.Term.Table\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"Term\"], baseName = MName \"Table\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"Term\",\"Table.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.Term.Table.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"Term\",MName \"Table\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/Term/TermType.hs b/Database/RethinkDB/Internal/Query_Language/Term/TermType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/Term/TermType.hs
@@ -0,0 +1,134 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.Term.TermType (TermType(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data TermType = JSON_NULL
+ | VAR
+ | LET
+ | CALL
+ | IF
+ | ERROR
+ | NUMBER
+ | STRING
+ | JSON
+ | BOOL
+ | ARRAY
+ | OBJECT
+ | GETBYKEY
+ | TABLE
+ | JAVASCRIPT
+ | IMPLICIT_VAR
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable TermType
+
+instance Prelude'.Bounded TermType where
+ minBound = JSON_NULL
+ maxBound = IMPLICIT_VAR
+
+instance P'.Default TermType where
+ defaultValue = JSON_NULL
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe TermType
+toMaybe'Enum 0 = Prelude'.Just JSON_NULL
+toMaybe'Enum 1 = Prelude'.Just VAR
+toMaybe'Enum 2 = Prelude'.Just LET
+toMaybe'Enum 3 = Prelude'.Just CALL
+toMaybe'Enum 4 = Prelude'.Just IF
+toMaybe'Enum 5 = Prelude'.Just ERROR
+toMaybe'Enum 6 = Prelude'.Just NUMBER
+toMaybe'Enum 7 = Prelude'.Just STRING
+toMaybe'Enum 8 = Prelude'.Just JSON
+toMaybe'Enum 9 = Prelude'.Just BOOL
+toMaybe'Enum 10 = Prelude'.Just ARRAY
+toMaybe'Enum 11 = Prelude'.Just OBJECT
+toMaybe'Enum 12 = Prelude'.Just GETBYKEY
+toMaybe'Enum 13 = Prelude'.Just TABLE
+toMaybe'Enum 14 = Prelude'.Just JAVASCRIPT
+toMaybe'Enum 15 = Prelude'.Just IMPLICIT_VAR
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum TermType where
+ fromEnum JSON_NULL = 0
+ fromEnum VAR = 1
+ fromEnum LET = 2
+ fromEnum CALL = 3
+ fromEnum IF = 4
+ fromEnum ERROR = 5
+ fromEnum NUMBER = 6
+ fromEnum STRING = 7
+ fromEnum JSON = 8
+ fromEnum BOOL = 9
+ fromEnum ARRAY = 10
+ fromEnum OBJECT = 11
+ fromEnum GETBYKEY = 12
+ fromEnum TABLE = 13
+ fromEnum JAVASCRIPT = 14
+ fromEnum IMPLICIT_VAR = 15
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType")
+ . toMaybe'Enum
+ succ JSON_NULL = VAR
+ succ VAR = LET
+ succ LET = CALL
+ succ CALL = IF
+ succ IF = ERROR
+ succ ERROR = NUMBER
+ succ NUMBER = STRING
+ succ STRING = JSON
+ succ JSON = BOOL
+ succ BOOL = ARRAY
+ succ ARRAY = OBJECT
+ succ OBJECT = GETBYKEY
+ succ GETBYKEY = TABLE
+ succ TABLE = JAVASCRIPT
+ succ JAVASCRIPT = IMPLICIT_VAR
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType"
+ pred VAR = JSON_NULL
+ pred LET = VAR
+ pred CALL = LET
+ pred IF = CALL
+ pred ERROR = IF
+ pred NUMBER = ERROR
+ pred STRING = NUMBER
+ pred JSON = STRING
+ pred BOOL = JSON
+ pred ARRAY = BOOL
+ pred OBJECT = ARRAY
+ pred GETBYKEY = OBJECT
+ pred TABLE = GETBYKEY
+ pred JAVASCRIPT = TABLE
+ pred IMPLICIT_VAR = JAVASCRIPT
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.Term.TermType"
+
+instance P'.Wire TermType where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB TermType
+
+instance P'.MessageAPI msg' (msg' -> TermType) TermType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum TermType where
+ reflectEnum
+ = [(0, "JSON_NULL", JSON_NULL), (1, "VAR", VAR), (2, "LET", LET), (3, "CALL", CALL), (4, "IF", IF), (5, "ERROR", ERROR),
+ (6, "NUMBER", NUMBER), (7, "STRING", STRING), (8, "JSON", JSON), (9, "BOOL", BOOL), (10, "ARRAY", ARRAY),
+ (11, "OBJECT", OBJECT), (12, "GETBYKEY", GETBYKEY), (13, "TABLE", TABLE), (14, "JAVASCRIPT", JAVASCRIPT),
+ (15, "IMPLICIT_VAR", IMPLICIT_VAR)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.Term.TermType") ["Database", "RethinkDB", "Internal"] ["Query_Language", "Term"]
+ "TermType")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "Term", "TermType.hs"]
+ [(0, "JSON_NULL"), (1, "VAR"), (2, "LET"), (3, "CALL"), (4, "IF"), (5, "ERROR"), (6, "NUMBER"), (7, "STRING"), (8, "JSON"),
+ (9, "BOOL"), (10, "ARRAY"), (11, "OBJECT"), (12, "GETBYKEY"), (13, "TABLE"), (14, "JAVASCRIPT"), (15, "IMPLICIT_VAR")]
diff --git a/Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs b/Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.VarTermTuple (VarTermTuple(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data VarTermTuple = VarTermTuple{var :: !P'.Utf8, term :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable VarTermTuple where
+ mergeAppend (VarTermTuple x'1 x'2) (VarTermTuple y'1 y'2) = VarTermTuple (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default VarTermTuple where
+ defaultValue = VarTermTuple P'.defaultValue P'.defaultValue
+
+instance P'.Wire VarTermTuple where
+ wireSize ft' self'@(VarTermTuple x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 9 x'1 + P'.wireSizeReq 1 11 x'2)
+ wirePut ft' self'@(VarTermTuple x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 9 x'1
+ P'.wirePutReq 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{var = new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{term = P'.mergeAppend (term old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> VarTermTuple) VarTermTuple where
+ getVal m' f' = f' m'
+
+instance P'.GPB VarTermTuple
+
+instance P'.ReflectDescriptor VarTermTuple where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.VarTermTuple\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"VarTermTuple\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"VarTermTuple.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.VarTermTuple.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"VarTermTuple\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.VarTermTuple.term\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"VarTermTuple\"], baseName' = FName \"term\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery.hs
@@ -0,0 +1,122 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery (WriteQuery(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete as Query_Language.WriteQuery (Delete)
+import {-# SOURCE #-} qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach as Query_Language.WriteQuery (ForEach)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert as Query_Language.WriteQuery (Insert)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate as Query_Language.WriteQuery (Mutate)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete as Query_Language.WriteQuery (PointDelete)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate as Query_Language.WriteQuery (PointMutate)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate as Query_Language.WriteQuery (PointUpdate)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.Update as Query_Language.WriteQuery (Update)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType as Query_Language.WriteQuery (WriteQueryType)
+
+data WriteQuery = WriteQuery{type' :: !Query_Language.WriteQuery.WriteQueryType, atomic :: !(P'.Maybe P'.Bool),
+ update :: !(P'.Maybe Query_Language.WriteQuery.Update),
+ delete :: !(P'.Maybe Query_Language.WriteQuery.Delete),
+ mutate :: !(P'.Maybe Query_Language.WriteQuery.Mutate),
+ insert :: !(P'.Maybe Query_Language.WriteQuery.Insert),
+ for_each :: !(P'.Maybe Query_Language.WriteQuery.ForEach),
+ point_update :: !(P'.Maybe Query_Language.WriteQuery.PointUpdate),
+ point_delete :: !(P'.Maybe Query_Language.WriteQuery.PointDelete),
+ point_mutate :: !(P'.Maybe Query_Language.WriteQuery.PointMutate)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable WriteQuery where
+ mergeAppend (WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10) (WriteQuery y'1 y'2 y'3 y'4 y'5 y'6 y'7 y'8 y'9 y'10)
+ = WriteQuery (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+ (P'.mergeAppend x'5 y'5)
+ (P'.mergeAppend x'6 y'6)
+ (P'.mergeAppend x'7 y'7)
+ (P'.mergeAppend x'8 y'8)
+ (P'.mergeAppend x'9 y'9)
+ (P'.mergeAppend x'10 y'10)
+
+instance P'.Default WriteQuery where
+ defaultValue
+ = WriteQuery P'.defaultValue (Prelude'.Just Prelude'.True) P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+ P'.defaultValue
+
+instance P'.Wire WriteQuery where
+ wireSize ft' self'@(WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeReq 1 14 x'1 + P'.wireSizeOpt 1 8 x'2 + P'.wireSizeOpt 1 11 x'3 + P'.wireSizeOpt 1 11 x'4 +
+ P'.wireSizeOpt 1 11 x'5
+ + P'.wireSizeOpt 1 11 x'6
+ + P'.wireSizeOpt 1 11 x'7
+ + P'.wireSizeOpt 1 11 x'8
+ + P'.wireSizeOpt 1 11 x'9
+ + P'.wireSizeOpt 1 11 x'10)
+ wirePut ft' self'@(WriteQuery x'1 x'2 x'3 x'4 x'5 x'6 x'7 x'8 x'9 x'10)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 8 14 x'1
+ P'.wirePutOpt 18 11 x'3
+ P'.wirePutOpt 26 11 x'4
+ P'.wirePutOpt 34 11 x'5
+ P'.wirePutOpt 42 11 x'6
+ P'.wirePutOpt 58 11 x'7
+ P'.wirePutOpt 66 11 x'8
+ P'.wirePutOpt 74 11 x'9
+ P'.wirePutOpt 82 11 x'10
+ P'.wirePutOpt 88 8 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = new'Field}) (P'.wireGet 14)
+ 88 -> Prelude'.fmap (\ !new'Field -> old'Self{atomic = Prelude'.Just new'Field}) (P'.wireGet 8)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{update = P'.mergeAppend (update old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{delete = P'.mergeAppend (delete old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{mutate = P'.mergeAppend (mutate old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 42 -> Prelude'.fmap (\ !new'Field -> old'Self{insert = P'.mergeAppend (insert old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 58 -> Prelude'.fmap (\ !new'Field -> old'Self{for_each = P'.mergeAppend (for_each old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 66 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{point_update = P'.mergeAppend (point_update old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 74 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{point_delete = P'.mergeAppend (point_delete old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 82 -> Prelude'.fmap
+ (\ !new'Field -> old'Self{point_mutate = P'.mergeAppend (point_mutate old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> WriteQuery) WriteQuery where
+ getVal m' f' = f' m'
+
+instance P'.GPB WriteQuery
+
+instance P'.ReflectDescriptor WriteQuery where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [8]) (P'.fromDistinctAscList [8, 18, 26, 34, 42, 58, 66, 74, 82, 88])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.WriteQueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"WriteQueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.atomic\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"atomic\"}, fieldNumber = FieldId {getFieldId = 11}, wireTag = WireTag {getWireTag = 88}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"true\", hsDefault = Just (HsDef'Bool True)},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.update\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"update\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Update\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Update\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.delete\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"delete\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Delete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Delete\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.mutate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"mutate\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Mutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Mutate\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.insert\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"insert\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Insert\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Insert\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.for_each\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"for_each\"}, fieldNumber = FieldId {getFieldId = 7}, wireTag = WireTag {getWireTag = 58}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.ForEach\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"ForEach\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_update\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_update\"}, fieldNumber = FieldId {getFieldId = 8}, wireTag = WireTag {getWireTag = 66}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointUpdate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointUpdate\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_delete\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_delete\"}, fieldNumber = FieldId {getFieldId = 9}, wireTag = WireTag {getWireTag = 74}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointDelete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointDelete\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.point_mutate\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\"], baseName' = FName \"point_mutate\"}, fieldNumber = FieldId {getFieldId = 10}, wireTag = WireTag {getWireTag = 82}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointMutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointMutate\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete (Delete(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Delete = Delete{view :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Delete where
+ mergeAppend (Delete x'1) (Delete y'1) = Delete (P'.mergeAppend x'1 y'1)
+
+instance P'.Default Delete where
+ defaultValue = Delete P'.defaultValue
+
+instance P'.Wire Delete where
+ wireSize ft' self'@(Delete x'1)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1)
+ wirePut ft' self'@(Delete x'1)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Delete) Delete where
+ getVal m' f' = f' m'
+
+instance P'.GPB Delete
+
+instance P'.ReflectDescriptor Delete where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Delete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Delete\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Delete.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Delete.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Delete\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs
@@ -0,0 +1,64 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach (ForEach(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+import qualified Database.RethinkDB.Internal.Query_Language.WriteQuery as Query_Language (WriteQuery)
+
+data ForEach = ForEach{stream :: !Query_Language.Term, var :: !P'.Utf8, queries :: !(P'.Seq Query_Language.WriteQuery)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable ForEach where
+ mergeAppend (ForEach x'1 x'2 x'3) (ForEach y'1 y'2 y'3)
+ = ForEach (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default ForEach where
+ defaultValue = ForEach P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire ForEach where
+ wireSize ft' self'@(ForEach x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeRep 1 11 x'3)
+ wirePut ft' self'@(ForEach x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutRep 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{stream = P'.mergeAppend (stream old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{var = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{queries = P'.append (queries old'Self) new'Field}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> ForEach) ForEach where
+ getVal m' f' = f' m'
+
+instance P'.GPB ForEach
+
+instance P'.ReflectDescriptor ForEach where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.ForEach\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"ForEach\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"ForEach.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.stream\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"stream\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.var\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"var\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.ForEach.queries\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"ForEach\"], baseName' = FName \"queries\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.WriteQuery\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"WriteQuery\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot b/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot
@@ -0,0 +1,30 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach (ForEach) where
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data ForEach
+
+instance P'.MessageAPI msg' (msg' -> ForEach) ForEach
+
+instance Prelude'.Show ForEach
+
+instance Prelude'.Eq ForEach
+
+instance Prelude'.Ord ForEach
+
+instance Prelude'.Typeable ForEach
+
+instance Prelude'.Data ForEach
+
+instance P'.Mergeable ForEach
+
+instance P'.Default ForEach
+
+instance P'.Wire ForEach
+
+instance P'.GPB ForEach
+
+instance P'.ReflectDescriptor ForEach
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert (Insert(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Insert = Insert{table_ref :: !Query_Language.TableRef, terms :: !(P'.Seq Query_Language.Term),
+ overwrite :: !(P'.Maybe P'.Bool)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Insert where
+ mergeAppend (Insert x'1 x'2 x'3) (Insert y'1 y'2 y'3)
+ = Insert (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default Insert where
+ defaultValue = Insert P'.defaultValue P'.defaultValue (Prelude'.Just Prelude'.False)
+
+instance P'.Wire Insert where
+ wireSize ft' self'@(Insert x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeRep 1 11 x'2 + P'.wireSizeOpt 1 8 x'3)
+ wirePut ft' self'@(Insert x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutRep 18 11 x'2
+ P'.wirePutOpt 24 8 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{terms = P'.append (terms old'Self) new'Field}) (P'.wireGet 11)
+ 24 -> Prelude'.fmap (\ !new'Field -> old'Self{overwrite = Prelude'.Just new'Field}) (P'.wireGet 8)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Insert) Insert where
+ getVal m' f' = f' m'
+
+instance P'.GPB Insert
+
+instance P'.ReflectDescriptor Insert where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10]) (P'.fromDistinctAscList [10, 18, 24])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Insert\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Insert\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Insert.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.terms\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"terms\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Insert.overwrite\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Insert\"], baseName' = FName \"overwrite\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 24}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 8}, typeName = Nothing, hsRawDefault = Just \"false\", hsDefault = Just (HsDef'Bool False)}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate (Mutate(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Mutate = Mutate{view :: !Query_Language.Term, mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Mutate where
+ mergeAppend (Mutate x'1 x'2) (Mutate y'1 y'2) = Mutate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default Mutate where
+ defaultValue = Mutate P'.defaultValue P'.defaultValue
+
+instance P'.Wire Mutate where
+ wireSize ft' self'@(Mutate x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2)
+ wirePut ft' self'@(Mutate x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Mutate) Mutate where
+ getVal m' f' = f' m'
+
+instance P'.GPB Mutate
+
+instance P'.ReflectDescriptor Mutate where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Mutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Mutate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Mutate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Mutate.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Mutate\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Mutate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Mutate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs
@@ -0,0 +1,65 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete (PointDelete(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data PointDelete = PointDelete{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable PointDelete where
+ mergeAppend (PointDelete x'1 x'2 x'3) (PointDelete y'1 y'2 y'3)
+ = PointDelete (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default PointDelete where
+ defaultValue = PointDelete P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire PointDelete where
+ wireSize ft' self'@(PointDelete x'1 x'2 x'3)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3)
+ wirePut ft' self'@(PointDelete x'1 x'2 x'3)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutReq 26 11 x'3
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> PointDelete) PointDelete where
+ getVal m' f' = f' m'
+
+instance P'.GPB PointDelete
+
+instance P'.ReflectDescriptor PointDelete where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26]) (P'.fromDistinctAscList [10, 18, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointDelete\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointDelete\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointDelete.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointDelete.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointDelete\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs
@@ -0,0 +1,69 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate (PointMutate(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data PointMutate = PointMutate{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term,
+ mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable PointMutate where
+ mergeAppend (PointMutate x'1 x'2 x'3 x'4) (PointMutate y'1 y'2 y'3 y'4)
+ = PointMutate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default PointMutate where
+ defaultValue = PointMutate P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire PointMutate where
+ wireSize ft' self'@(PointMutate x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3 + P'.wireSizeReq 1 11 x'4)
+ wirePut ft' self'@(PointMutate x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutReq 26 11 x'3
+ P'.wirePutReq 34 11 x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> PointMutate) PointMutate where
+ getVal m' f' = f' m'
+
+instance P'.GPB PointMutate
+
+instance P'.ReflectDescriptor PointMutate where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointMutate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointMutate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointMutate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointMutate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointMutate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs
@@ -0,0 +1,69 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate (PointUpdate(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+import qualified Database.RethinkDB.Internal.Query_Language.TableRef as Query_Language (TableRef)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data PointUpdate = PointUpdate{table_ref :: !Query_Language.TableRef, attrname :: !P'.Utf8, key :: !Query_Language.Term,
+ mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable PointUpdate where
+ mergeAppend (PointUpdate x'1 x'2 x'3 x'4) (PointUpdate y'1 y'2 y'3 y'4)
+ = PointUpdate (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)
+
+instance P'.Default PointUpdate where
+ defaultValue = PointUpdate P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire PointUpdate where
+ wireSize ft' self'@(PointUpdate x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 9 x'2 + P'.wireSizeReq 1 11 x'3 + P'.wireSizeReq 1 11 x'4)
+ wirePut ft' self'@(PointUpdate x'1 x'2 x'3 x'4)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 9 x'2
+ P'.wirePutReq 26 11 x'3
+ P'.wirePutReq 34 11 x'4
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{table_ref = P'.mergeAppend (table_ref old'Self) (new'Field)})
+ (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{attrname = new'Field}) (P'.wireGet 9)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{key = P'.mergeAppend (key old'Self) (new'Field)}) (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> PointUpdate) PointUpdate where
+ getVal m' f' = f' m'
+
+instance P'.GPB PointUpdate
+
+instance P'.ReflectDescriptor PointUpdate where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18, 26, 34]) (P'.fromDistinctAscList [10, 18, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.PointUpdate\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"PointUpdate\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"PointUpdate.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.table_ref\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"table_ref\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.TableRef\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"TableRef\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.attrname\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"attrname\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"key\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.PointUpdate.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"PointUpdate\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.Update (Update(..)) where
+import Prelude ((+), (/))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+import qualified Database.RethinkDB.Internal.Query_Language.Mapping as Query_Language (Mapping)
+import qualified Database.RethinkDB.Internal.Query_Language.Term as Query_Language (Term)
+
+data Update = Update{view :: !Query_Language.Term, mapping :: !Query_Language.Mapping}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Update where
+ mergeAppend (Update x'1 x'2) (Update y'1 y'2) = Update (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default Update where
+ defaultValue = Update P'.defaultValue P'.defaultValue
+
+instance P'.Wire Update where
+ wireSize ft' self'@(Update x'1 x'2)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeReq 1 11 x'1 + P'.wireSizeReq 1 11 x'2)
+ wirePut ft' self'@(Update x'1 x'2)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ P'.wirePutReq 10 11 x'1
+ P'.wirePutReq 18 11 x'2
+ wireGet ft'
+ = case ft' of
+ 10 -> P'.getBareMessageWith update'Self
+ 11 -> P'.getMessageWith update'Self
+ _ -> P'.wireGetErr ft'
+ where
+ update'Self wire'Tag old'Self
+ = case wire'Tag of
+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{view = P'.mergeAppend (view old'Self) (new'Field)}) (P'.wireGet 11)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{mapping = P'.mergeAppend (mapping old'Self) (new'Field)}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Update) Update where
+ getVal m' f' = f' m'
+
+instance P'.GPB Update
+
+instance P'.ReflectDescriptor Update where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList [10, 18]) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Query_Language.WriteQuery.Update\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\",MName \"WriteQuery\"], baseName = MName \"Update\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Internal\",\"Query_Language\",\"WriteQuery\",\"Update.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Update.view\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Update\"], baseName' = FName \"view\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Query_Language.WriteQuery.Update.mapping\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule' = [MName \"Query_Language\",MName \"WriteQuery\",MName \"Update\"], baseName' = FName \"mapping\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = True, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Query_Language.Mapping\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Internal\"], parentModule = [MName \"Query_Language\"], baseName = MName \"Mapping\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs b/Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs
@@ -0,0 +1,98 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType (WriteQueryType(..)) where
+import Prelude ((+), (/), (.))
+import qualified Prelude as Prelude'
+import qualified Data.Typeable as Prelude'
+import qualified Data.Data as Prelude'
+import qualified Text.ProtocolBuffers.Header as P'
+
+data WriteQueryType = UPDATE
+ | DELETE
+ | MUTATE
+ | INSERT
+ | FOREACH
+ | POINTUPDATE
+ | POINTDELETE
+ | POINTMUTATE
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable WriteQueryType
+
+instance Prelude'.Bounded WriteQueryType where
+ minBound = UPDATE
+ maxBound = POINTMUTATE
+
+instance P'.Default WriteQueryType where
+ defaultValue = UPDATE
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe WriteQueryType
+toMaybe'Enum 1 = Prelude'.Just UPDATE
+toMaybe'Enum 2 = Prelude'.Just DELETE
+toMaybe'Enum 3 = Prelude'.Just MUTATE
+toMaybe'Enum 4 = Prelude'.Just INSERT
+toMaybe'Enum 6 = Prelude'.Just FOREACH
+toMaybe'Enum 7 = Prelude'.Just POINTUPDATE
+toMaybe'Enum 8 = Prelude'.Just POINTDELETE
+toMaybe'Enum 9 = Prelude'.Just POINTMUTATE
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum WriteQueryType where
+ fromEnum UPDATE = 1
+ fromEnum DELETE = 2
+ fromEnum MUTATE = 3
+ fromEnum INSERT = 4
+ fromEnum FOREACH = 6
+ fromEnum POINTUPDATE = 7
+ fromEnum POINTDELETE = 8
+ fromEnum POINTMUTATE = 9
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error
+ "hprotoc generated code: toEnum failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType")
+ . toMaybe'Enum
+ succ UPDATE = DELETE
+ succ DELETE = MUTATE
+ succ MUTATE = INSERT
+ succ INSERT = FOREACH
+ succ FOREACH = POINTUPDATE
+ succ POINTUPDATE = POINTDELETE
+ succ POINTDELETE = POINTMUTATE
+ succ _
+ = Prelude'.error
+ "hprotoc generated code: succ failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType"
+ pred DELETE = UPDATE
+ pred MUTATE = DELETE
+ pred INSERT = MUTATE
+ pred FOREACH = INSERT
+ pred POINTUPDATE = FOREACH
+ pred POINTDELETE = POINTUPDATE
+ pred POINTMUTATE = POINTDELETE
+ pred _
+ = Prelude'.error
+ "hprotoc generated code: pred failure for type Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType"
+
+instance P'.Wire WriteQueryType where
+ wireSize ft' enum = P'.wireSize ft' (Prelude'.fromEnum enum)
+ wirePut ft' enum = P'.wirePut ft' (Prelude'.fromEnum enum)
+ wireGet 14 = P'.wireGetEnum toMaybe'Enum
+ wireGet ft' = P'.wireGetErr ft'
+ wireGetPacked 14 = P'.wireGetPackedEnum toMaybe'Enum
+ wireGetPacked ft' = P'.wireGetErr ft'
+
+instance P'.GPB WriteQueryType
+
+instance P'.MessageAPI msg' (msg' -> WriteQueryType) WriteQueryType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum WriteQueryType where
+ reflectEnum
+ = [(1, "UPDATE", UPDATE), (2, "DELETE", DELETE), (3, "MUTATE", MUTATE), (4, "INSERT", INSERT), (6, "FOREACH", FOREACH),
+ (7, "POINTUPDATE", POINTUPDATE), (8, "POINTDELETE", POINTDELETE), (9, "POINTMUTATE", POINTMUTATE)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Query_Language.WriteQuery.WriteQueryType") ["Database", "RethinkDB", "Internal"]
+ ["Query_Language", "WriteQuery"]
+ "WriteQueryType")
+ ["Database", "RethinkDB", "Internal", "Query_Language", "WriteQuery", "WriteQueryType.hs"]
+ [(1, "UPDATE"), (2, "DELETE"), (3, "MUTATE"), (4, "INSERT"), (6, "FOREACH"), (7, "POINTUPDATE"), (8, "POINTDELETE"),
+ (9, "POINTMUTATE")]
diff --git a/Database/RethinkDB/Internal/Types.hs b/Database/RethinkDB/Internal/Types.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Internal/Types.hs
@@ -0,0 +1,83 @@
+module Database.RethinkDB.Internal.Types (
+ module Database.RethinkDB.Internal.Query_Language.ReadQuery,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.Comparison,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.Map,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.Filter,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.Range,
+ module Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType,
+ module Database.RethinkDB.Internal.Query_Language.Query,
+ module Database.RethinkDB.Internal.Query_Language.Term,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.Update,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate,
+ module Database.RethinkDB.Internal.Query_Language.Response,
+ module Database.RethinkDB.Internal.Query_Language.VarTermTuple,
+ module Database.RethinkDB.Internal.Query_Language.Reduction,
+ module Database.RethinkDB.Internal.Query_Language.Term.Call,
+ module Database.RethinkDB.Internal.Query_Language.Term.Table,
+ module Database.RethinkDB.Internal.Query_Language.Term.GetByKey,
+ module Database.RethinkDB.Internal.Query_Language.Term.Let,
+ module Database.RethinkDB.Internal.Query_Language.Term.If,
+ module Database.RethinkDB.Internal.Query_Language.Term.TermType,
+ module Database.RethinkDB.Internal.Query_Language.Query.QueryType,
+ module Database.RethinkDB.Internal.Query_Language.MetaQuery,
+ module Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType,
+ module Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable,
+ module Database.RethinkDB.Internal.Query_Language.Predicate,
+ module Database.RethinkDB.Internal.Query_Language.Builtin,
+ module Database.RethinkDB.Internal.Query_Language.Response.StatusCode,
+ module Database.RethinkDB.Internal.Query_Language.Response.Backtrace,
+ module Database.RethinkDB.Internal.Query_Language.TableRef,
+ module Database.RethinkDB.Internal.Query_Language.WriteQuery,
+ module Database.RethinkDB.Internal.Query_Language.Mapping,
+ ) where
+
+import Database.RethinkDB.Internal.Query_Language.ReadQuery hiding (ext'field, term)
+import Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap hiding (mapping)
+import Database.RethinkDB.Internal.Query_Language.Builtin.Comparison
+import Database.RethinkDB.Internal.Query_Language.Builtin.Map hiding (mapping)
+import Database.RethinkDB.Internal.Query_Language.Builtin.Filter
+import Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce
+import Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy hiding (attr)
+import Database.RethinkDB.Internal.Query_Language.Builtin.Range hiding (attrname)
+import Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType
+import Database.RethinkDB.Internal.Query_Language.Query hiding (token, type')
+import Database.RethinkDB.Internal.Query_Language.Term hiding (ext'field, type', var)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete hiding (attrname, table_ref, key)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert hiding (table_ref)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Update hiding (mapping, view)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate hiding (key, table_ref, attrname)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete hiding (view)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach hiding (var)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate hiding (mapping, view)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate hiding (key, table_ref, attrname, mapping)
+import Database.RethinkDB.Internal.Query_Language.Response hiding (token)
+import Database.RethinkDB.Internal.Query_Language.VarTermTuple hiding (var, term)
+import Database.RethinkDB.Internal.Query_Language.Reduction hiding (body)
+import Database.RethinkDB.Internal.Query_Language.Term.Call
+import Database.RethinkDB.Internal.Query_Language.Term.Table hiding (table_ref)
+import Database.RethinkDB.Internal.Query_Language.Term.GetByKey hiding (key, table_ref, attrname)
+import Database.RethinkDB.Internal.Query_Language.Term.Let
+import Database.RethinkDB.Internal.Query_Language.Term.If
+import Database.RethinkDB.Internal.Query_Language.Term.TermType
+import Database.RethinkDB.Internal.Query_Language.Query.QueryType
+import Database.RethinkDB.Internal.Query_Language.MetaQuery hiding (type', db_name)
+import Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType
+import Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable hiding (table_ref)
+import Database.RethinkDB.Internal.Query_Language.Predicate hiding (body, arg)
+import Database.RethinkDB.Internal.Query_Language.Builtin hiding (attr, type')
+import Database.RethinkDB.Internal.Query_Language.Response.StatusCode
+import Database.RethinkDB.Internal.Query_Language.Response.Backtrace
+import Database.RethinkDB.Internal.Query_Language.TableRef hiding (db_name)
+import Database.RethinkDB.Internal.Query_Language.WriteQuery hiding (type')
+import Database.RethinkDB.Internal.Query_Language.Mapping hiding (arg, body, ext'field)
diff --git a/Database/RethinkDB/Types.hs b/Database/RethinkDB/Types.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Types.hs
@@ -0,0 +1,20 @@
+-- | Some seperate types to solve problems with recursive modules
+module Database.RethinkDB.Types where
+
+-- | The type of a RQL expression
+--
+-- The type hierarchy has 3 branches:
+--
+-- - A read-only sequence: @StreamType False@
+--
+-- - A selection (also called a view): @StreamType True@
+--
+-- - A value (a JSON object, array or primitive type): @ExprType@
+
+data ExprTypeKind =
+ StreamType Bool ValueTypeKind -- ^ When the flag is true, it can be updated or deleted
+ | ValueType ValueTypeKind
+
+-- | The types of values
+data ValueTypeKind = NumberType | BoolType | ObjectType | ArrayType |
+ StringType | NoneType | OtherValueType
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,15 @@
+RethinkDB Language Drivers for Haskell
+
+Copyright 2012 Etienne Laurin
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this product except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/rethinkdb.cabal b/rethinkdb.cabal
new file mode 100644
--- /dev/null
+++ b/rethinkdb.cabal
@@ -0,0 +1,76 @@
+name: rethinkdb
+version: 0.1.0.0
+synopsis: RethinkDB client library for haskell
+description: This library is modelled upon the official RethinkDB API for
+ Python and Javascript.
+homepage: http://code.atnnn.com/projects/haskell-rethinkdb
+license: OtherLicense
+license-file: LICENSE
+author: Etienne Laurin
+maintainer: Etienne Laurin
+category: Database
+build-type: Simple
+cabal-version: >=1.8
+
+source-repository head
+ type: darcs
+ location: http://code.atnnn.com/darcs/rethinkdb
+
+library
+ exposed-modules: Database.RethinkDB,
+ Database.RethinkDB.Driver,
+ Database.RethinkDB.Functions,
+ Database.RethinkDB.Types
+ other-modules: Database.RethinkDB.Internal.Query_Language.Builtin,
+ Database.RethinkDB.Internal.Query_Language.Builtin.BuiltinType,
+ Database.RethinkDB.Internal.Query_Language.Builtin.Comparison,
+ Database.RethinkDB.Internal.Query_Language.Builtin.ConcatMap,
+ Database.RethinkDB.Internal.Query_Language.Builtin.Filter,
+ Database.RethinkDB.Internal.Query_Language.Builtin.GroupedMapReduce,
+ Database.RethinkDB.Internal.Query_Language.Builtin.Map,
+ Database.RethinkDB.Internal.Query_Language.Builtin.OrderBy,
+ Database.RethinkDB.Internal.Query_Language.Builtin.Range,
+ Database.RethinkDB.Internal.Query_Language.Mapping,
+ Database.RethinkDB.Internal.Query_Language.MetaQuery,
+ Database.RethinkDB.Internal.Query_Language.MetaQuery.CreateTable,
+ Database.RethinkDB.Internal.Query_Language.MetaQuery.MetaQueryType,
+ Database.RethinkDB.Internal.Query_Language.Predicate,
+ Database.RethinkDB.Internal.Query_Language.Query,
+ Database.RethinkDB.Internal.Query_Language.Query.QueryType,
+ Database.RethinkDB.Internal.Query_Language.ReadQuery,
+ Database.RethinkDB.Internal.Query_Language.Reduction,
+ Database.RethinkDB.Internal.Query_Language.Response,
+ Database.RethinkDB.Internal.Query_Language.Response.Backtrace,
+ Database.RethinkDB.Internal.Query_Language.Response.StatusCode,
+ Database.RethinkDB.Internal.Query_Language.TableRef,
+ Database.RethinkDB.Internal.Query_Language.Term,
+ Database.RethinkDB.Internal.Query_Language.Term.Call,
+ Database.RethinkDB.Internal.Query_Language.Term.GetByKey,
+ Database.RethinkDB.Internal.Query_Language.Term.If,
+ Database.RethinkDB.Internal.Query_Language.Term.Let,
+ Database.RethinkDB.Internal.Query_Language.Term.Table,
+ Database.RethinkDB.Internal.Query_Language.Term.TermType,
+ Database.RethinkDB.Internal.Query_Language.VarTermTuple,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.Delete,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.ForEach,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.Insert,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.Mutate,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.PointDelete,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.PointMutate,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.PointUpdate,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.Update,
+ Database.RethinkDB.Internal.Query_Language.WriteQuery.WriteQueryType,
+ Database.RethinkDB.Internal.Types
+ build-depends: base >= 4.6 && < 5,
+ protocol-buffers >= 2,
+ unordered-containers,
+ text,
+ aeson,
+ bytestring,
+ containers,
+ attoparsec,
+ data-default,
+ network,
+ ghc-prim >= 0.3,
+ mtl