diff --git a/Database/RethinkDB.hs b/Database/RethinkDB.hs
--- a/Database/RethinkDB.hs
+++ b/Database/RethinkDB.hs
@@ -1,100 +1,113 @@
-
--- | RethinkDB client library for Haskell
---
--- Modelled upon the official Javascript and Python API:
---
+-- | Haskell client driver for RethinkDB
+--
+-- Based upon the official Javascript, Python and Ruby API:
+--
-- /How to use/
---
--- >>> import Database.RethinkDB
--- >>> import qualified Database.RethinkDB.Functions as R
+--
+-- >>> {-# LANGUAGE OverloadedStrings #-}
+-- >>> import Database.RethinkDB as R
module Database.RethinkDB (
-
-- * Accessing RethinkDB
-
+
RethinkDBHandle,
- openConnection,
- closeConnection,
+ connect,
+ close,
use,
- run, runMaybe, runEither, runRaw, runJSON, runBatch,
- next, collect, resultsError,
-
+ run, run', runOpts,
+ next, collect,
+ Cursor,
+ Response,
+ Result(..),
+ RethinkDBError(..),
+ SuccessCode(..),
+ ErrorCode(..),
+
-- * Manipulating databases
-
+
Database(..),
- db, dbCreate, dbDrop, dbList,
-
+ db, dbCreate, dbDrop, dbList,
+
-- * Manipulating Tables
-
- Table(..), tablePrimaryAttr, TableCreateOptions(..),
+
+ Table(..), TableCreateOptions(..),
table, tableCreate, tableDrop, tableList,
-
+ indexCreate, indexDrop, indexList,
+
-- * Writing data
-
- Document(..),
- insert, insertMany, upsert, upsertMany,
+
+ insert, upsert,
update, replace, delete,
-
+ returnVals,
+
-- * Selecting data
-
- get, filter', between,
-
+
+ get, filter, between, getAll,
+
-- * Joins
-
- innerJoin, outerJoin, eqJoin, zip',
-
+
+ innerJoin, outerJoin, eqJoin, mergeRightLeft,
+
-- * Transformations
-
- map', concatMap', orderBy, skip, limit,
- slice, nth, pluck, without, union',
+
+ map, withFields, concatMap, drop, take,
+ (!!), slice,
+ orderBy, Order(..),
+ indexesOf, isEmpty, (++), sample,
-- * Aggregation
-
- reduce, count, distinct, groupedMapReduce, groupBy',
-
- -- * Reductions
-
- count', sum', avg,
-
+
+ reduce, reduce1, distinct, groupBy, member,
+
+ -- * Aggregators
+
+ length, sum, avg,
+
-- * Document manipulation
+
+ pluck, without,
+ merge, append,
+ prepend, (\\),
+ setInsert, setUnion, setIntersection, setDifference,
+ (!), hasFields,
+ insertAt, spliceAt, deleteAt, changeAt, keys,
+
+ -- * Math and logic
+
+ (+), (-), (*), (/), mod, (&&), (||),
+ (==), (!=), (>), (<), (<=), (>=), not,
+
+ -- * String manipulation
- pick, unpick, merge, append, (!), (!?),
+ (=~),
- -- * Operators
+ -- * Dates and times
- concat,
- add, sub, mul, div', mod, and', or',
- eq, ne, gt, ge, lt, le, not',
+ UTCTime, ZonedTime,
+ now, time, epochTime, iso8601, inTimezone, during,
+ timezone, date, timeOfDay, year, month, day, dayOfWeek, dayOfYear, hours, minutes, seconds,
+ toIso8601, toEpochTime,
-- * 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
+ apply, Javascript(js), if', forEach, error,
+ handle, Expr(..), coerceTo,
+ asArray, asString, asNumber, asObject, asBool,
+ typeOf, info, json,
- 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
+ -- * Helpers
+
+ Obj(..), Object, Attribute(..), str, num, (.), (#),
+ def
+
) where
import Prelude ()
-import Database.RethinkDB.Types
+import Database.RethinkDB.ReQL
+import Database.RethinkDB.Network
+import Database.RethinkDB.Objects
import Database.RethinkDB.Driver
import Database.RethinkDB.Functions
+import Database.RethinkDB.Time
+import Data.Default
diff --git a/Database/RethinkDB/Driver.hs b/Database/RethinkDB/Driver.hs
--- a/Database/RethinkDB/Driver.hs
+++ b/Database/RethinkDB/Driver.hs
@@ -1,1224 +1,89 @@
-{-# 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) ++ "]"
+module Database.RethinkDB.Driver (
+ run,
+ run',
+ Result(..),
+ runOpts,
+ RunOptions(..),
+ ) where
+
+import Data.Aeson (Value, FromJSON, fromJSON)
+import qualified Data.Aeson (Result(Error, Success))
+import Control.Monad
+import Control.Concurrent.MVar (MVar, takeMVar)
+import Data.Sequence ((|>))
+
+import Database.RethinkDB.Protobuf.Ql2.Query (Query(..))
+import Database.RethinkDB.Protobuf.Ql2.Query.AssocPair (AssocPair(..))
+import Database.RethinkDB.Protobuf.Ql2.Term as Term (Term(..))
+import Database.RethinkDB.Protobuf.Ql2.Term.TermType
+import Database.RethinkDB.Protobuf.Ql2.Datum as Datum
+import Database.RethinkDB.Protobuf.Ql2.Datum.DatumType
+import Text.ProtocolBuffers.Basic (uFromString, defaultValue)
+
+import Database.RethinkDB.Network
+import Database.RethinkDB.ReQL
+
+-- | Per-query settings
+data RunOptions =
+ UseOutdated |
+ NoReply |
+ SoftDurability Bool
+
+applyOption :: RunOptions -> Query -> Query
+applyOption UseOutdated q = addQueryOption q "user_outdated" True
+applyOption NoReply q = addQueryOption q "noreply" True
+applyOption (SoftDurability b) q = addQueryOption q "soft_durability" b
+
+addQueryOption :: Query -> String -> Bool -> Query
+addQueryOption q k v = q {
+ global_optargs = global_optargs q |> AssocPair (Just $ uFromString k) (Just boolTrue) }
+ where
+ boolTrue = defaultValue{
+ Term.type' = Just DATUM, datum = Just defaultValue{
+ Datum.type' = Just R_BOOL, r_bool = Just v } }
+
+-- | Run a query with the given options
+runOpts :: (Expr query, Result r) => RethinkDBHandle -> [RunOptions] -> query -> IO r
+runOpts h opts t = do
+ let (q, bt) = buildQuery (expr t) 0 (rdbDatabase h)
+ let q' = foldr (fmap . applyOption) id opts q
+ r <- runQLQuery h q' bt
+ convertResult r
+
+-- | Run a given query and return a Result
+run :: (Expr query, Result r) => RethinkDBHandle -> query -> IO r
+run h = runOpts h []
+
+-- | Run a given query and return a Value
+run' :: Expr query => RethinkDBHandle -> query -> IO [Value]
+run' h t = do
+ c <- run h t
+ collect c
+
+-- | Convert the raw query response into useful values
+class Result r where
+ convertResult :: MVar Response -> IO r
+
+instance Result Response where
+ convertResult = takeMVar
+
+instance FromJSON a => Result (Cursor a) where
+ convertResult r = fmap (fmap $ unsafe . fromJSON) $ makeCursor r
+ where
+ unsafe (Data.Aeson.Error e) = error e
+ unsafe (Data.Aeson.Success a) = a
+
+instance FromJSON a => Result [a] where
+ convertResult = collect <=< convertResult
+
+instance FromJSON a => Result (Maybe a) where
+ convertResult r = do
+ c <- convertResult r
+ car <- next c
+ case car of
+ Nothing -> return Nothing
+ Just a -> do
+ cadr <- next c
+ case cadr of
+ Nothing -> return $ Just a
+ Just _ -> return Nothing
diff --git a/Database/RethinkDB/Driver.hs-boot b/Database/RethinkDB/Driver.hs-boot
deleted file mode 100644
--- a/Database/RethinkDB/Driver.hs-boot
+++ /dev/null
@@ -1,13 +0,0 @@
-{-# 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
--- a/Database/RethinkDB/Functions.hs
+++ b/Database/RethinkDB/Functions.hs
@@ -1,437 +1,399 @@
-{-# LANGUAGE DataKinds, TypeFamilies, ConstraintKinds, FlexibleInstances,
- FlexibleContexts, TypeOperators, ViewPatterns #-}
+{-# LANGUAGE FlexibleInstances, OverloadedStrings #-}
+-- TODO: operator fixity
+
-- | Functions from the ReQL (RethinkDB Query Language)
module Database.RethinkDB.Functions where
-import Database.RethinkDB.Types
-import Database.RethinkDB.Driver
+import Data.Text (Text)
+import Control.Monad.State
+import Control.Applicative
+import Data.Maybe
-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 Database.RethinkDB.ReQL
+import Database.RethinkDB.MapReduce
+import Database.RethinkDB.Objects as O
+import Database.RethinkDB.Protobuf.Ql2.Term.TermType
+
+import Prelude (($), return, Double, Bool, String)
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
+-- | Arithmetic Operator
+(+), (-), (*), (/), mod
+ :: (Expr a, Expr b) => a -> b -> ReQL
+(+) a b = op ADD (a, b) ()
+(-) a b = op SUB (a, b) ()
+(*) a b = op MUL (a, b) ()
+(/) a b = op DIV (a, b) ()
+mod a b = op MOD (a, b) ()
--- * Numbers, Booleans and Comparisons
+-- | Boolean operator
+(||), (&&) :: (Expr a, Expr b) => a -> b -> ReQL
+a || b = op ANY (a, b) ()
+a && b = op ALL (a, b) ()
-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
+-- | Comparison operator
+(==), (!=) :: (Expr a, Expr b) => a -> b -> ReQL
+a == b = op EQ (a, b) ()
+a != b = op NE (a, b) ()
-(+), add, (-), sub, (*), mul, (/), div', mod, mod'
- :: (HaveValueType a b NumberType) => a -> b -> NumberExpr
+-- | Comparison operator
+(>), (>=), (<), (<=)
+ :: (Expr a, Expr b) => a -> b -> ReQL
+a > b = op GT (a, b) ()
+a < b = op LT (a, b) ()
+a >=b = op GE (a, b) ()
+a <=b = op LE (a, b) ()
-(+) 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' = (/)
+-- | Negation
+not :: (Expr a) => a -> ReQL
+not a = op NOT [a] ()
-mod a b = simpleOp QL.MODULO [value a, value b]
-mod' = mod
+-- * Lists and Streams
-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
+-- | The size of a sequence or an array
+-- Called /count/ in the official drivers
+length :: (Expr a) => a -> ReQL
+length e = op COUNT [e] ()
-(==), (!=), 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
+-- | Join two sequences.
+-- Called /union/ in the official drivers
+(++) :: (Expr a, Expr b) => a -> b -> ReQL
+a ++ b = op UNION (a, b) ()
-(>), (>=), (<), (<=), 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
+-- | Map a function over a sequence
+map :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL
+map f a = op MAP (a, expr P.. f) ()
-not, not' :: HasValueType a BoolType => a -> BoolExpr
-not a = simpleOp QL.NOT [value a]
-not' = not
+-- | Filter a sequence given a predicate
+filter :: (Expr predicate, Expr seq) => predicate -> seq -> ReQL
+filter f a = op FILTER (a, f) ()
--- * Lists and Streams
+-- | Query all the documents whose value for the given index is in a given range
+between :: (Expr left, Expr right, Expr seq) => Key -> left -> right -> seq -> ReQL
+between i a b e = op BETWEEN [e] ["left_bound" := a, "right_bound" := b, "index" := i]
-length, count :: (ToExpr e, Sequence (ExprType e)) => e -> NumberExpr
-count e = simpleOp QL.LENGTH [expr e]
-length = count
+-- | Append a datum to a sequence
+append :: (Expr a, Expr b) => a -> b -> ReQL
+append a b = op APPEND (b, a) ()
-(++), concat :: (HaveValueType a b v, CanConcat v) => a -> b -> Expr (ValueType v)
-(++) a b = simpleOp QL.ADD [value a, value b]
-concat = (++)
+-- | Map a function of a sequence and concat the results
+concatMap :: (Expr a, Expr b) => (ReQL -> b) -> a -> ReQL
+concatMap f e = op CONCATMAP (e, expr P.. f) ()
-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 }
+-- | SQL-like join of two sequences. Returns each pair of rows that satisfy the 2-ary predicate.
+innerJoin, outerJoin :: (Expr a, Expr b, Expr c) => (ReQL -> ReQL -> c) -> a -> b -> ReQL
+innerJoin f a b = op INNER_JOIN (a, b, fmap expr P.. f) ()
+outerJoin f a b = op OUTER_JOIN (a, b, fmap expr P.. f) ()
-map' = map
+-- | An efficient iner_join that uses a key for the first table and an index for the left table.
+eqJoin :: (Expr a, Expr b) => Key -> a -> Key -> b -> ReQL
+eqJoin a i k b = op EQ_JOIN (b, k, a) ["index" := i]
--- | 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 }
+-- | Drop elements from the head of a sequence
+-- Called /skip/ in the official drivers
+drop :: (Expr a, Expr b) => a -> b -> ReQL
+drop a b = op SKIP (b, a) ()
-filter = filter'
+-- | Limit the size of a sequence
+-- Called /limit/ in the official drivers
+take :: (Expr a, Expr b) => a -> b -> ReQL
+take a b = op LIMIT (a, b) ()
--- | 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) }
+-- | Cut out part of a sequence
+slice :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL
+slice n m s = op SLICE (s, n, m) ()
-append :: (HasValueType a ArrayType, HasValueType b x) => a -> b -> ArrayExpr
-append a b = simpleOp QL.ARRAYAPPEND [value a, value b]
+-- | Get the nth value of a sequence or array
+(!!) :: (Expr a) => a -> ReQL -> ReQL
+s !! n = op NTH (s, n) ()
-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 }
+-- | Reduce a sequence to a single value
+reduce :: (Expr base, Expr seq, Expr a) => (ReQL -> ReQL -> a) -> base -> seq -> ReQL
+reduce f b s = op REDUCE (s, fmap expr P.. f) ["base" := b]
-concatMap' = concatMap
+-- | Reduce a non-empty sequence to a single value
+reduce1 :: (Expr a, Expr s) => (ReQL -> ReQL -> a) -> s -> ReQL
+reduce1 f s = op REDUCE (s, fmap expr P.. f) ()
-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))
+-- | Filter out identical elements of the sequence
+distinct :: (Expr s) => s -> ReQL
+distinct s = op DISTINCT [s] ()
-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]]))
+-- | Like map but for write queries
+forEach :: (Expr s, Expr a) => s -> (ReQL -> a) -> ReQL
+forEach s f = op FOREACH (s, expr P.. f) ()
-asArray :: ToExpr e => e -> ArrayExpr
-asArray e = mkExpr $ expr e
+-- | Merge the "left" and "right" attributes of the objects in a sequence
+-- Called /zip/ in the official drivers
+mergeRightLeft :: (Expr a) => a -> ReQL
+mergeRightLeft a = op ZIP [a] ()
-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
+-- | Oredering specification for orderBy
+data Order =
+ Asc { orderAttr :: Key } |
+ Desc { orderAttr :: Key }
-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
+-- | Order a sequence by the given keys
+orderBy :: (Expr s) => [Order] -> s -> ReQL
+orderBy o s = ReQL $ do
+ s' <- baseReQL (expr s)
+ o' <- baseArray $ arr $ P.map buildOrder o
+ return $ BaseReQL ORDERBY P.Nothing (s' : o') []
+ where
+ buildOrder (Asc k) = op ASC [k] ()
+ buildOrder (Desc k) = op DESC [k] ()
-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
+-- | Turn a grouping function and a reduction function into a grouped map reduce operation
+groupBy ::
+ (Expr group, Expr reduction, Expr seq)
+ => (ReQL -> group) -> (ReQL -> reduction) -> seq -> ReQL
+groupBy g mr s = ReQL $ do
+ (m, r, f) <- termToMapReduce (expr . mr)
+ baseReQL $ map (f . (!"reduction")) $
+ op GROUPED_MAP_REDUCE [expr s, expr $ expr P.. g, expr m, expr r] ()
-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)
+-- | The sum of a sequence
+sum :: (Expr s) => s -> ReQL
+sum = reduce ((+) :: ReQL -> ReQL -> ReQL) (0 :: ReQL)
-(!!), 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 average of a sequence
+avg :: (Expr s) => s -> ReQL
+avg = (\x -> (x!!0) / (x!!1)) .
+ reduce (\a b -> [(a!!0) + (b!!0), (a!!1) + (b!!1)]) [num 0, num 0] .
+ map (\x -> [x, 1])
--- | The empty list expression
-nil :: ValueExpr ArrayType
-nil = toExpr ([] :: [()])
+-- * Accessors
-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
+-- | Get a single field form an object
+(!) :: (Expr s) => s -> ReQL -> ReQL
+s ! k = op GET_FIELD (s, k) ()
--- | A fold
---
--- >>> run h $ reduce [1,2,3] (0 :: Int) (+)
--- 6
+-- | Keep only the given attributes
+pluck :: (Expr o) => [ReQL] -> o -> ReQL
+pluck ks e = op PLUCK (cons e $ arr (P.map expr ks)) ()
-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 } }
+-- | Remove the given attributes from an object
+without :: (Expr o) => [ReQL] -> o -> ReQL
+without ks e = op WITHOUT (cons e $ arr (P.map expr ks)) ()
-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
+-- | Test if an object contains the given attribute
+-- Called /contains/ in the official drivers
+member :: (Expr o) => [ReQL] -> o -> ReQL
+member ks o = op CONTAINS (cons o $ arr (P.map expr ks)) ()
-distinct :: (ToStream e, v `HasToStreamValueOf` e) =>
- e -> Expr (StreamType False v)
-distinct e = simpleOp QL.DISTINCT [stream e]
+-- | Merge two objects together
+merge :: (Expr a, Expr b) => a -> b -> ReQL
+merge a b = op MERGE (a, b) ()
--- 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 }} }
+-- | Create a javascript expression
+class Javascript r where
+ js :: P.String -> r
--- | Execute a write query for each element of the stream
---
--- >>> run h $ forEach [1,2,3::Int] (\x -> insert (table "fruits") (obj ["n" := x]))
+instance Javascript ReQL where
+ js s = op JAVASCRIPT [str s] ()
-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_ ())
+instance Javascript (ReQL -> ReQL) where
+ js s x = op FUNCALL (op JAVASCRIPT [str s] (), x) ()
-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
+instance Javascript (ReQL -> ReQL -> ReQL) where
+ js s x y = op FUNCALL (op JAVASCRIPT [str s] (), x, y) ()
-data Order = Asc { orderAttr :: String }
- | Desc { orderAttr :: String }
+-- | Called /branch/ in the official drivers
+if' :: (Expr a, Expr b, Expr c) => a -> b -> c -> ReQL
+if' a b c = op BRANCH (a, b, c) ()
-orderAscending :: Order -> Bool
-orderAscending Asc {} = True
-orderAscending Desc {} = False
+error :: (Expr s) => s -> ReQL
+error m = op ERROR [m] ()
-class ToOrder a where toOrder :: a -> Order
-instance ToOrder String where toOrder = Asc
-instance ToOrder Order where toOrder o = o
+-- | Create a Database reference
+db :: Text -> O.Database
+db s = O.Database s
-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 }}
+-- | Create a database on the server
+dbCreate :: P.String -> ReQL
+dbCreate db_name = op DB_CREATE [str db_name] ()
-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
+-- | Drop a database
+dbDrop :: Database -> ReQL
+dbDrop (O.Database name) = op DB_DROP [name] ()
-data MapReduce a b c d = MapReduce (ValueExpr a -> ValueExpr b) (ValueExpr c)
- (ValueExpr c -> ValueExpr b -> ValueExpr c)
- (ValueExpr c -> ValueExpr d)
+-- | List the databases on the server
+dbList :: ReQL
+dbList = op DB_LIST () ()
-sum, sum' :: String -> MapReduce ObjectType NumberType NumberType NumberType
-sum a = MapReduce (! a) 0 (+) P.id
-sum' = sum
+-- | Create an index on the table from the given function
+indexCreate :: (Expr fun) => P.String -> fun -> Table -> ReQL
+indexCreate name f tbl = op INDEX_CREATE (tbl, str name, f) ()
-count' :: MapReduce ObjectType NoneType NumberType NumberType
-count' = MapReduce (P.const (toExpr ())) 0 (\x _ -> x + (1 :: Int)) P.id
+-- | Drop an index
+indexDrop :: Key -> Table -> ReQL
+indexDrop name tbl = op INDEX_DROP (tbl, name) ()
-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))))
+-- | List the indexes on the table
+indexList :: Table -> ReQL
+indexList tbl = op INDEX_LIST [tbl] ()
--- * Accessors
+-- | Retreive documents by their indexed value
+getAll :: (Expr value) => Key -> [value] -> Table -> ReQL
+getAll idx xs tbl = op GET_ALL (expr tbl : P.map expr xs) ["index" := idx]
--- | 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
+-- | Create a simple table refence with no associated database
+table :: Text -> Table
+table n = O.Table Nothing n Nothing
-(!) :: (ToExpr a, ExprValueType a ~ ObjectType) => a -> String -> ValueExpr t
-(!) a b = mkExpr $ rapply [expr a] (op QL.GETATTR) {
- QLBuiltin.attr = Just (uFromString b) }
+-- | Create a table on the server
+tableCreate :: Table -> TableCreateOptions -> ReQL
+tableCreate (O.Table mdb table_name pkey) opts =
+ withQuerySettings $ \QuerySettings{ queryDefaultDatabase = ddb } ->
+ op TABLE_CREATE (fromMaybe ddb mdb, table_name) $ catMaybes [
+ ("datacenter" :=) <$> tableDataCenter opts,
+ ("cache_size" :=) <$> tableCacheSize opts,
+ ("primary_key" :=) <$> pkey ]
-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 }
+-- | Drop a table
+tableDrop :: Table -> ReQL
+tableDrop (O.Table mdb table_name _) =
+ withQuerySettings $ \QuerySettings{ queryDefaultDatabase = ddb } ->
+ op TABLE_DROP (fromMaybe ddb mdb, table_name) ()
-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 }
+-- | List the tables in a database
+tableList :: Database -> ReQL
+tableList (O.Database name) = op DB_LIST [name] ()
-(!?) :: (HasValueType a ObjectType) => a -> String -> BoolExpr
-(!?) a b = mkExpr $ rapply [value a] (op QL.HASATTR) {
- QLBuiltin.attr = Just $ uFromString b }
+-- | Get a document by primary key
+get :: (Expr s, Expr k) => k -> s -> ReQL
+get k e = op GET (e, k) ()
-pluck :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
- [String] -> e -> Expr (StreamType False ObjectType)
-pluck ks = map (pick ks)
+-- | Insert a document or a list of documents into a table
+insert :: (Expr table, Expr object) => object -> table -> ReQL
+insert a tb = op INSERT (tb, a) ()
-without :: (ToStream e, ObjectType `HasToStreamValueOf` e) =>
- [String] -> e -> Expr (StreamType False ObjectType)
-without ks = map (unpick ks)
+-- | Like insert, but update existing documents with the same primary key
+upsert :: (Expr table, Expr object) => object -> table -> ReQL
+upsert a tb = op INSERT (tb, a) ["upsert" := P.True]
-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]
+-- | Add to or modify the contents of a document
+update :: (Expr selection) => (ReQL -> ReQL) -> selection -> ReQL
+update f s = op UPDATE (s, f) ()
--- * Control Structures, Functions and Javascript
+-- | Replace a document with another
+replace :: (Expr selection) => (ReQL -> ReQL) -> selection -> ReQL
+replace f s = op REPLACE (s, f) ()
--- | A javascript expression
---
--- It is often necessary to specify the result type:
---
--- >>> run h $ (js "1 + 2" :: NumberExpr)
--- 3
+-- | Delete the documents
+delete :: (Expr selection) => selection -> ReQL
+delete s = op DELETE [s] ()
-js :: String -> Expr (ValueType any)
-js s = mkExpr $ return defaultValue {
- QLTerm.type' = QL.JAVASCRIPT,
- QLTerm.javascript = Just $ uFromString ("return (" P.++ s P.++ ")") }
+-- | Convert a value to a different type
+coerceTo :: (Expr x) => ReQL -> x -> ReQL
+coerceTo t a = op COERCE_TO (a, t) ()
-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 }
+-- | Convert a value to a different type
+asArray, asString, asNumber, asObject, asBool :: Expr x => x -> ReQL
+asArray = coerceTo "ARRAY"
+asString = coerceTo "STRING"
+asNumber = coerceTo "NUMBER"
+asObject = coerceTo "OBJECT"
+asBool = coerceTo "BOOL"
-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 }
+-- | Like hasFields followed by pluck
+withFields :: (Expr paths, Expr seq) => [paths] -> seq -> ReQL
+withFields p s = op WITH_FIELDS (s, p) ()
-var :: ExprIsView (Expr t) ~ False => String -> Expr t
-var v = mkExpr $ return defaultValue {
- QLTerm.type' = QL.VAR,
- QLTerm.var = Just $ uFromString v
- }
+-- | The position in the sequence of the elements that match the predicate
+indexesOf :: (Expr fun, Expr seq) => fun -> seq -> ReQL
+indexesOf f s = op INDEXES_OF (s, f) ()
-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 }
+-- | Test if a sequence is empty
+isEmpty :: Expr seq => seq -> ReQL
+isEmpty s = op IS_EMPTY [s] ()
--- | A javascript function
---
--- >>> let squareRoot = jsfun "Math.sqrt" :: NumberExpr -> NumberExpr
--- >>> run h $ squareRoot 5 :: IO Double
--- 2.23606797749979
+-- | Select a given number of elements from a sequence with uniform random distribution
+sample :: (Expr n, Expr seq) => n -> seq -> ReQL
+sample n s = op SAMPLE (s, n) ()
-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.++ ")")
+-- | Prepend an element to an array
+prepend :: (Expr datum, Expr array) => datum -> array -> ReQL
+prepend d a = op PREPEND (a, d) ()
-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
+-- | Called /difference/ in the official drivers
+(\\) :: (Expr a, Expr b) => a -> b -> ReQL
+a \\ b = op DIFFERENCE (a, b) ()
-class CanConcat (a :: ValueTypeKind)
-instance CanConcat StringType
-instance CanConcat ArrayType
+-- | Insert a datum into an array if it is not yet present
+setInsert :: (Expr datum, Expr array) => datum -> array -> ReQL
+setInsert d a = op SET_INSERT (a, d) ()
+
+-- | The union of two sets
+setUnion :: (Expr a, Expr b) => a -> b -> ReQL
+setUnion a b = op SET_UNION (b, a) ()
+
+-- | The intersection of two sets
+setIntersection :: (Expr a, Expr b) => a -> b -> ReQL
+setIntersection a b = op SET_INTERSECTION (b, a) ()
+
+-- | The difference of two sets
+setDifference :: (Expr set, Expr remove) => remove -> set -> ReQL
+setDifference r s = op SET_DIFFERENCE (s, r) ()
+
+-- | Test if an object has the given fields
+hasFields :: (Expr obj, Expr paths) => paths -> obj -> ReQL
+hasFields p o = op HAS_FIELDS (o, p) ()
+
+-- | Insert a datum at the given position in an array
+insertAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL
+insertAt n d a = op INSERT_AT (a, n, d) ()
+
+-- | Splice an array at a given position inside another array
+spliceAt :: (Expr n, Expr replace, Expr array) => n -> replace -> array -> ReQL
+spliceAt n s a = op SPLICE_AT (a, n, s) ()
+
+-- | Delete an element from an array
+deleteAt :: (Expr n, Expr array) => n -> array -> ReQL
+deleteAt n a = op DELETE_AT (a, n) ()
+
+-- | Change an element in an array
+changeAt :: (Expr n, Expr datum, Expr array) => n -> datum -> array -> ReQL
+changeAt n d a = op CHANGE_AT (a, n, d) ()
+
+-- | The list of keys of the given object
+keys :: Expr obj => obj -> ReQL
+keys o = op KEYS [o] ()
+
+-- | Match a string to a regulr expression
+-- Called /match/ in the official drivers
+(=~) :: (Expr string, Expr regex) => string -> regex -> ReQL
+s =~ r = op MATCH (s, r) ()
+
+-- | Apply a function to a list of arguments
+-- Called /do/ in the official drivers
+apply :: (Expr fun, Expr arg) => fun -> [arg] -> ReQL
+f `apply` as = op FUNCALL (expr f : P.map expr as) ()
+
+-- | Catch some expections inside the query.
+-- Called /default/ in the official drivers
+handle :: (Expr handler, Expr reql) => handler -> reql -> ReQL
+handle h r = op DEFAULT (r, h) ()
+
+-- | A string representing the type of an expression
+typeOf :: Expr a => a -> ReQL
+typeOf a = op TYPEOF [a] ()
+
+-- | Get information on a given expression. Useful for tables and databases.
+info :: Expr a => a -> ReQL
+info a = op INFO [a] ()
+
+-- | Parse a json string into an object
+json :: Expr string => string -> ReQL
+json s = op JSON [s] ()
+
+-- | Flipped function composition
+(#) :: (Expr a, Expr b, Expr c) => (ReQL -> a) -> (ReQL -> b) -> c -> ReQL
+(f # g) x = expr (g (expr (f (expr x))))
+
+-- | Specialised function composition
+(.) :: (Expr a, Expr b, Expr c) => (ReQL -> b) -> (ReQL -> a) -> c -> ReQL
+(f . g) x = expr (f (expr (g (expr x))))
diff --git a/Database/RethinkDB/Functions.hs-boot b/Database/RethinkDB/Functions.hs-boot
deleted file mode 100644
--- a/Database/RethinkDB/Functions.hs-boot
+++ /dev/null
@@ -1,9 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin.hs
+++ /dev/null
@@ -1,123 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs
+++ /dev/null
@@ -1,231 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs
+++ /dev/null
@@ -1,82 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs
+++ /dev/null
@@ -1,59 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs
+++ /dev/null
@@ -1,68 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs
+++ /dev/null
@@ -1,59 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs
+++ /dev/null
@@ -1,68 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Mapping.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/MetaQuery.hs
+++ /dev/null
@@ -1,73 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs
+++ /dev/null
@@ -1,87 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Predicate.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Query.hs
+++ /dev/null
@@ -1,80 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs
+++ /dev/null
@@ -1,74 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/ReadQuery.hs
+++ /dev/null
@@ -1,72 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Reduction.hs
+++ /dev/null
@@ -1,65 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Response.hs
+++ /dev/null
@@ -1,74 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs
+++ /dev/null
@@ -1,57 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs
+++ /dev/null
@@ -1,92 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/TableRef.hs
+++ /dev/null
@@ -1,62 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term.hs
+++ /dev/null
@@ -1,150 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term.hs-boot
+++ /dev/null
@@ -1,32 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/Call.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs
+++ /dev/null
@@ -1,65 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/If.hs
+++ /dev/null
@@ -1,64 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/Let.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/Table.hs
+++ /dev/null
@@ -1,59 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/Term/TermType.hs
+++ /dev/null
@@ -1,134 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery.hs
+++ /dev/null
@@ -1,122 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs
+++ /dev/null
@@ -1,64 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot
+++ /dev/null
@@ -1,30 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs
+++ /dev/null
@@ -1,66 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs
+++ /dev/null
@@ -1,65 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs
+++ /dev/null
@@ -1,69 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs
+++ /dev/null
@@ -1,61 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs
+++ /dev/null
@@ -1,98 +0,0 @@
-{-# 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
deleted file mode 100644
--- a/Database/RethinkDB/Internal/Types.hs
+++ /dev/null
@@ -1,83 +0,0 @@
-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/MapReduce.hs b/Database/RethinkDB/MapReduce.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/MapReduce.hs
@@ -0,0 +1,114 @@
+module Database.RethinkDB.MapReduce where
+
+import Control.Monad.State
+import Control.Monad.Writer
+import qualified Data.Text as T
+
+import Database.RethinkDB.Protobuf.Ql2.Term.TermType
+import qualified Database.RethinkDB.Protobuf.Ql2.Datum as Datum
+
+import Database.RethinkDB.ReQL
+import Database.RethinkDB.Objects
+
+termToMapReduce ::
+ (ReQL -> ReQL) -> State QuerySettings (ReQL -> ReQL, ReQL -> ReQL -> ReQL, ReQL -> ReQL)
+termToMapReduce f = do
+ v <- newVarId
+ body <- baseReQL $ f (op VAR [v] ())
+ let MapReduce map reduce finally = toMapReduce v body
+ return (map, reduce, finally)
+
+toReduce :: MapReduce -> (ReQL -> ReQL, ReQL -> ReQL -> ReQL, ReQL -> ReQL)
+toReduce (None t) = (\_ -> expr (), \_ _ -> expr (), const t)
+toReduce (Map m) = ((\x -> expr [x]) . m, unionReduce, id)
+toReduce (MapReduce m r f) = (m, r, f)
+
+unionReduce :: ReQL -> ReQL -> ReQL
+unionReduce a b = op UNION (a, b) ()
+
+sameVar :: Int -> BaseArray -> Bool
+sameVar x [BaseReQL DATUM (Just (Datum.Datum{ Datum.r_num = Just y })) _ _] =
+ fromIntegral x == y
+sameVar _ _ = False
+
+notNone :: MapReduce -> Bool
+notNone None{} = False
+notNone _ = True
+
+wrap :: BaseReQL -> ReQL
+wrap = ReQL . return
+
+toFun1 :: ReQL -> (ReQL -> ReQL)
+toFun1 f a = op FUNCALL (f, a) ()
+
+toFun2 :: ReQL -> (ReQL -> ReQL -> ReQL)
+toFun2 f a b = op FUNCALL (f, a, b) ()
+
+toMapReduce :: Int -> BaseReQL -> MapReduce
+toMapReduce _ t@(BaseReQL DATUM _ _ _) = None $ wrap t
+toMapReduce v (BaseReQL VAR _ w _) | sameVar v w = Map id
+toMapReduce v t@(BaseReQL type' _ args optargs) = let
+ args' = map (toMapReduce v) args
+ optargs' = map (\(BaseAttribute k vv) -> (k, toMapReduce v vv)) optargs
+ count = length $ filter notNone $ args' ++ map snd optargs'
+ rebuild = (if count == 1 then rebuild0 else rebuildx) type' args' optargs'
+ in if count == 0 then None $ wrap t
+ else if not $ count == 1
+ then rebuild else
+ case (type', args') of
+ (MAP, [Map m, None f]) -> Map (toFun1 f . m)
+ (REDUCE, [Map m, None f]) -> MapReduce m (toFun2 f) id
+ (COUNT, [Map _]) -> MapReduce (const 1)
+ (\a b -> op ADD (a, b) ()) id
+ _ -> rebuild
+
+data MapReduce =
+ None ReQL |
+ Map (ReQL -> ReQL) |
+ MapReduce (ReQL -> ReQL) (ReQL -> ReQL -> ReQL) (ReQL -> ReQL)
+
+rebuild0 :: TermType -> [MapReduce] -> [(T.Text, MapReduce)] -> MapReduce
+rebuild0 ttype args optargs = MapReduce maps reduce finals where
+ (finally2, [mr]) = extract Nothing ttype args optargs
+ (maps, reduce, finally1) = toReduce mr
+ finals = finally2 . finally1
+
+rebuildx :: TermType -> [MapReduce] -> [(Key, MapReduce)] -> MapReduce
+rebuildx ttype args optargs = MapReduce maps reduces finallys where
+ (finally, mrs) = extract (Just 0) ttype args optargs
+ index = zip ([0..] :: [Int])
+ triplets = map toReduce mrs
+ maps x = expr $ map (($ x) . fst3) triplets
+ reduces a b = expr $ map (uncurry $ mkReduce a b) . index $ map snd3 triplets
+ finallys x = finally $ expr $ map (uncurry $ mkFinally x) . index $ map thrd3 triplets
+ mkReduce a b i f = f (op NTH (a, i) ()) (op NTH (b, i) ())
+ mkFinally x i f = f (op NTH (x, i) ())
+
+fst3 :: (a,b,c) -> a
+fst3 (a,_,_) = a
+
+snd3 :: (a,b,c) -> b
+snd3 (_,b,_) = b
+
+thrd3 :: (a,b,c) -> c
+thrd3 (_,_,c) = c
+
+extract ::
+ Maybe Int -> TermType -> [MapReduce] -> [(Key, MapReduce)]
+ -> (ReQL -> ReQL, [MapReduce])
+extract state tt args optargs = fst $ flip runState state $ runWriterT $ do
+ args' <- sequence $ map extractOne args
+ optargvs' <- sequence $ map extractOne (map snd optargs)
+ let optargks = map fst optargs
+ return $ \v -> op tt (map ($ v) args') (zipWith (:=) optargks $ map ($ v) optargvs')
+
+extractOne :: MapReduce -> WriterT [MapReduce] (State (Maybe Int)) (ReQL -> ReQL)
+extractOne (None term) = return $ const term
+extractOne mr = do
+ tell [mr]
+ st <- get
+ case st of
+ Nothing -> return id
+ Just n -> do
+ put $ Just $ n + 1
+ return $ \v -> op NTH (v, n) ()
diff --git a/Database/RethinkDB/Network.hs b/Database/RethinkDB/Network.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Network.hs
@@ -0,0 +1,344 @@
+{-# LANGUAGE RecordWildCards, OverloadedStrings, DeriveDataTypeable, NamedFieldPuns #-}
+
+module Database.RethinkDB.Network (
+ RethinkDBHandle(..),
+ connect,
+ close,
+ use,
+ runQLQuery,
+ Cursor,
+ makeCursor,
+ next,
+ collect,
+ stopResponse,
+ nextResponse,
+ Response(..),
+ SuccessCode(..),
+ ErrorCode(..),
+ RethinkDBError(..),
+ RethinkDBConnectionError(..),
+ ) where
+
+import Control.Monad (when, forever)
+import Data.Typeable (Typeable)
+import Network (HostName, connectTo, PortID(PortNumber))
+import System.IO (Handle, hClose, hIsEOF)
+import Data.ByteString.Lazy (pack, unpack, hPut, hGet, ByteString)
+import qualified Data.ByteString.Lazy as B
+import qualified Data.ByteString.UTF8 as BS (fromString)
+import qualified Data.Text as T
+import Control.Concurrent (
+ writeChan, MVar, Chan, modifyMVar, readMVar, forkIO, readChan,
+ myThreadId, newMVar, ThreadId, withMVar, newChan,
+ newEmptyMVar, putMVar, mkWeakMVar)
+import Data.Bits (shiftL, (.|.), shiftR)
+import Data.Monoid ((<>))
+import Data.Foldable hiding (forM_)
+import Control.Exception (catches, Exception, throwIO)
+import Data.Aeson (toJSON, object, (.=), Value(Null, Bool))
+import Data.IORef (IORef, newIORef, atomicModifyIORef', readIORef)
+import Data.Map (Map)
+import qualified Data.Map as M
+import Data.Maybe (fromMaybe, listToMaybe)
+import Control.Monad.Fix (fix)
+import Data.Int (Int64)
+import System.IO.Unsafe (unsafeInterleaveIO)
+
+import Text.ProtocolBuffers.Basic (uToString)
+import Text.ProtocolBuffers (messagePut, defaultValue, messageGet)
+
+import Database.RethinkDB.Protobuf.Ql2.Query as Query
+import Database.RethinkDB.Protobuf.Ql2.Query.QueryType
+import qualified Database.RethinkDB.Protobuf.Ql2.Response as Ql2
+import Database.RethinkDB.Protobuf.Ql2.Response.ResponseType
+import Database.RethinkDB.Protobuf.Ql2.Datum as Datum
+import Database.RethinkDB.Protobuf.Ql2.Datum.DatumType
+import Database.RethinkDB.Protobuf.Ql2.Datum.AssocPair
+import Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version
+
+import Database.RethinkDB.Objects as O
+import Database.RethinkDB.ReQL (
+ BaseReQL, Backtrace, convertBacktrace)
+
+type Token = Int64
+
+-- | A connection to the database server
+data RethinkDBHandle = RethinkDBHandle {
+ rdbHandle :: Handle,
+ rdbWriteLock :: MVar (),
+ rdbToken :: IORef Token, -- ^ The next token to use
+ rdbDatabase :: Database, -- ^ The default database
+ rdbWait :: IORef (Map Token (Chan Response, BaseReQL)),
+ rdbThread :: ThreadId
+ }
+
+data Cursor a = Cursor {
+ cursorMBox :: MVar Response,
+ cursorBuffer :: MVar (Either RethinkDBError ([O.Datum], Bool)),
+ cursorMap :: O.Datum -> a }
+
+instance Functor Cursor where
+ fmap f Cursor{ .. } = Cursor { cursorMap = f . cursorMap, .. }
+
+instance Show RethinkDBHandle where
+ show RethinkDBHandle{ rdbHandle } = "RethinkDB Connection " ++ show rdbHandle
+
+newToken :: RethinkDBHandle -> IO Int64
+newToken RethinkDBHandle{rdbToken} =
+ atomicModifyIORef' rdbToken $ \x -> (x+1, x)
+
+data RethinkDBConnectionError =
+ RethinkDBConnectionError ByteString
+ deriving (Show, Typeable)
+instance Exception RethinkDBConnectionError
+
+-- | Create a new connection to the database server
+--
+-- /Example:/ connect using the default port with no passphrase
+--
+-- >>> h <- connect "localhost" 28015 Nothing
+
+connect :: HostName -> Integer -> Maybe String -> IO RethinkDBHandle
+connect host port mauth = do
+ h <- connectTo host (PortNumber (fromInteger port))
+ hPut h magicNumber
+ let auth = B.fromChunks . return . BS.fromString $ fromMaybe "" mauth
+ hPut h $ packUInt (fromIntegral $ B.length auth)
+ hPut h auth
+ res <- hGetNullTerminatedString h
+ when (res /= "SUCCESS") $ throwIO (RethinkDBConnectionError res)
+ r <- newIORef 1
+ let db' = Database "test"
+ wlock <- newMVar ()
+ waits <- newIORef M.empty
+ let rdb = RethinkDBHandle h wlock r db' waits
+ tid <- forkIO $ readResponses rdb
+ return $ rdb tid
+
+hGetNullTerminatedString :: Handle -> IO ByteString
+hGetNullTerminatedString h = go "" where
+ go acc = do
+ end <- hIsEOF h
+ if end then return acc else do
+ c <- B.hGet h 1
+ if c == B.pack [0] then return acc else
+ go (acc <> c)
+
+magicNumber :: ByteString
+magicNumber = packUInt $ fromEnum V0_2
+
+-- | Convert a 4-byte 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"
+
+-- | Convert an int to a 4-byte bytestring
+packUInt :: Int -> B.ByteString
+packUInt n = pack $ map fromIntegral $
+ [n `mod` 256, (n `shiftR` 8) `mod` 256,
+ (n `shiftR` 16) `mod` 256, (n `shiftR` 24) `mod` 256]
+
+withHandle :: RethinkDBHandle -> (Handle -> IO a) -> IO a
+withHandle RethinkDBHandle{ rdbHandle, rdbWriteLock } f =
+ withMVar rdbWriteLock $ \_ -> f rdbHandle
+
+data RethinkDBError = RethinkDBError {
+ errorCode :: ErrorCode,
+ errorTerm :: BaseReQL,
+ errorMessage :: String,
+ errorBacktrace :: Backtrace
+ } deriving (Typeable, Show)
+
+instance Exception RethinkDBError
+
+-- | The raw response to a query
+data Response = ErrorResponse {
+ errorResponse :: RethinkDBError
+ } | SuccessResponse {
+ successCode :: SuccessCode,
+ successDatums :: [O.Datum]
+ }
+
+data ErrorCode =
+ ErrorBrokenClient |
+ ErrorBadQuery |
+ ErrorRuntime |
+ ErrorUnexpectedResponse
+
+instance Show ErrorCode where
+ show ErrorBrokenClient = "broken client error"
+ show ErrorBadQuery = "malformed query error"
+ show ErrorRuntime = "runtime error"
+ show ErrorUnexpectedResponse = "unexpected response"
+
+data SuccessCode =
+ SuccessPartial RethinkDBHandle Int64 |
+ Success
+ deriving Show
+
+instance Show Response where
+ show (ErrorResponse RethinkDBError {..}) =
+ show errorCode ++ ": " ++
+ show errorMessage ++ " (" ++
+ show errorBacktrace ++ ")"
+ show SuccessResponse {..} = show successCode ++ ": " ++ show successDatums
+
+convertResponse :: RethinkDBHandle -> BaseReQL -> Int64 -> Ql2.Response -> Response
+convertResponse h q t Ql2.Response{ .. } = case type' of
+ Just SUCCESS_ATOM -> SuccessResponse Success (map convertDatum r)
+ Just SUCCESS_PARTIAL -> SuccessResponse (SuccessPartial h t) (map convertDatum r)
+ Just SUCCESS_SEQUENCE -> SuccessResponse Success (map convertDatum r)
+ Just CLIENT_ERROR -> ErrorResponse $ RethinkDBError ErrorBrokenClient q e bt
+ Just COMPILE_ERROR -> ErrorResponse $ RethinkDBError ErrorBadQuery q e bt
+ Just RUNTIME_ERROR -> ErrorResponse $ RethinkDBError ErrorRuntime q e bt
+ Nothing -> ErrorResponse $ RethinkDBError ErrorUnexpectedResponse q e bt
+ where
+ bt = maybe [] convertBacktrace backtrace
+ r = toList response
+ e = maybe "" uToString $ r_str =<< listToMaybe (toList response)
+ -- TODO: nicer backtrace
+
+runQLQuery :: RethinkDBHandle -> Query -> BaseReQL -> IO (MVar Response)
+runQLQuery h query term = do
+ tok <- newToken h
+ mbox <- addMBox h tok term
+ sendQLQuery h query{ Query.token = Just tok }
+ return mbox
+
+addMBox :: RethinkDBHandle -> Token -> BaseReQL -> IO (MVar Response)
+addMBox h tok term = do
+ chan <- newChan
+ atomicModifyIORef' (rdbWait h) $ \mboxes ->
+ (M.insert tok (chan, term) mboxes, ())
+ mbox <- newEmptyMVar
+ _ <- mkWeakMVar mbox $ do
+ atomicModifyIORef' (rdbWait h) $ \mboxes ->
+ (M.delete tok mboxes, ())
+ _ <- forkIO $ fix $ \loop -> do
+ response <- readChan chan
+ putMVar mbox response
+ when (not $ isLastResponse response) $ do
+ nextResponse response
+ loop
+ return mbox
+
+sendQLQuery :: RethinkDBHandle -> Query -> IO ()
+sendQLQuery h query = do
+ let queryS = messagePut query
+ withHandle h $ \s ->
+ hPut s $ packUInt (fromIntegral $ B.length queryS) <> queryS
+
+data RethinkDBReadError =
+ RethinkDBReadError String
+ deriving (Show, Typeable)
+instance Exception RethinkDBReadError
+
+readResponses :: (ThreadId -> RethinkDBHandle) -> IO ()
+readResponses h' = do
+ tid <- myThreadId
+ let h = h' tid
+ forever $ flip catches handlers $
+ readSingleResponse h
+ where
+ handlers = []
+
+readSingleResponse :: RethinkDBHandle -> IO ()
+readSingleResponse h = do
+ header <- hGet (rdbHandle h) 4
+ rawResponse <- hGet (rdbHandle h) (unpackUInt header)
+ let parsedResponse = messageGet rawResponse
+ case parsedResponse of
+ Left errMsg -> throwIO $ RethinkDBReadError errMsg
+ Right (response, rest)
+ | B.null rest -> dispatch (Ql2.token response) response
+ | otherwise -> throwIO $ RethinkDBReadError "RethinkDB: readResponses: invalid reply length"
+
+ where
+ dispatch Nothing _ = return ()
+ dispatch (Just tok) response = do
+ mboxes <- readIORef $ rdbWait h
+ case M.lookup tok mboxes of
+ Nothing -> return ()
+ Just (mbox, term) -> do
+ let convertedResponse = convertResponse h term tok response
+ writeChan mbox convertedResponse
+ when (isLastResponse convertedResponse) $
+ atomicModifyIORef' (rdbWait h) $ \m -> (M.delete tok m, ())
+
+isLastResponse :: Response -> Bool
+isLastResponse ErrorResponse{} = True
+isLastResponse SuccessResponse{ successCode = Success } = True
+isLastResponse SuccessResponse{ successCode = SuccessPartial{} } = False
+
+-- | Set the default database
+--
+-- The new handle is an alias for the old one. Calling close on either one
+-- will close both.
+use :: RethinkDBHandle -> Database -> RethinkDBHandle
+use h db' = h { rdbDatabase = db' }
+
+-- | Close an open connection
+close :: RethinkDBHandle -> IO ()
+close RethinkDBHandle{ rdbHandle } = hClose rdbHandle
+
+convertDatum :: Datum.Datum -> O.Datum
+convertDatum Datum { type' = Just R_NULL } = Null
+convertDatum Datum { type' = Just R_BOOL, r_bool = Just b } = Bool b
+convertDatum Datum { type' = Just R_ARRAY, r_array = a } = toJSON (map convertDatum $ toList a)
+convertDatum Datum { type' = Just R_OBJECT, r_object = o } =
+ object $ Prelude.concatMap pair $ toList o
+ where
+ pair (AssocPair (Just k) (Just v)) = [(T.pack $ uToString $ k) .= convertDatum v]
+ pair _ = []
+convertDatum Datum { type' = Just R_STR, r_str = Just s } = toJSON (uToString s)
+convertDatum Datum { type' = Just R_NUM, r_num = Just n } = toJSON n
+convertDatum d = error ("Invalid Datum: " ++ show d)
+
+stopResponse :: Response -> IO ()
+stopResponse SuccessResponse { successCode = SuccessPartial h tok } = do
+ let query = defaultValue { Query.type' = Just STOP, Query.token = Just tok}
+ sendQLQuery h query
+stopResponse _ = return ()
+
+nextResponse :: Response -> IO ()
+nextResponse SuccessResponse { successCode = SuccessPartial h tok } = do
+ let query = defaultValue { Query.type' = Just CONTINUE, Query.token = Just tok}
+ sendQLQuery h query
+nextResponse _ = return ()
+
+makeCursor :: MVar Response -> IO (Cursor O.Datum)
+makeCursor cursorMBox = do
+ cursorBuffer <- newMVar (Right ([], False))
+ return Cursor{..}
+ where cursorMap = id
+
+-- | Get the next value from a cursor
+next :: Cursor a -> IO (Maybe a)
+next c@Cursor{ .. } = modifyMVar cursorBuffer $ fix $ \loop mbuffer ->
+ case mbuffer of
+ Left err -> throwIO err
+ Right ([], True) -> return (Right ([], True), Nothing)
+ Right (x:xs, end) -> return $ (Right (xs, end), Just (cursorMap x))
+ Right ([], False) -> cursorFetchBatch c >>= loop
+
+cursorFetchBatch :: Cursor a -> IO (Either RethinkDBError ([O.Datum], Bool))
+cursorFetchBatch c = do
+ response <- readMVar (cursorMBox c)
+ case response of
+ ErrorResponse e -> return $ Left e
+ SuccessResponse Success datums -> return $ Right (datums, True)
+ SuccessResponse SuccessPartial{} datums -> return $ Right (datums, False)
+
+-- | A lazy stream of all the elements in the cursor
+collect :: Cursor a -> IO [a]
+collect c = fix $ \loop -> do
+ n <- next c
+ case n of
+ Nothing -> return []
+ Just x -> do
+ xs <- unsafeInterleaveIO $ loop
+ return $ x : xs
diff --git a/Database/RethinkDB/Objects.hs b/Database/RethinkDB/Objects.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Objects.hs
@@ -0,0 +1,45 @@
+module Database.RethinkDB.Objects (
+ Database(..),
+ TableCreateOptions(..),
+ Table(..),
+ Datum,
+ Key
+ ) where
+
+import Data.Default (def, Default)
+import Data.Int (Int64)
+import Data.Text as Text
+import Data.Aeson (Value)
+
+type Key = Text
+
+-- | A database, referenced by name
+data Database = Database {
+ databaseName :: Text
+ } deriving (Eq, Ord)
+
+instance Show Database where
+ show (Database d) = show d
+
+-- | Options used to create a table
+data TableCreateOptions = TableCreateOptions {
+ tableDataCenter :: Maybe Text,
+ tableCacheSize :: Maybe Int64
+ }
+
+instance Default TableCreateOptions where
+ def = TableCreateOptions Nothing Nothing
+
+-- | A table description
+data Table = Table {
+ tableDatabase :: Maybe Database, -- ^ when Nothing, use the connection's database
+ tableName :: Text,
+ tablePrimaryKey :: Maybe Key
+ } deriving (Eq, Ord)
+
+instance Show Table where
+ show (Table db' nam mkey) =
+ maybe "" (\(Database d) -> Text.unpack d++".") db' ++ Text.unpack nam ++
+ maybe "" (\k -> "[" ++ show k ++ "]") mkey
+
+type Datum = Value
diff --git a/Database/RethinkDB/Protobuf/Ql2.hs b/Database/RethinkDB/Protobuf/Ql2.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2.hs
@@ -0,0 +1,21 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2 (protoInfo, fileDescriptorProto) 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 Text.DescriptorProtos.FileDescriptorProto (FileDescriptorProto)
+import Text.ProtocolBuffers.Reflections (ProtoInfo)
+import qualified Text.ProtocolBuffers.WireMessage as P' (wireGet,getFromBS)
+
+protoInfo :: ProtoInfo
+protoInfo
+ = Prelude'.read
+ "ProtoInfo {protoMod = ProtoName {protobufName = FIName \".Ql2\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [], baseName = MName \"Ql2\"}, protoFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2.hs\"], protoSource = \"ql2.proto\", extensionKeys = fromList [], messages = [DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.VersionDummy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"VersionDummy\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"VersionDummy.hs\"], isGroup = False, fields = fromList [], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Query\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Query\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Query.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Query.QueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"QueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"query\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"token\"}, 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},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.OBSOLETE_noreply\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"oBSOLETE_noreply\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 32}, 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)},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.global_optargs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"global_optargs\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Query.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Query.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Query\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Query.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Frame\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Frame\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Frame.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Frame.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Frame.FrameType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Frame\"], baseName = MName \"FrameType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Frame.pos\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"pos\"}, 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 \".Ql2.Frame.opt\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"opt\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Backtrace\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Backtrace.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Backtrace.frames\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Backtrace\"], baseName' = FName \"frames\"}, 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 \".Ql2.Frame\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Frame\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Response\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Response\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Response.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Response.ResponseType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Response\"], baseName = MName \"ResponseType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"token\"}, 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 \".Ql2.Response.response\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",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 = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.backtrace\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"backtrace\"}, 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 \".Ql2.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Backtrace\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Datum.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum.DatumType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"DatumType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_bool\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_bool\"}, 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 = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_num\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_num\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 25}, 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 \".Ql2.Datum.r_str\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_str\"}, 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 \".Ql2.Datum.r_array\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_array\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_object\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_object\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 10000},FieldId {getFieldId = 18999}),(FieldId {getFieldId = 20000},FieldId {getFieldId = 20000})], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Datum.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Datum\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Datum.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Term.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Term.TermType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"TermType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.datum\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"datum\"}, 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 \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.args\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"args\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.optargs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"optargs\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Term.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 10000},FieldId {getFieldId = 18999}),(FieldId {getFieldId = 20000},FieldId {getFieldId = 20000})], knownKeys = fromList [], storeUnknown = False, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Term.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Term\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Term.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}], enums = [EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.VersionDummy.Version\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"VersionDummy\"], baseName = MName \"Version\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"VersionDummy\",\"Version.hs\"], enumValues = [(EnumCode {getEnumCode = 1063369270},\"V0_1\"),(EnumCode {getEnumCode = 1915781601},\"V0_2\")]},EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.Query.QueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"QueryType\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Query\",\"QueryType.hs\"], enumValues = [(EnumCode {getEnumCode = 1},\"START\"),(EnumCode {getEnumCode = 2},\"CONTINUE\"),(EnumCode {getEnumCode = 3},\"STOP\")]},EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.Frame.FrameType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Frame\"], baseName = MName \"FrameType\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Frame\",\"FrameType.hs\"], enumValues = [(EnumCode {getEnumCode = 1},\"POS\"),(EnumCode {getEnumCode = 2},\"OPT\")]},EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.Response.ResponseType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Response\"], baseName = MName \"ResponseType\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Response\",\"ResponseType.hs\"], enumValues = [(EnumCode {getEnumCode = 1},\"SUCCESS_ATOM\"),(EnumCode {getEnumCode = 2},\"SUCCESS_SEQUENCE\"),(EnumCode {getEnumCode = 3},\"SUCCESS_PARTIAL\"),(EnumCode {getEnumCode = 16},\"CLIENT_ERROR\"),(EnumCode {getEnumCode = 17},\"COMPILE_ERROR\"),(EnumCode {getEnumCode = 18},\"RUNTIME_ERROR\")]},EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.Datum.DatumType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"DatumType\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Datum\",\"DatumType.hs\"], enumValues = [(EnumCode {getEnumCode = 1},\"R_NULL\"),(EnumCode {getEnumCode = 2},\"R_BOOL\"),(EnumCode {getEnumCode = 3},\"R_NUM\"),(EnumCode {getEnumCode = 4},\"R_STR\"),(EnumCode {getEnumCode = 5},\"R_ARRAY\"),(EnumCode {getEnumCode = 6},\"R_OBJECT\")]},EnumInfo {enumName = ProtoName {protobufName = FIName \".Ql2.Term.TermType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"TermType\"}, enumFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Term\",\"TermType.hs\"], enumValues = [(EnumCode {getEnumCode = 1},\"DATUM\"),(EnumCode {getEnumCode = 2},\"MAKE_ARRAY\"),(EnumCode {getEnumCode = 3},\"MAKE_OBJ\"),(EnumCode {getEnumCode = 10},\"VAR\"),(EnumCode {getEnumCode = 11},\"JAVASCRIPT\"),(EnumCode {getEnumCode = 12},\"ERROR\"),(EnumCode {getEnumCode = 13},\"IMPLICIT_VAR\"),(EnumCode {getEnumCode = 14},\"DB\"),(EnumCode {getEnumCode = 15},\"TABLE\"),(EnumCode {getEnumCode = 16},\"GET\"),(EnumCode {getEnumCode = 78},\"GET_ALL\"),(EnumCode {getEnumCode = 17},\"EQ\"),(EnumCode {getEnumCode = 18},\"NE\"),(EnumCode {getEnumCode = 19},\"LT\"),(EnumCode {getEnumCode = 20},\"LE\"),(EnumCode {getEnumCode = 21},\"GT\"),(EnumCode {getEnumCode = 22},\"GE\"),(EnumCode {getEnumCode = 23},\"NOT\"),(EnumCode {getEnumCode = 24},\"ADD\"),(EnumCode {getEnumCode = 25},\"SUB\"),(EnumCode {getEnumCode = 26},\"MUL\"),(EnumCode {getEnumCode = 27},\"DIV\"),(EnumCode {getEnumCode = 28},\"MOD\"),(EnumCode {getEnumCode = 29},\"APPEND\"),(EnumCode {getEnumCode = 80},\"PREPEND\"),(EnumCode {getEnumCode = 95},\"DIFFERENCE\"),(EnumCode {getEnumCode = 88},\"SET_INSERT\"),(EnumCode {getEnumCode = 89},\"SET_INTERSECTION\"),(EnumCode {getEnumCode = 90},\"SET_UNION\"),(EnumCode {getEnumCode = 91},\"SET_DIFFERENCE\"),(EnumCode {getEnumCode = 30},\"SLICE\"),(EnumCode {getEnumCode = 70},\"SKIP\"),(EnumCode {getEnumCode = 71},\"LIMIT\"),(EnumCode {getEnumCode = 87},\"INDEXES_OF\"),(EnumCode {getEnumCode = 93},\"CONTAINS\"),(EnumCode {getEnumCode = 31},\"GET_FIELD\"),(EnumCode {getEnumCode = 94},\"KEYS\"),(EnumCode {getEnumCode = 32},\"HAS_FIELDS\"),(EnumCode {getEnumCode = 96},\"WITH_FIELDS\"),(EnumCode {getEnumCode = 33},\"PLUCK\"),(EnumCode {getEnumCode = 34},\"WITHOUT\"),(EnumCode {getEnumCode = 35},\"MERGE\"),(EnumCode {getEnumCode = 36},\"BETWEEN\"),(EnumCode {getEnumCode = 37},\"REDUCE\"),(EnumCode {getEnumCode = 38},\"MAP\"),(EnumCode {getEnumCode = 39},\"FILTER\"),(EnumCode {getEnumCode = 40},\"CONCATMAP\"),(EnumCode {getEnumCode = 41},\"ORDERBY\"),(EnumCode {getEnumCode = 42},\"DISTINCT\"),(EnumCode {getEnumCode = 43},\"COUNT\"),(EnumCode {getEnumCode = 86},\"IS_EMPTY\"),(EnumCode {getEnumCode = 44},\"UNION\"),(EnumCode {getEnumCode = 45},\"NTH\"),(EnumCode {getEnumCode = 46},\"GROUPED_MAP_REDUCE\"),(EnumCode {getEnumCode = 47},\"GROUPBY\"),(EnumCode {getEnumCode = 48},\"INNER_JOIN\"),(EnumCode {getEnumCode = 49},\"OUTER_JOIN\"),(EnumCode {getEnumCode = 50},\"EQ_JOIN\"),(EnumCode {getEnumCode = 72},\"ZIP\"),(EnumCode {getEnumCode = 82},\"INSERT_AT\"),(EnumCode {getEnumCode = 83},\"DELETE_AT\"),(EnumCode {getEnumCode = 84},\"CHANGE_AT\"),(EnumCode {getEnumCode = 85},\"SPLICE_AT\"),(EnumCode {getEnumCode = 51},\"COERCE_TO\"),(EnumCode {getEnumCode = 52},\"TYPEOF\"),(EnumCode {getEnumCode = 53},\"UPDATE\"),(EnumCode {getEnumCode = 54},\"DELETE\"),(EnumCode {getEnumCode = 55},\"REPLACE\"),(EnumCode {getEnumCode = 56},\"INSERT\"),(EnumCode {getEnumCode = 57},\"DB_CREATE\"),(EnumCode {getEnumCode = 58},\"DB_DROP\"),(EnumCode {getEnumCode = 59},\"DB_LIST\"),(EnumCode {getEnumCode = 60},\"TABLE_CREATE\"),(EnumCode {getEnumCode = 61},\"TABLE_DROP\"),(EnumCode {getEnumCode = 62},\"TABLE_LIST\"),(EnumCode {getEnumCode = 75},\"INDEX_CREATE\"),(EnumCode {getEnumCode = 76},\"INDEX_DROP\"),(EnumCode {getEnumCode = 77},\"INDEX_LIST\"),(EnumCode {getEnumCode = 64},\"FUNCALL\"),(EnumCode {getEnumCode = 65},\"BRANCH\"),(EnumCode {getEnumCode = 66},\"ANY\"),(EnumCode {getEnumCode = 67},\"ALL\"),(EnumCode {getEnumCode = 68},\"FOREACH\"),(EnumCode {getEnumCode = 69},\"FUNC\"),(EnumCode {getEnumCode = 73},\"ASC\"),(EnumCode {getEnumCode = 74},\"DESC\"),(EnumCode {getEnumCode = 79},\"INFO\"),(EnumCode {getEnumCode = 97},\"MATCH\"),(EnumCode {getEnumCode = 81},\"SAMPLE\"),(EnumCode {getEnumCode = 92},\"DEFAULT\"),(EnumCode {getEnumCode = 98},\"JSON\"),(EnumCode {getEnumCode = 99},\"ISO8601\"),(EnumCode {getEnumCode = 100},\"TO_ISO8601\"),(EnumCode {getEnumCode = 101},\"EPOCH_TIME\"),(EnumCode {getEnumCode = 102},\"TO_EPOCH_TIME\"),(EnumCode {getEnumCode = 103},\"NOW\"),(EnumCode {getEnumCode = 104},\"IN_TIMEZONE\"),(EnumCode {getEnumCode = 105},\"DURING\"),(EnumCode {getEnumCode = 106},\"DATE\"),(EnumCode {getEnumCode = 126},\"TIME_OF_DAY\"),(EnumCode {getEnumCode = 127},\"TIMEZONE\"),(EnumCode {getEnumCode = 128},\"YEAR\"),(EnumCode {getEnumCode = 129},\"MONTH\"),(EnumCode {getEnumCode = 130},\"DAY\"),(EnumCode {getEnumCode = 131},\"DAY_OF_WEEK\"),(EnumCode {getEnumCode = 132},\"DAY_OF_YEAR\"),(EnumCode {getEnumCode = 133},\"HOURS\"),(EnumCode {getEnumCode = 134},\"MINUTES\"),(EnumCode {getEnumCode = 135},\"SECONDS\"),(EnumCode {getEnumCode = 136},\"TIME\"),(EnumCode {getEnumCode = 107},\"MONDAY\"),(EnumCode {getEnumCode = 108},\"TUESDAY\"),(EnumCode {getEnumCode = 109},\"WEDNESDAY\"),(EnumCode {getEnumCode = 110},\"THURSDAY\"),(EnumCode {getEnumCode = 111},\"FRIDAY\"),(EnumCode {getEnumCode = 112},\"SATURDAY\"),(EnumCode {getEnumCode = 113},\"SUNDAY\"),(EnumCode {getEnumCode = 114},\"JANUARY\"),(EnumCode {getEnumCode = 115},\"FEBRUARY\"),(EnumCode {getEnumCode = 116},\"MARCH\"),(EnumCode {getEnumCode = 117},\"APRIL\"),(EnumCode {getEnumCode = 118},\"MAY\"),(EnumCode {getEnumCode = 119},\"JUNE\"),(EnumCode {getEnumCode = 120},\"JULY\"),(EnumCode {getEnumCode = 121},\"AUGUST\"),(EnumCode {getEnumCode = 122},\"SEPTEMBER\"),(EnumCode {getEnumCode = 123},\"OCTOBER\"),(EnumCode {getEnumCode = 124},\"NOVEMBER\"),(EnumCode {getEnumCode = 125},\"DECEMBER\"),(EnumCode {getEnumCode = 137},\"LITERAL\")]}], knownKeyMap = fromList []}"
+
+fileDescriptorProto :: FileDescriptorProto
+fileDescriptorProto
+ = P'.getFromBS (P'.wireGet 11)
+ (P'.pack
+ "\230\SYN\n\tql2.proto\"5\n\fVersionDummy\"%\n\aVersion\DC2\f\n\EOTV0_1\DLE\182\244\134\251\ETX\DC2\f\n\EOTV0_2\DLE\225\131\194\145\a\"\133\STX\n\ENQQuery\DC2\"\n\EOTtype\CAN\SOH \SOH(\SO2\DC4.Ql2.Query.QueryType\DC2\CAN\n\ENQquery\CAN\STX \SOH(\v2\t.Ql2.Term\DC2\r\n\ENQtoken\CAN\ETX \SOH(\ETX\DC2\US\n\DLEOBSOLETE_noreply\CAN\EOT \SOH(\b:\ENQfalse\DC2,\n\SOglobal_optargs\CAN\ACK \ETX(\v2\DC4.Ql2.Query.AssocPair\SUB0\n\tAssocPair\DC2\v\n\ETXkey\CAN\SOH \SOH(\t\DC2\SYN\n\ETXval\CAN\STX \SOH(\v2\t.Ql2.Term\".\n\tQueryType\DC2\t\n\ENQSTART\DLE\SOH\DC2\f\n\bCONTINUE\DLE\STX\DC2\b\n\EOTSTOP\DLE\ETX\"d\n\ENQFrame\DC2\"\n\EOTtype\CAN\SOH \SOH(\SO2\DC4.Ql2.Frame.FrameType\DC2\v\n\ETXpos\CAN\STX \SOH(\ETX\DC2\v\n\ETXopt\CAN\ETX \SOH(\t\"\GS\n\tFrameType\DC2\a\n\ETXPOS\DLE\SOH\DC2\a\n\ETXOPT\DLE\STX\"'\n\tBacktrace\DC2\SUB\n\ACKframes\CAN\SOH \ETX(\v2\n.Ql2.Frame\"\138\STX\n\bResponse\DC2(\n\EOTtype\CAN\SOH \SOH(\SO2\SUB.Ql2.Response.ResponseType\DC2\r\n\ENQtoken\CAN\STX \SOH(\ETX\DC2\FS\n\bresponse\CAN\ETX \ETX(\v2\n.Ql2.Datum\DC2!\n\tbacktrace\CAN\EOT \SOH(\v2\SO.Ql2.Backtrace\"\131\SOH\n\fResponseType\DC2\DLE\n\fSUCCESS_ATOM\DLE\SOH\DC2\DC4\n\DLESUCCESS_SEQUENCE\DLE\STX\DC2\DC3\n\SISUCCESS_PARTIAL\DLE\ETX\DC2\DLE\n\fCLIENT_ERROR\DLE\DLE\DC2\DC1\n\rCOMPILE_ERROR\DLE\DC1\DC2\DC1\n\rRUNTIME_ERROR\DLE\DC2\"\176\STX\n\ENQDatum\DC2\"\n\EOTtype\CAN\SOH \SOH(\SO2\DC4.Ql2.Datum.DatumType\DC2\SO\n\ACKr_bool\CAN\STX \SOH(\b\DC2\r\n\ENQr_num\CAN\ETX \SOH(\SOH\DC2\r\n\ENQr_str\CAN\EOT \SOH(\t\DC2\ESC\n\ar_array\CAN\ENQ \ETX(\v2\n.Ql2.Datum\DC2&\n\br_object\CAN\ACK \ETX(\v2\DC4.Ql2.Datum.AssocPair\SUB1\n\tAssocPair\DC2\v\n\ETXkey\CAN\SOH \SOH(\t\DC2\ETB\n\ETXval\CAN\STX \SOH(\v2\n.Ql2.Datum\"T\n\tDatumType\DC2\n\n\ACKR_NULL\DLE\SOH\DC2\n\n\ACKR_BOOL\DLE\STX\DC2\t\n\ENQR_NUM\DLE\ETX\DC2\t\n\ENQR_STR\DLE\EOT\DC2\v\n\aR_ARRAY\DLE\ENQ\DC2\f\n\bR_OBJECT\DLE\ACK*\a\b\144N\DLE\161\156\SOH\"\202\SO\n\EOTTerm\DC2 \n\EOTtype\CAN\SOH \SOH(\SO2\DC2.Ql2.Term.TermType\DC2\EM\n\ENQdatum\CAN\STX \SOH(\v2\n.Ql2.Datum\DC2\ETB\n\EOTargs\CAN\ETX \ETX(\v2\t.Ql2.Term\DC2$\n\aoptargs\CAN\EOT \ETX(\v2\DC3.Ql2.Term.AssocPair\SUB0\n\tAssocPair\DC2\v\n\ETXkey\CAN\SOH \SOH(\t\DC2\SYN\n\ETXval\CAN\STX \SOH(\v2\t.Ql2.Term\"\138\r\n\bTermType\DC2\t\n\ENQDATUM\DLE\SOH\DC2\SO\n\nMAKE_ARRAY\DLE\STX\DC2\f\n\bMAKE_OBJ\DLE\ETX\DC2\a\n\ETXVAR\DLE\n\DC2\SO\n\nJAVASCRIPT\DLE\v\DC2\t\n\ENQERROR\DLE\f\DC2\DLE\n\fIMPLICIT_VAR\DLE\r\DC2\ACK\n\STXDB\DLE\SO\DC2\t\n\ENQTABLE\DLE\SI\DC2\a\n\ETXGET\DLE\DLE\DC2\v\n\aGET_ALL\DLEN\DC2\ACK\n\STXEQ\DLE\DC1\DC2\ACK\n\STXNE\DLE\DC2\DC2\ACK\n\STXLT\DLE\DC3\DC2\ACK\n\STXLE\DLE\DC4\DC2\ACK\n\STXGT\DLE\NAK\DC2\ACK\n\STXGE\DLE\SYN\DC2\a\n\ETXNOT\DLE\ETB\DC2\a\n\ETXADD\DLE\CAN\DC2\a\n\ETXSUB\DLE\EM\DC2\a\n\ETXMUL\DLE\SUB\DC2\a\n\ETXDIV\DLE\ESC\DC2\a\n\ETXMOD\DLE\FS\DC2\n\n\ACKAPPEND\DLE\GS\DC2\v\n\aPREPEND\DLEP\DC2\SO\n\nDIFFERENCE\DLE_\DC2\SO\n\nSET_INSERT\DLEX\DC2\DC4\n\DLESET_INTERSECTION\DLEY\DC2\r\n\tSET_UNION\DLEZ\DC2\DC2\n\SOSET_DIFFERENCE\DLE[\DC2\t\n\ENQSLICE\DLE\RS\DC2\b\n\EOTSKIP\DLEF\DC2\t\n\ENQLIMIT\DLEG\DC2\SO\n\nINDEXES_OF\DLEW\DC2\f\n\bCONTAINS\DLE]\DC2\r\n\tGET_FIELD\DLE\US\DC2\b\n\EOTKEYS\DLE^\DC2\SO\n\nHAS_FIELDS\DLE \DC2\SI\n\vWITH_FIELDS\DLE`\DC2\t\n\ENQPLUCK\DLE!\DC2\v\n\aWITHOUT\DLE\"\DC2\t\n\ENQMERGE\DLE#\DC2\v\n\aBETWEEN\DLE$\DC2\n\n\ACKREDUCE\DLE%\DC2\a\n\ETXMAP\DLE&\DC2\n\n\ACKFILTER\DLE'\DC2\r\n\tCONCATMAP\DLE(\DC2\v\n\aORDERBY\DLE)\DC2\f\n\bDISTINCT\DLE*\DC2\t\n\ENQCOUNT\DLE+\DC2\f\n\bIS_EMPTY\DLEV\DC2\t\n\ENQUNION\DLE,\DC2\a\n\ETXNTH\DLE-\DC2\SYN\n\DC2GROUPED_MAP_REDUCE\DLE.\DC2\v\n\aGROUPBY\DLE/\DC2\SO\n\nINNER_JOIN\DLE0\DC2\SO\n\nOUTER_JOIN\DLE1\DC2\v\n\aEQ_JOIN\DLE2\DC2\a\n\ETXZIP\DLEH\DC2\r\n\tINSERT_AT\DLER\DC2\r\n\tDELETE_AT\DLES\DC2\r\n\tCHANGE_AT\DLET\DC2\r\n\tSPLICE_AT\DLEU\DC2\r\n\tCOERCE_TO\DLE3\DC2\n\n\ACKTYPEOF\DLE4\DC2\n\n\ACKUPDATE\DLE5\DC2\n\n\ACKDELETE\DLE6\DC2\v\n\aREPLACE\DLE7\DC2\n\n\ACKINSERT\DLE8\DC2\r\n\tDB_CREATE\DLE9\DC2\v\n\aDB_DROP\DLE:\DC2\v\n\aDB_LIST\DLE;\DC2\DLE\n\fTABLE_CREATE\DLE<\DC2\SO\n\nTABLE_DROP\DLE=\DC2\SO\n\nTABLE_LIST\DLE>\DC2\DLE\n\fINDEX_CREATE\DLEK\DC2\SO\n\nINDEX_DROP\DLEL\DC2\SO\n\nINDEX_LIST\DLEM\DC2\v\n\aFUNCALL\DLE@\DC2\n\n\ACKBRANCH\DLEA\DC2\a\n\ETXANY\DLEB\DC2\a\n\ETXALL\DLEC\DC2\v\n\aFOREACH\DLED\DC2\b\n\EOTFUNC\DLEE\DC2\a\n\ETXASC\DLEI\DC2\b\n\EOTDESC\DLEJ\DC2\b\n\EOTINFO\DLEO\DC2\t\n\ENQMATCH\DLEa\DC2\n\n\ACKSAMPLE\DLEQ\DC2\v\n\aDEFAULT\DLE\\\DC2\b\n\EOTJSON\DLEb\DC2\v\n\aISO8601\DLEc\DC2\SO\n\nTO_ISO8601\DLEd\DC2\SO\n\nEPOCH_TIME\DLEe\DC2\DC1\n\rTO_EPOCH_TIME\DLEf\DC2\a\n\ETXNOW\DLEg\DC2\SI\n\vIN_TIMEZONE\DLEh\DC2\n\n\ACKDURING\DLEi\DC2\b\n\EOTDATE\DLEj\DC2\SI\n\vTIME_OF_DAY\DLE~\DC2\f\n\bTIMEZONE\DLE\DEL\DC2\t\n\EOTYEAR\DLE\128\SOH\DC2\n\n\ENQMONTH\DLE\129\SOH\DC2\b\n\ETXDAY\DLE\130\SOH\DC2\DLE\n\vDAY_OF_WEEK\DLE\131\SOH\DC2\DLE\n\vDAY_OF_YEAR\DLE\132\SOH\DC2\n\n\ENQHOURS\DLE\133\SOH\DC2\f\n\aMINUTES\DLE\134\SOH\DC2\f\n\aSECONDS\DLE\135\SOH\DC2\t\n\EOTTIME\DLE\136\SOH\DC2\n\n\ACKMONDAY\DLEk\DC2\v\n\aTUESDAY\DLEl\DC2\r\n\tWEDNESDAY\DLEm\DC2\f\n\bTHURSDAY\DLEn\DC2\n\n\ACKFRIDAY\DLEo\DC2\f\n\bSATURDAY\DLEp\DC2\n\n\ACKSUNDAY\DLEq\DC2\v\n\aJANUARY\DLEr\DC2\f\n\bFEBRUARY\DLEs\DC2\t\n\ENQMARCH\DLEt\DC2\t\n\ENQAPRIL\DLEu\DC2\a\n\ETXMAY\DLEv\DC2\b\n\EOTJUNE\DLEw\DC2\b\n\EOTJULY\DLEx\DC2\n\n\ACKAUGUST\DLEy\DC2\r\n\tSEPTEMBER\DLEz\DC2\v\n\aOCTOBER\DLE{\DC2\f\n\bNOVEMBER\DLE|\DC2\f\n\bDECEMBER\DLE}\DC2\f\n\aLITERAL\DLE\137\SOH*\a\b\144N\DLE\161\156\SOH")
diff --git a/Database/RethinkDB/Protobuf/Ql2/Backtrace.hs b/Database/RethinkDB/Protobuf/Ql2/Backtrace.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Backtrace.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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'
+import qualified Database.RethinkDB.Protobuf.Ql2.Frame as Ql2 (Frame)
+
+data Backtrace = Backtrace{frames :: !(P'.Seq Ql2.Frame)}
+ 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 11 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 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{frames = P'.append (frames 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' -> 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 \".Ql2.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Backtrace\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Backtrace.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Backtrace.frames\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Backtrace\"], baseName' = FName \"frames\"}, 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 \".Ql2.Frame\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Frame\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Datum.hs b/Database/RethinkDB/Protobuf/Ql2/Datum.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Datum.hs
@@ -0,0 +1,88 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Datum (Datum(..)) 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.Protobuf.Ql2.Datum.AssocPair as Ql2.Datum (AssocPair)
+import qualified Database.RethinkDB.Protobuf.Ql2.Datum.DatumType as Ql2.Datum (DatumType)
+
+data Datum = Datum{type' :: !(P'.Maybe Ql2.Datum.DatumType), r_bool :: !(P'.Maybe P'.Bool), r_num :: !(P'.Maybe P'.Double),
+ r_str :: !(P'.Maybe P'.Utf8), r_array :: !(P'.Seq Datum), r_object :: !(P'.Seq Ql2.Datum.AssocPair),
+ ext'field :: !P'.ExtField}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.ExtendMessage Datum where
+ getExtField = ext'field
+ putExtField e'f msg = msg{ext'field = e'f}
+ validExtRanges msg = P'.extRanges (P'.reflectDescriptorInfo msg)
+
+instance P'.Mergeable Datum where
+ mergeAppend (Datum x'1 x'2 x'3 x'4 x'5 x'6 x'7) (Datum y'1 y'2 y'3 y'4 y'5 y'6 y'7)
+ = Datum (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)
+
+instance P'.Default Datum where
+ defaultValue
+ = Datum P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Datum where
+ wireSize ft' self'@(Datum x'1 x'2 x'3 x'4 x'5 x'6 x'7)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeOpt 1 14 x'1 + P'.wireSizeOpt 1 8 x'2 + P'.wireSizeOpt 1 1 x'3 + P'.wireSizeOpt 1 9 x'4 +
+ P'.wireSizeRep 1 11 x'5
+ + P'.wireSizeRep 1 11 x'6
+ + P'.wireSizeExtField x'7)
+ wirePut ft' self'@(Datum x'1 x'2 x'3 x'4 x'5 x'6 x'7)
+ = 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 8 14 x'1
+ P'.wirePutOpt 16 8 x'2
+ P'.wirePutOpt 25 1 x'3
+ P'.wirePutOpt 34 9 x'4
+ P'.wirePutRep 42 11 x'5
+ P'.wirePutRep 50 11 x'6
+ P'.wirePutExtField x'7
+ 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' = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{r_bool = Prelude'.Just new'Field}) (P'.wireGet 8)
+ 25 -> Prelude'.fmap (\ !new'Field -> old'Self{r_num = Prelude'.Just new'Field}) (P'.wireGet 1)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{r_str = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 42 -> Prelude'.fmap (\ !new'Field -> old'Self{r_array = P'.append (r_array old'Self) new'Field}) (P'.wireGet 11)
+ 50 -> Prelude'.fmap (\ !new'Field -> old'Self{r_object = P'.append (r_object old'Self) new'Field}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in
+ if Prelude'.or [10000 <= field'Number && field'Number <= 18999, field'Number == 20000] then
+ P'.loadExtension field'Number wire'Type old'Self else P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> Datum) Datum where
+ getVal m' f' = f' m'
+
+instance P'.GPB Datum
+
+instance P'.ReflectDescriptor Datum where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [8, 16, 25, 34, 42, 50])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Datum.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum.DatumType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"DatumType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_bool\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_bool\"}, 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 = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_num\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_num\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 25}, 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 \".Ql2.Datum.r_str\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_str\"}, 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 \".Ql2.Datum.r_array\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_array\"}, fieldNumber = FieldId {getFieldId = 5}, wireTag = WireTag {getWireTag = 42}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.r_object\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\"], baseName' = FName \"r_object\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 10000},FieldId {getFieldId = 18999}),(FieldId {getFieldId = 20000},FieldId {getFieldId = 20000})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs b/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Datum.AssocPair (AssocPair(..)) 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.Protobuf.Ql2.Datum as Ql2 (Datum)
+
+data AssocPair = AssocPair{key :: !(P'.Maybe P'.Utf8), val :: !(P'.Maybe Ql2.Datum)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable AssocPair where
+ mergeAppend (AssocPair x'1 x'2) (AssocPair y'1 y'2) = AssocPair (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default AssocPair where
+ defaultValue = AssocPair P'.defaultValue P'.defaultValue
+
+instance P'.Wire AssocPair where
+ wireSize ft' self'@(AssocPair x'1 x'2)
+ = 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'.wireSizeOpt 1 11 x'2)
+ wirePut ft' self'@(AssocPair 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'.wirePutOpt 10 9 x'1
+ P'.wirePutOpt 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{key = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{val = P'.mergeAppend (val 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' -> AssocPair) AssocPair where
+ getVal m' f' = f' m'
+
+instance P'.GPB AssocPair
+
+instance P'.ReflectDescriptor AssocPair where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Datum.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Datum\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Datum\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Datum.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Datum.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Datum\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs-boot b/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs-boot
@@ -0,0 +1,30 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Datum.AssocPair (AssocPair) 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 AssocPair
+
+instance P'.MessageAPI msg' (msg' -> AssocPair) AssocPair
+
+instance Prelude'.Show AssocPair
+
+instance Prelude'.Eq AssocPair
+
+instance Prelude'.Ord AssocPair
+
+instance Prelude'.Typeable AssocPair
+
+instance Prelude'.Data AssocPair
+
+instance P'.Mergeable AssocPair
+
+instance P'.Default AssocPair
+
+instance P'.Wire AssocPair
+
+instance P'.GPB AssocPair
+
+instance P'.ReflectDescriptor AssocPair
diff --git a/Database/RethinkDB/Protobuf/Ql2/Datum/DatumType.hs b/Database/RethinkDB/Protobuf/Ql2/Datum/DatumType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Datum/DatumType.hs
@@ -0,0 +1,78 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Datum.DatumType (DatumType(..)) 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 DatumType = R_NULL
+ | R_BOOL
+ | R_NUM
+ | R_STR
+ | R_ARRAY
+ | R_OBJECT
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable DatumType
+
+instance Prelude'.Bounded DatumType where
+ minBound = R_NULL
+ maxBound = R_OBJECT
+
+instance P'.Default DatumType where
+ defaultValue = R_NULL
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe DatumType
+toMaybe'Enum 1 = Prelude'.Just R_NULL
+toMaybe'Enum 2 = Prelude'.Just R_BOOL
+toMaybe'Enum 3 = Prelude'.Just R_NUM
+toMaybe'Enum 4 = Prelude'.Just R_STR
+toMaybe'Enum 5 = Prelude'.Just R_ARRAY
+toMaybe'Enum 6 = Prelude'.Just R_OBJECT
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum DatumType where
+ fromEnum R_NULL = 1
+ fromEnum R_BOOL = 2
+ fromEnum R_NUM = 3
+ fromEnum R_STR = 4
+ fromEnum R_ARRAY = 5
+ fromEnum R_OBJECT = 6
+ toEnum
+ = P'.fromMaybe (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.Datum.DatumType")
+ . toMaybe'Enum
+ succ R_NULL = R_BOOL
+ succ R_BOOL = R_NUM
+ succ R_NUM = R_STR
+ succ R_STR = R_ARRAY
+ succ R_ARRAY = R_OBJECT
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.Datum.DatumType"
+ pred R_BOOL = R_NULL
+ pred R_NUM = R_BOOL
+ pred R_STR = R_NUM
+ pred R_ARRAY = R_STR
+ pred R_OBJECT = R_ARRAY
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.Datum.DatumType"
+
+instance P'.Wire DatumType 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 DatumType
+
+instance P'.MessageAPI msg' (msg' -> DatumType) DatumType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum DatumType where
+ reflectEnum
+ = [(1, "R_NULL", R_NULL), (2, "R_BOOL", R_BOOL), (3, "R_NUM", R_NUM), (4, "R_STR", R_STR), (5, "R_ARRAY", R_ARRAY),
+ (6, "R_OBJECT", R_OBJECT)]
+ reflectEnumInfo _
+ = P'.EnumInfo (P'.makePNF (P'.pack ".Ql2.Datum.DatumType") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "Datum"] "DatumType")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "Datum", "DatumType.hs"]
+ [(1, "R_NULL"), (2, "R_BOOL"), (3, "R_NUM"), (4, "R_STR"), (5, "R_ARRAY"), (6, "R_OBJECT")]
diff --git a/Database/RethinkDB/Protobuf/Ql2/Frame.hs b/Database/RethinkDB/Protobuf/Ql2/Frame.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Frame.hs
@@ -0,0 +1,63 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Frame (Frame(..)) 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.Protobuf.Ql2.Frame.FrameType as Ql2.Frame (FrameType)
+
+data Frame = Frame{type' :: !(P'.Maybe Ql2.Frame.FrameType), pos :: !(P'.Maybe P'.Int64), opt :: !(P'.Maybe P'.Utf8)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Frame where
+ mergeAppend (Frame x'1 x'2 x'3) (Frame y'1 y'2 y'3)
+ = Frame (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)
+
+instance P'.Default Frame where
+ defaultValue = Frame P'.defaultValue P'.defaultValue P'.defaultValue
+
+instance P'.Wire Frame where
+ wireSize ft' self'@(Frame 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'.wireSizeOpt 1 14 x'1 + P'.wireSizeOpt 1 3 x'2 + P'.wireSizeOpt 1 9 x'3)
+ wirePut ft' self'@(Frame 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'.wirePutOpt 8 14 x'1
+ P'.wirePutOpt 16 3 x'2
+ P'.wirePutOpt 26 9 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
+ 8 -> Prelude'.fmap (\ !new'Field -> old'Self{type' = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{pos = Prelude'.Just new'Field}) (P'.wireGet 3)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{opt = Prelude'.Just 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' -> Frame) Frame where
+ getVal m' f' = f' m'
+
+instance P'.GPB Frame
+
+instance P'.ReflectDescriptor Frame where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [8, 16, 26])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Frame\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Frame\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Frame.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Frame.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Frame.FrameType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Frame\"], baseName = MName \"FrameType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Frame.pos\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"pos\"}, 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 \".Ql2.Frame.opt\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Frame\"], baseName' = FName \"opt\"}, fieldNumber = FieldId {getFieldId = 3}, wireTag = WireTag {getWireTag = 26}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, 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/Protobuf/Ql2/Frame/FrameType.hs b/Database/RethinkDB/Protobuf/Ql2/Frame/FrameType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Frame/FrameType.hs
@@ -0,0 +1,56 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Frame.FrameType (FrameType(..)) 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 FrameType = POS
+ | OPT
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable FrameType
+
+instance Prelude'.Bounded FrameType where
+ minBound = POS
+ maxBound = OPT
+
+instance P'.Default FrameType where
+ defaultValue = POS
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe FrameType
+toMaybe'Enum 1 = Prelude'.Just POS
+toMaybe'Enum 2 = Prelude'.Just OPT
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum FrameType where
+ fromEnum POS = 1
+ fromEnum OPT = 2
+ toEnum
+ = P'.fromMaybe (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.Frame.FrameType")
+ . toMaybe'Enum
+ succ POS = OPT
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.Frame.FrameType"
+ pred OPT = POS
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.Frame.FrameType"
+
+instance P'.Wire FrameType 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 FrameType
+
+instance P'.MessageAPI msg' (msg' -> FrameType) FrameType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum FrameType where
+ reflectEnum = [(1, "POS", POS), (2, "OPT", OPT)]
+ reflectEnumInfo _
+ = P'.EnumInfo (P'.makePNF (P'.pack ".Ql2.Frame.FrameType") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "Frame"] "FrameType")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "Frame", "FrameType.hs"]
+ [(1, "POS"), (2, "OPT")]
diff --git a/Database/RethinkDB/Protobuf/Ql2/Query.hs b/Database/RethinkDB/Protobuf/Ql2/Query.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Query.hs
@@ -0,0 +1,75 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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.Protobuf.Ql2.Query.AssocPair as Ql2.Query (AssocPair)
+import qualified Database.RethinkDB.Protobuf.Ql2.Query.QueryType as Ql2.Query (QueryType)
+import qualified Database.RethinkDB.Protobuf.Ql2.Term as Ql2 (Term)
+
+data Query = Query{type' :: !(P'.Maybe Ql2.Query.QueryType), query :: !(P'.Maybe Ql2.Term), token :: !(P'.Maybe P'.Int64),
+ oBSOLETE_noreply :: !(P'.Maybe P'.Bool), global_optargs :: !(P'.Seq Ql2.Query.AssocPair)}
+ 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 (Prelude'.Just Prelude'.False) 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'.wireSizeOpt 1 14 x'1 + P'.wireSizeOpt 1 11 x'2 + P'.wireSizeOpt 1 3 x'3 + P'.wireSizeOpt 1 8 x'4 +
+ P'.wireSizeRep 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'.wirePutOpt 8 14 x'1
+ P'.wirePutOpt 18 11 x'2
+ P'.wirePutOpt 24 3 x'3
+ P'.wirePutOpt 32 8 x'4
+ P'.wirePutRep 50 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' = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{query = P'.mergeAppend (query old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 24 -> Prelude'.fmap (\ !new'Field -> old'Self{token = Prelude'.Just new'Field}) (P'.wireGet 3)
+ 32 -> Prelude'.fmap (\ !new'Field -> old'Self{oBSOLETE_noreply = Prelude'.Just new'Field}) (P'.wireGet 8)
+ 50 -> Prelude'.fmap (\ !new'Field -> old'Self{global_optargs = P'.append (global_optargs 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' -> Query) Query where
+ getVal m' f' = f' m'
+
+instance P'.GPB Query
+
+instance P'.ReflectDescriptor Query where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [8, 18, 24, 32, 50])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Query\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Query\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Query.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Query.QueryType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"QueryType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.query\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"query\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"token\"}, 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},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.OBSOLETE_noreply\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"oBSOLETE_noreply\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 32}, 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)},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.global_optargs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\"], baseName' = FName \"global_optargs\"}, fieldNumber = FieldId {getFieldId = 6}, wireTag = WireTag {getWireTag = 50}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Query.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Query/AssocPair.hs b/Database/RethinkDB/Protobuf/Ql2/Query/AssocPair.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Query/AssocPair.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Query.AssocPair (AssocPair(..)) 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.Protobuf.Ql2.Term as Ql2 (Term)
+
+data AssocPair = AssocPair{key :: !(P'.Maybe P'.Utf8), val :: !(P'.Maybe Ql2.Term)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable AssocPair where
+ mergeAppend (AssocPair x'1 x'2) (AssocPair y'1 y'2) = AssocPair (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default AssocPair where
+ defaultValue = AssocPair P'.defaultValue P'.defaultValue
+
+instance P'.Wire AssocPair where
+ wireSize ft' self'@(AssocPair x'1 x'2)
+ = 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'.wireSizeOpt 1 11 x'2)
+ wirePut ft' self'@(AssocPair 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'.wirePutOpt 10 9 x'1
+ P'.wirePutOpt 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{key = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{val = P'.mergeAppend (val 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' -> AssocPair) AssocPair where
+ getVal m' f' = f' m'
+
+instance P'.GPB AssocPair
+
+instance P'.ReflectDescriptor AssocPair where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Query.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Query\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Query\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Query.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Query.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Query\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Query/QueryType.hs b/Database/RethinkDB/Protobuf/Ql2/Query/QueryType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Query/QueryType.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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 = START
+ | CONTINUE
+ | STOP
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable QueryType
+
+instance Prelude'.Bounded QueryType where
+ minBound = START
+ maxBound = STOP
+
+instance P'.Default QueryType where
+ defaultValue = START
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe QueryType
+toMaybe'Enum 1 = Prelude'.Just START
+toMaybe'Enum 2 = Prelude'.Just CONTINUE
+toMaybe'Enum 3 = Prelude'.Just STOP
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum QueryType where
+ fromEnum START = 1
+ fromEnum CONTINUE = 2
+ fromEnum STOP = 3
+ toEnum
+ = P'.fromMaybe (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.Query.QueryType")
+ . toMaybe'Enum
+ succ START = CONTINUE
+ succ CONTINUE = STOP
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.Query.QueryType"
+ pred CONTINUE = START
+ pred STOP = CONTINUE
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.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, "START", START), (2, "CONTINUE", CONTINUE), (3, "STOP", STOP)]
+ reflectEnumInfo _
+ = P'.EnumInfo (P'.makePNF (P'.pack ".Ql2.Query.QueryType") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "Query"] "QueryType")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "Query", "QueryType.hs"]
+ [(1, "START"), (2, "CONTINUE"), (3, "STOP")]
diff --git a/Database/RethinkDB/Protobuf/Ql2/Response.hs b/Database/RethinkDB/Protobuf/Ql2/Response.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Response.hs
@@ -0,0 +1,70 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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.Protobuf.Ql2.Backtrace as Ql2 (Backtrace)
+import qualified Database.RethinkDB.Protobuf.Ql2.Datum as Ql2 (Datum)
+import qualified Database.RethinkDB.Protobuf.Ql2.Response.ResponseType as Ql2.Response (ResponseType)
+
+data Response = Response{type' :: !(P'.Maybe Ql2.Response.ResponseType), token :: !(P'.Maybe P'.Int64),
+ response :: !(P'.Seq Ql2.Datum), backtrace :: !(P'.Maybe Ql2.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) (Response y'1 y'2 y'3 y'4)
+ = 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)
+
+instance P'.Default Response where
+ defaultValue = Response 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)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = (P'.wireSizeOpt 1 14 x'1 + P'.wireSizeOpt 1 3 x'2 + P'.wireSizeRep 1 11 x'3 + P'.wireSizeOpt 1 11 x'4)
+ wirePut ft' self'@(Response 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 8 14 x'1
+ P'.wirePutOpt 16 3 x'2
+ P'.wirePutRep 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' = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 16 -> Prelude'.fmap (\ !new'Field -> old'Self{token = Prelude'.Just new'Field}) (P'.wireGet 3)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{response = P'.append (response old'Self) new'Field}) (P'.wireGet 11)
+ 34 -> 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 []) (P'.fromDistinctAscList [8, 16, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Response\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Response\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Response.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Response.ResponseType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Response\"], baseName = MName \"ResponseType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.token\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"token\"}, 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 \".Ql2.Response.response\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",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 = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Response.backtrace\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Response\"], baseName' = FName \"backtrace\"}, 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 \".Ql2.Backtrace\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Backtrace\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Response/ResponseType.hs b/Database/RethinkDB/Protobuf/Ql2/Response/ResponseType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Response/ResponseType.hs
@@ -0,0 +1,81 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Response.ResponseType (ResponseType(..)) 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 ResponseType = SUCCESS_ATOM
+ | SUCCESS_SEQUENCE
+ | SUCCESS_PARTIAL
+ | CLIENT_ERROR
+ | COMPILE_ERROR
+ | RUNTIME_ERROR
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable ResponseType
+
+instance Prelude'.Bounded ResponseType where
+ minBound = SUCCESS_ATOM
+ maxBound = RUNTIME_ERROR
+
+instance P'.Default ResponseType where
+ defaultValue = SUCCESS_ATOM
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe ResponseType
+toMaybe'Enum 1 = Prelude'.Just SUCCESS_ATOM
+toMaybe'Enum 2 = Prelude'.Just SUCCESS_SEQUENCE
+toMaybe'Enum 3 = Prelude'.Just SUCCESS_PARTIAL
+toMaybe'Enum 16 = Prelude'.Just CLIENT_ERROR
+toMaybe'Enum 17 = Prelude'.Just COMPILE_ERROR
+toMaybe'Enum 18 = Prelude'.Just RUNTIME_ERROR
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum ResponseType where
+ fromEnum SUCCESS_ATOM = 1
+ fromEnum SUCCESS_SEQUENCE = 2
+ fromEnum SUCCESS_PARTIAL = 3
+ fromEnum CLIENT_ERROR = 16
+ fromEnum COMPILE_ERROR = 17
+ fromEnum RUNTIME_ERROR = 18
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.Response.ResponseType")
+ . toMaybe'Enum
+ succ SUCCESS_ATOM = SUCCESS_SEQUENCE
+ succ SUCCESS_SEQUENCE = SUCCESS_PARTIAL
+ succ SUCCESS_PARTIAL = CLIENT_ERROR
+ succ CLIENT_ERROR = COMPILE_ERROR
+ succ COMPILE_ERROR = RUNTIME_ERROR
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.Response.ResponseType"
+ pred SUCCESS_SEQUENCE = SUCCESS_ATOM
+ pred SUCCESS_PARTIAL = SUCCESS_SEQUENCE
+ pred CLIENT_ERROR = SUCCESS_PARTIAL
+ pred COMPILE_ERROR = CLIENT_ERROR
+ pred RUNTIME_ERROR = COMPILE_ERROR
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.Response.ResponseType"
+
+instance P'.Wire ResponseType 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 ResponseType
+
+instance P'.MessageAPI msg' (msg' -> ResponseType) ResponseType where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum ResponseType where
+ reflectEnum
+ = [(1, "SUCCESS_ATOM", SUCCESS_ATOM), (2, "SUCCESS_SEQUENCE", SUCCESS_SEQUENCE), (3, "SUCCESS_PARTIAL", SUCCESS_PARTIAL),
+ (16, "CLIENT_ERROR", CLIENT_ERROR), (17, "COMPILE_ERROR", COMPILE_ERROR), (18, "RUNTIME_ERROR", RUNTIME_ERROR)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Ql2.Response.ResponseType") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "Response"] "ResponseType")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "Response", "ResponseType.hs"]
+ [(1, "SUCCESS_ATOM"), (2, "SUCCESS_SEQUENCE"), (3, "SUCCESS_PARTIAL"), (16, "CLIENT_ERROR"), (17, "COMPILE_ERROR"),
+ (18, "RUNTIME_ERROR")]
diff --git a/Database/RethinkDB/Protobuf/Ql2/Term.hs b/Database/RethinkDB/Protobuf/Ql2/Term.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Term.hs
@@ -0,0 +1,80 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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.Protobuf.Ql2.Datum as Ql2 (Datum)
+import {-# SOURCE #-} qualified Database.RethinkDB.Protobuf.Ql2.Term.AssocPair as Ql2.Term (AssocPair)
+import qualified Database.RethinkDB.Protobuf.Ql2.Term.TermType as Ql2.Term (TermType)
+
+data Term = Term{type' :: !(P'.Maybe Ql2.Term.TermType), datum :: !(P'.Maybe Ql2.Datum), args :: !(P'.Seq Term),
+ optargs :: !(P'.Seq Ql2.Term.AssocPair), 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) (Term y'1 y'2 y'3 y'4 y'5)
+ = 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)
+
+instance P'.Default Term where
+ defaultValue = Term 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)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size
+ = (P'.wireSizeOpt 1 14 x'1 + P'.wireSizeOpt 1 11 x'2 + P'.wireSizeRep 1 11 x'3 + P'.wireSizeRep 1 11 x'4 +
+ P'.wireSizeExtField x'5)
+ wirePut ft' self'@(Term 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'.wirePutOpt 8 14 x'1
+ P'.wirePutOpt 18 11 x'2
+ P'.wirePutRep 26 11 x'3
+ P'.wirePutRep 34 11 x'4
+ P'.wirePutExtField 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' = Prelude'.Just new'Field}) (P'.wireGet 14)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{datum = P'.mergeAppend (datum old'Self) (Prelude'.Just new'Field)})
+ (P'.wireGet 11)
+ 26 -> Prelude'.fmap (\ !new'Field -> old'Self{args = P'.append (args old'Self) new'Field}) (P'.wireGet 11)
+ 34 -> Prelude'.fmap (\ !new'Field -> old'Self{optargs = P'.append (optargs old'Self) new'Field}) (P'.wireGet 11)
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in
+ if Prelude'.or [10000 <= field'Number && field'Number <= 18999, field'Number == 20000] 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 []) (P'.fromDistinctAscList [8, 18, 26, 34])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Term.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.type\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"type'\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 8}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 14}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Term.TermType\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"TermType\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.datum\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"datum\"}, 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 \".Ql2.Datum\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Datum\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.args\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"args\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.optargs\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\"], baseName' = FName \"optargs\"}, fieldNumber = FieldId {getFieldId = 4}, wireTag = WireTag {getWireTag = 34}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".Ql2.Term.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"AssocPair\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [(FieldId {getFieldId = 10000},FieldId {getFieldId = 18999}),(FieldId {getFieldId = 20000},FieldId {getFieldId = 20000})], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs b/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Term.AssocPair (AssocPair(..)) 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.Protobuf.Ql2.Term as Ql2 (Term)
+
+data AssocPair = AssocPair{key :: !(P'.Maybe P'.Utf8), val :: !(P'.Maybe Ql2.Term)}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable AssocPair where
+ mergeAppend (AssocPair x'1 x'2) (AssocPair y'1 y'2) = AssocPair (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2)
+
+instance P'.Default AssocPair where
+ defaultValue = AssocPair P'.defaultValue P'.defaultValue
+
+instance P'.Wire AssocPair where
+ wireSize ft' self'@(AssocPair x'1 x'2)
+ = 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'.wireSizeOpt 1 11 x'2)
+ wirePut ft' self'@(AssocPair 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'.wirePutOpt 10 9 x'1
+ P'.wirePutOpt 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{key = Prelude'.Just new'Field}) (P'.wireGet 9)
+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{val = P'.mergeAppend (val 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' -> AssocPair) AssocPair where
+ getVal m' f' = f' m'
+
+instance P'.GPB AssocPair
+
+instance P'.ReflectDescriptor AssocPair where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 18])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.Term.AssocPair\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\",MName \"Term\"], baseName = MName \"AssocPair\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"Term\",\"AssocPair.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".Ql2.Term.AssocPair.key\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\",MName \"AssocPair\"], baseName' = FName \"key\"}, 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 \".Ql2.Term.AssocPair.val\", haskellPrefix' = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule' = [MName \"Ql2\",MName \"Term\",MName \"AssocPair\"], baseName' = FName \"val\"}, 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 \".Ql2.Term\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"Term\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs-boot b/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs-boot
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs-boot
@@ -0,0 +1,30 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.Term.AssocPair (AssocPair) 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 AssocPair
+
+instance P'.MessageAPI msg' (msg' -> AssocPair) AssocPair
+
+instance Prelude'.Show AssocPair
+
+instance Prelude'.Eq AssocPair
+
+instance Prelude'.Ord AssocPair
+
+instance Prelude'.Typeable AssocPair
+
+instance Prelude'.Data AssocPair
+
+instance P'.Mergeable AssocPair
+
+instance P'.Default AssocPair
+
+instance P'.Wire AssocPair
+
+instance P'.GPB AssocPair
+
+instance P'.ReflectDescriptor AssocPair
diff --git a/Database/RethinkDB/Protobuf/Ql2/Term/TermType.hs b/Database/RethinkDB/Protobuf/Ql2/Term/TermType.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/Term/TermType.hs
@@ -0,0 +1,744 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.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 = DATUM
+ | MAKE_ARRAY
+ | MAKE_OBJ
+ | VAR
+ | JAVASCRIPT
+ | ERROR
+ | IMPLICIT_VAR
+ | DB
+ | TABLE
+ | GET
+ | GET_ALL
+ | EQ
+ | NE
+ | LT
+ | LE
+ | GT
+ | GE
+ | NOT
+ | ADD
+ | SUB
+ | MUL
+ | DIV
+ | MOD
+ | APPEND
+ | PREPEND
+ | DIFFERENCE
+ | SET_INSERT
+ | SET_INTERSECTION
+ | SET_UNION
+ | SET_DIFFERENCE
+ | SLICE
+ | SKIP
+ | LIMIT
+ | INDEXES_OF
+ | CONTAINS
+ | GET_FIELD
+ | KEYS
+ | HAS_FIELDS
+ | WITH_FIELDS
+ | PLUCK
+ | WITHOUT
+ | MERGE
+ | BETWEEN
+ | REDUCE
+ | MAP
+ | FILTER
+ | CONCATMAP
+ | ORDERBY
+ | DISTINCT
+ | COUNT
+ | IS_EMPTY
+ | UNION
+ | NTH
+ | GROUPED_MAP_REDUCE
+ | GROUPBY
+ | INNER_JOIN
+ | OUTER_JOIN
+ | EQ_JOIN
+ | ZIP
+ | INSERT_AT
+ | DELETE_AT
+ | CHANGE_AT
+ | SPLICE_AT
+ | COERCE_TO
+ | TYPEOF
+ | UPDATE
+ | DELETE
+ | REPLACE
+ | INSERT
+ | DB_CREATE
+ | DB_DROP
+ | DB_LIST
+ | TABLE_CREATE
+ | TABLE_DROP
+ | TABLE_LIST
+ | INDEX_CREATE
+ | INDEX_DROP
+ | INDEX_LIST
+ | FUNCALL
+ | BRANCH
+ | ANY
+ | ALL
+ | FOREACH
+ | FUNC
+ | ASC
+ | DESC
+ | INFO
+ | MATCH
+ | SAMPLE
+ | DEFAULT
+ | JSON
+ | ISO8601
+ | TO_ISO8601
+ | EPOCH_TIME
+ | TO_EPOCH_TIME
+ | NOW
+ | IN_TIMEZONE
+ | DURING
+ | DATE
+ | TIME_OF_DAY
+ | TIMEZONE
+ | YEAR
+ | MONTH
+ | DAY
+ | DAY_OF_WEEK
+ | DAY_OF_YEAR
+ | HOURS
+ | MINUTES
+ | SECONDS
+ | TIME
+ | MONDAY
+ | TUESDAY
+ | WEDNESDAY
+ | THURSDAY
+ | FRIDAY
+ | SATURDAY
+ | SUNDAY
+ | JANUARY
+ | FEBRUARY
+ | MARCH
+ | APRIL
+ | MAY
+ | JUNE
+ | JULY
+ | AUGUST
+ | SEPTEMBER
+ | OCTOBER
+ | NOVEMBER
+ | DECEMBER
+ | LITERAL
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable TermType
+
+instance Prelude'.Bounded TermType where
+ minBound = DATUM
+ maxBound = LITERAL
+
+instance P'.Default TermType where
+ defaultValue = DATUM
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe TermType
+toMaybe'Enum 1 = Prelude'.Just DATUM
+toMaybe'Enum 2 = Prelude'.Just MAKE_ARRAY
+toMaybe'Enum 3 = Prelude'.Just MAKE_OBJ
+toMaybe'Enum 10 = Prelude'.Just VAR
+toMaybe'Enum 11 = Prelude'.Just JAVASCRIPT
+toMaybe'Enum 12 = Prelude'.Just ERROR
+toMaybe'Enum 13 = Prelude'.Just IMPLICIT_VAR
+toMaybe'Enum 14 = Prelude'.Just DB
+toMaybe'Enum 15 = Prelude'.Just TABLE
+toMaybe'Enum 16 = Prelude'.Just GET
+toMaybe'Enum 78 = Prelude'.Just GET_ALL
+toMaybe'Enum 17 = Prelude'.Just EQ
+toMaybe'Enum 18 = Prelude'.Just NE
+toMaybe'Enum 19 = Prelude'.Just LT
+toMaybe'Enum 20 = Prelude'.Just LE
+toMaybe'Enum 21 = Prelude'.Just GT
+toMaybe'Enum 22 = Prelude'.Just GE
+toMaybe'Enum 23 = Prelude'.Just NOT
+toMaybe'Enum 24 = Prelude'.Just ADD
+toMaybe'Enum 25 = Prelude'.Just SUB
+toMaybe'Enum 26 = Prelude'.Just MUL
+toMaybe'Enum 27 = Prelude'.Just DIV
+toMaybe'Enum 28 = Prelude'.Just MOD
+toMaybe'Enum 29 = Prelude'.Just APPEND
+toMaybe'Enum 80 = Prelude'.Just PREPEND
+toMaybe'Enum 95 = Prelude'.Just DIFFERENCE
+toMaybe'Enum 88 = Prelude'.Just SET_INSERT
+toMaybe'Enum 89 = Prelude'.Just SET_INTERSECTION
+toMaybe'Enum 90 = Prelude'.Just SET_UNION
+toMaybe'Enum 91 = Prelude'.Just SET_DIFFERENCE
+toMaybe'Enum 30 = Prelude'.Just SLICE
+toMaybe'Enum 70 = Prelude'.Just SKIP
+toMaybe'Enum 71 = Prelude'.Just LIMIT
+toMaybe'Enum 87 = Prelude'.Just INDEXES_OF
+toMaybe'Enum 93 = Prelude'.Just CONTAINS
+toMaybe'Enum 31 = Prelude'.Just GET_FIELD
+toMaybe'Enum 94 = Prelude'.Just KEYS
+toMaybe'Enum 32 = Prelude'.Just HAS_FIELDS
+toMaybe'Enum 96 = Prelude'.Just WITH_FIELDS
+toMaybe'Enum 33 = Prelude'.Just PLUCK
+toMaybe'Enum 34 = Prelude'.Just WITHOUT
+toMaybe'Enum 35 = Prelude'.Just MERGE
+toMaybe'Enum 36 = Prelude'.Just BETWEEN
+toMaybe'Enum 37 = Prelude'.Just REDUCE
+toMaybe'Enum 38 = Prelude'.Just MAP
+toMaybe'Enum 39 = Prelude'.Just FILTER
+toMaybe'Enum 40 = Prelude'.Just CONCATMAP
+toMaybe'Enum 41 = Prelude'.Just ORDERBY
+toMaybe'Enum 42 = Prelude'.Just DISTINCT
+toMaybe'Enum 43 = Prelude'.Just COUNT
+toMaybe'Enum 86 = Prelude'.Just IS_EMPTY
+toMaybe'Enum 44 = Prelude'.Just UNION
+toMaybe'Enum 45 = Prelude'.Just NTH
+toMaybe'Enum 46 = Prelude'.Just GROUPED_MAP_REDUCE
+toMaybe'Enum 47 = Prelude'.Just GROUPBY
+toMaybe'Enum 48 = Prelude'.Just INNER_JOIN
+toMaybe'Enum 49 = Prelude'.Just OUTER_JOIN
+toMaybe'Enum 50 = Prelude'.Just EQ_JOIN
+toMaybe'Enum 72 = Prelude'.Just ZIP
+toMaybe'Enum 82 = Prelude'.Just INSERT_AT
+toMaybe'Enum 83 = Prelude'.Just DELETE_AT
+toMaybe'Enum 84 = Prelude'.Just CHANGE_AT
+toMaybe'Enum 85 = Prelude'.Just SPLICE_AT
+toMaybe'Enum 51 = Prelude'.Just COERCE_TO
+toMaybe'Enum 52 = Prelude'.Just TYPEOF
+toMaybe'Enum 53 = Prelude'.Just UPDATE
+toMaybe'Enum 54 = Prelude'.Just DELETE
+toMaybe'Enum 55 = Prelude'.Just REPLACE
+toMaybe'Enum 56 = Prelude'.Just INSERT
+toMaybe'Enum 57 = Prelude'.Just DB_CREATE
+toMaybe'Enum 58 = Prelude'.Just DB_DROP
+toMaybe'Enum 59 = Prelude'.Just DB_LIST
+toMaybe'Enum 60 = Prelude'.Just TABLE_CREATE
+toMaybe'Enum 61 = Prelude'.Just TABLE_DROP
+toMaybe'Enum 62 = Prelude'.Just TABLE_LIST
+toMaybe'Enum 75 = Prelude'.Just INDEX_CREATE
+toMaybe'Enum 76 = Prelude'.Just INDEX_DROP
+toMaybe'Enum 77 = Prelude'.Just INDEX_LIST
+toMaybe'Enum 64 = Prelude'.Just FUNCALL
+toMaybe'Enum 65 = Prelude'.Just BRANCH
+toMaybe'Enum 66 = Prelude'.Just ANY
+toMaybe'Enum 67 = Prelude'.Just ALL
+toMaybe'Enum 68 = Prelude'.Just FOREACH
+toMaybe'Enum 69 = Prelude'.Just FUNC
+toMaybe'Enum 73 = Prelude'.Just ASC
+toMaybe'Enum 74 = Prelude'.Just DESC
+toMaybe'Enum 79 = Prelude'.Just INFO
+toMaybe'Enum 97 = Prelude'.Just MATCH
+toMaybe'Enum 81 = Prelude'.Just SAMPLE
+toMaybe'Enum 92 = Prelude'.Just DEFAULT
+toMaybe'Enum 98 = Prelude'.Just JSON
+toMaybe'Enum 99 = Prelude'.Just ISO8601
+toMaybe'Enum 100 = Prelude'.Just TO_ISO8601
+toMaybe'Enum 101 = Prelude'.Just EPOCH_TIME
+toMaybe'Enum 102 = Prelude'.Just TO_EPOCH_TIME
+toMaybe'Enum 103 = Prelude'.Just NOW
+toMaybe'Enum 104 = Prelude'.Just IN_TIMEZONE
+toMaybe'Enum 105 = Prelude'.Just DURING
+toMaybe'Enum 106 = Prelude'.Just DATE
+toMaybe'Enum 126 = Prelude'.Just TIME_OF_DAY
+toMaybe'Enum 127 = Prelude'.Just TIMEZONE
+toMaybe'Enum 128 = Prelude'.Just YEAR
+toMaybe'Enum 129 = Prelude'.Just MONTH
+toMaybe'Enum 130 = Prelude'.Just DAY
+toMaybe'Enum 131 = Prelude'.Just DAY_OF_WEEK
+toMaybe'Enum 132 = Prelude'.Just DAY_OF_YEAR
+toMaybe'Enum 133 = Prelude'.Just HOURS
+toMaybe'Enum 134 = Prelude'.Just MINUTES
+toMaybe'Enum 135 = Prelude'.Just SECONDS
+toMaybe'Enum 136 = Prelude'.Just TIME
+toMaybe'Enum 107 = Prelude'.Just MONDAY
+toMaybe'Enum 108 = Prelude'.Just TUESDAY
+toMaybe'Enum 109 = Prelude'.Just WEDNESDAY
+toMaybe'Enum 110 = Prelude'.Just THURSDAY
+toMaybe'Enum 111 = Prelude'.Just FRIDAY
+toMaybe'Enum 112 = Prelude'.Just SATURDAY
+toMaybe'Enum 113 = Prelude'.Just SUNDAY
+toMaybe'Enum 114 = Prelude'.Just JANUARY
+toMaybe'Enum 115 = Prelude'.Just FEBRUARY
+toMaybe'Enum 116 = Prelude'.Just MARCH
+toMaybe'Enum 117 = Prelude'.Just APRIL
+toMaybe'Enum 118 = Prelude'.Just MAY
+toMaybe'Enum 119 = Prelude'.Just JUNE
+toMaybe'Enum 120 = Prelude'.Just JULY
+toMaybe'Enum 121 = Prelude'.Just AUGUST
+toMaybe'Enum 122 = Prelude'.Just SEPTEMBER
+toMaybe'Enum 123 = Prelude'.Just OCTOBER
+toMaybe'Enum 124 = Prelude'.Just NOVEMBER
+toMaybe'Enum 125 = Prelude'.Just DECEMBER
+toMaybe'Enum 137 = Prelude'.Just LITERAL
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum TermType where
+ fromEnum DATUM = 1
+ fromEnum MAKE_ARRAY = 2
+ fromEnum MAKE_OBJ = 3
+ fromEnum VAR = 10
+ fromEnum JAVASCRIPT = 11
+ fromEnum ERROR = 12
+ fromEnum IMPLICIT_VAR = 13
+ fromEnum DB = 14
+ fromEnum TABLE = 15
+ fromEnum GET = 16
+ fromEnum GET_ALL = 78
+ fromEnum EQ = 17
+ fromEnum NE = 18
+ fromEnum LT = 19
+ fromEnum LE = 20
+ fromEnum GT = 21
+ fromEnum GE = 22
+ fromEnum NOT = 23
+ fromEnum ADD = 24
+ fromEnum SUB = 25
+ fromEnum MUL = 26
+ fromEnum DIV = 27
+ fromEnum MOD = 28
+ fromEnum APPEND = 29
+ fromEnum PREPEND = 80
+ fromEnum DIFFERENCE = 95
+ fromEnum SET_INSERT = 88
+ fromEnum SET_INTERSECTION = 89
+ fromEnum SET_UNION = 90
+ fromEnum SET_DIFFERENCE = 91
+ fromEnum SLICE = 30
+ fromEnum SKIP = 70
+ fromEnum LIMIT = 71
+ fromEnum INDEXES_OF = 87
+ fromEnum CONTAINS = 93
+ fromEnum GET_FIELD = 31
+ fromEnum KEYS = 94
+ fromEnum HAS_FIELDS = 32
+ fromEnum WITH_FIELDS = 96
+ fromEnum PLUCK = 33
+ fromEnum WITHOUT = 34
+ fromEnum MERGE = 35
+ fromEnum BETWEEN = 36
+ fromEnum REDUCE = 37
+ fromEnum MAP = 38
+ fromEnum FILTER = 39
+ fromEnum CONCATMAP = 40
+ fromEnum ORDERBY = 41
+ fromEnum DISTINCT = 42
+ fromEnum COUNT = 43
+ fromEnum IS_EMPTY = 86
+ fromEnum UNION = 44
+ fromEnum NTH = 45
+ fromEnum GROUPED_MAP_REDUCE = 46
+ fromEnum GROUPBY = 47
+ fromEnum INNER_JOIN = 48
+ fromEnum OUTER_JOIN = 49
+ fromEnum EQ_JOIN = 50
+ fromEnum ZIP = 72
+ fromEnum INSERT_AT = 82
+ fromEnum DELETE_AT = 83
+ fromEnum CHANGE_AT = 84
+ fromEnum SPLICE_AT = 85
+ fromEnum COERCE_TO = 51
+ fromEnum TYPEOF = 52
+ fromEnum UPDATE = 53
+ fromEnum DELETE = 54
+ fromEnum REPLACE = 55
+ fromEnum INSERT = 56
+ fromEnum DB_CREATE = 57
+ fromEnum DB_DROP = 58
+ fromEnum DB_LIST = 59
+ fromEnum TABLE_CREATE = 60
+ fromEnum TABLE_DROP = 61
+ fromEnum TABLE_LIST = 62
+ fromEnum INDEX_CREATE = 75
+ fromEnum INDEX_DROP = 76
+ fromEnum INDEX_LIST = 77
+ fromEnum FUNCALL = 64
+ fromEnum BRANCH = 65
+ fromEnum ANY = 66
+ fromEnum ALL = 67
+ fromEnum FOREACH = 68
+ fromEnum FUNC = 69
+ fromEnum ASC = 73
+ fromEnum DESC = 74
+ fromEnum INFO = 79
+ fromEnum MATCH = 97
+ fromEnum SAMPLE = 81
+ fromEnum DEFAULT = 92
+ fromEnum JSON = 98
+ fromEnum ISO8601 = 99
+ fromEnum TO_ISO8601 = 100
+ fromEnum EPOCH_TIME = 101
+ fromEnum TO_EPOCH_TIME = 102
+ fromEnum NOW = 103
+ fromEnum IN_TIMEZONE = 104
+ fromEnum DURING = 105
+ fromEnum DATE = 106
+ fromEnum TIME_OF_DAY = 126
+ fromEnum TIMEZONE = 127
+ fromEnum YEAR = 128
+ fromEnum MONTH = 129
+ fromEnum DAY = 130
+ fromEnum DAY_OF_WEEK = 131
+ fromEnum DAY_OF_YEAR = 132
+ fromEnum HOURS = 133
+ fromEnum MINUTES = 134
+ fromEnum SECONDS = 135
+ fromEnum TIME = 136
+ fromEnum MONDAY = 107
+ fromEnum TUESDAY = 108
+ fromEnum WEDNESDAY = 109
+ fromEnum THURSDAY = 110
+ fromEnum FRIDAY = 111
+ fromEnum SATURDAY = 112
+ fromEnum SUNDAY = 113
+ fromEnum JANUARY = 114
+ fromEnum FEBRUARY = 115
+ fromEnum MARCH = 116
+ fromEnum APRIL = 117
+ fromEnum MAY = 118
+ fromEnum JUNE = 119
+ fromEnum JULY = 120
+ fromEnum AUGUST = 121
+ fromEnum SEPTEMBER = 122
+ fromEnum OCTOBER = 123
+ fromEnum NOVEMBER = 124
+ fromEnum DECEMBER = 125
+ fromEnum LITERAL = 137
+ toEnum
+ = P'.fromMaybe (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.Term.TermType") .
+ toMaybe'Enum
+ succ DATUM = MAKE_ARRAY
+ succ MAKE_ARRAY = MAKE_OBJ
+ succ MAKE_OBJ = VAR
+ succ VAR = JAVASCRIPT
+ succ JAVASCRIPT = ERROR
+ succ ERROR = IMPLICIT_VAR
+ succ IMPLICIT_VAR = DB
+ succ DB = TABLE
+ succ TABLE = GET
+ succ GET = GET_ALL
+ succ GET_ALL = EQ
+ succ EQ = NE
+ succ NE = LT
+ succ LT = LE
+ succ LE = GT
+ succ GT = GE
+ succ GE = NOT
+ succ NOT = ADD
+ succ ADD = SUB
+ succ SUB = MUL
+ succ MUL = DIV
+ succ DIV = MOD
+ succ MOD = APPEND
+ succ APPEND = PREPEND
+ succ PREPEND = DIFFERENCE
+ succ DIFFERENCE = SET_INSERT
+ succ SET_INSERT = SET_INTERSECTION
+ succ SET_INTERSECTION = SET_UNION
+ succ SET_UNION = SET_DIFFERENCE
+ succ SET_DIFFERENCE = SLICE
+ succ SLICE = SKIP
+ succ SKIP = LIMIT
+ succ LIMIT = INDEXES_OF
+ succ INDEXES_OF = CONTAINS
+ succ CONTAINS = GET_FIELD
+ succ GET_FIELD = KEYS
+ succ KEYS = HAS_FIELDS
+ succ HAS_FIELDS = WITH_FIELDS
+ succ WITH_FIELDS = PLUCK
+ succ PLUCK = WITHOUT
+ succ WITHOUT = MERGE
+ succ MERGE = BETWEEN
+ succ BETWEEN = REDUCE
+ succ REDUCE = MAP
+ succ MAP = FILTER
+ succ FILTER = CONCATMAP
+ succ CONCATMAP = ORDERBY
+ succ ORDERBY = DISTINCT
+ succ DISTINCT = COUNT
+ succ COUNT = IS_EMPTY
+ succ IS_EMPTY = UNION
+ succ UNION = NTH
+ succ NTH = GROUPED_MAP_REDUCE
+ succ GROUPED_MAP_REDUCE = GROUPBY
+ succ GROUPBY = INNER_JOIN
+ succ INNER_JOIN = OUTER_JOIN
+ succ OUTER_JOIN = EQ_JOIN
+ succ EQ_JOIN = ZIP
+ succ ZIP = INSERT_AT
+ succ INSERT_AT = DELETE_AT
+ succ DELETE_AT = CHANGE_AT
+ succ CHANGE_AT = SPLICE_AT
+ succ SPLICE_AT = COERCE_TO
+ succ COERCE_TO = TYPEOF
+ succ TYPEOF = UPDATE
+ succ UPDATE = DELETE
+ succ DELETE = REPLACE
+ succ REPLACE = INSERT
+ succ INSERT = DB_CREATE
+ succ DB_CREATE = DB_DROP
+ succ DB_DROP = DB_LIST
+ succ DB_LIST = TABLE_CREATE
+ succ TABLE_CREATE = TABLE_DROP
+ succ TABLE_DROP = TABLE_LIST
+ succ TABLE_LIST = INDEX_CREATE
+ succ INDEX_CREATE = INDEX_DROP
+ succ INDEX_DROP = INDEX_LIST
+ succ INDEX_LIST = FUNCALL
+ succ FUNCALL = BRANCH
+ succ BRANCH = ANY
+ succ ANY = ALL
+ succ ALL = FOREACH
+ succ FOREACH = FUNC
+ succ FUNC = ASC
+ succ ASC = DESC
+ succ DESC = INFO
+ succ INFO = MATCH
+ succ MATCH = SAMPLE
+ succ SAMPLE = DEFAULT
+ succ DEFAULT = JSON
+ succ JSON = ISO8601
+ succ ISO8601 = TO_ISO8601
+ succ TO_ISO8601 = EPOCH_TIME
+ succ EPOCH_TIME = TO_EPOCH_TIME
+ succ TO_EPOCH_TIME = NOW
+ succ NOW = IN_TIMEZONE
+ succ IN_TIMEZONE = DURING
+ succ DURING = DATE
+ succ DATE = TIME_OF_DAY
+ succ TIME_OF_DAY = TIMEZONE
+ succ TIMEZONE = YEAR
+ succ YEAR = MONTH
+ succ MONTH = DAY
+ succ DAY = DAY_OF_WEEK
+ succ DAY_OF_WEEK = DAY_OF_YEAR
+ succ DAY_OF_YEAR = HOURS
+ succ HOURS = MINUTES
+ succ MINUTES = SECONDS
+ succ SECONDS = TIME
+ succ TIME = MONDAY
+ succ MONDAY = TUESDAY
+ succ TUESDAY = WEDNESDAY
+ succ WEDNESDAY = THURSDAY
+ succ THURSDAY = FRIDAY
+ succ FRIDAY = SATURDAY
+ succ SATURDAY = SUNDAY
+ succ SUNDAY = JANUARY
+ succ JANUARY = FEBRUARY
+ succ FEBRUARY = MARCH
+ succ MARCH = APRIL
+ succ APRIL = MAY
+ succ MAY = JUNE
+ succ JUNE = JULY
+ succ JULY = AUGUST
+ succ AUGUST = SEPTEMBER
+ succ SEPTEMBER = OCTOBER
+ succ OCTOBER = NOVEMBER
+ succ NOVEMBER = DECEMBER
+ succ DECEMBER = LITERAL
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.Term.TermType"
+ pred MAKE_ARRAY = DATUM
+ pred MAKE_OBJ = MAKE_ARRAY
+ pred VAR = MAKE_OBJ
+ pred JAVASCRIPT = VAR
+ pred ERROR = JAVASCRIPT
+ pred IMPLICIT_VAR = ERROR
+ pred DB = IMPLICIT_VAR
+ pred TABLE = DB
+ pred GET = TABLE
+ pred GET_ALL = GET
+ pred EQ = GET_ALL
+ pred NE = EQ
+ pred LT = NE
+ pred LE = LT
+ pred GT = LE
+ pred GE = GT
+ pred NOT = GE
+ pred ADD = NOT
+ pred SUB = ADD
+ pred MUL = SUB
+ pred DIV = MUL
+ pred MOD = DIV
+ pred APPEND = MOD
+ pred PREPEND = APPEND
+ pred DIFFERENCE = PREPEND
+ pred SET_INSERT = DIFFERENCE
+ pred SET_INTERSECTION = SET_INSERT
+ pred SET_UNION = SET_INTERSECTION
+ pred SET_DIFFERENCE = SET_UNION
+ pred SLICE = SET_DIFFERENCE
+ pred SKIP = SLICE
+ pred LIMIT = SKIP
+ pred INDEXES_OF = LIMIT
+ pred CONTAINS = INDEXES_OF
+ pred GET_FIELD = CONTAINS
+ pred KEYS = GET_FIELD
+ pred HAS_FIELDS = KEYS
+ pred WITH_FIELDS = HAS_FIELDS
+ pred PLUCK = WITH_FIELDS
+ pred WITHOUT = PLUCK
+ pred MERGE = WITHOUT
+ pred BETWEEN = MERGE
+ pred REDUCE = BETWEEN
+ pred MAP = REDUCE
+ pred FILTER = MAP
+ pred CONCATMAP = FILTER
+ pred ORDERBY = CONCATMAP
+ pred DISTINCT = ORDERBY
+ pred COUNT = DISTINCT
+ pred IS_EMPTY = COUNT
+ pred UNION = IS_EMPTY
+ pred NTH = UNION
+ pred GROUPED_MAP_REDUCE = NTH
+ pred GROUPBY = GROUPED_MAP_REDUCE
+ pred INNER_JOIN = GROUPBY
+ pred OUTER_JOIN = INNER_JOIN
+ pred EQ_JOIN = OUTER_JOIN
+ pred ZIP = EQ_JOIN
+ pred INSERT_AT = ZIP
+ pred DELETE_AT = INSERT_AT
+ pred CHANGE_AT = DELETE_AT
+ pred SPLICE_AT = CHANGE_AT
+ pred COERCE_TO = SPLICE_AT
+ pred TYPEOF = COERCE_TO
+ pred UPDATE = TYPEOF
+ pred DELETE = UPDATE
+ pred REPLACE = DELETE
+ pred INSERT = REPLACE
+ pred DB_CREATE = INSERT
+ pred DB_DROP = DB_CREATE
+ pred DB_LIST = DB_DROP
+ pred TABLE_CREATE = DB_LIST
+ pred TABLE_DROP = TABLE_CREATE
+ pred TABLE_LIST = TABLE_DROP
+ pred INDEX_CREATE = TABLE_LIST
+ pred INDEX_DROP = INDEX_CREATE
+ pred INDEX_LIST = INDEX_DROP
+ pred FUNCALL = INDEX_LIST
+ pred BRANCH = FUNCALL
+ pred ANY = BRANCH
+ pred ALL = ANY
+ pred FOREACH = ALL
+ pred FUNC = FOREACH
+ pred ASC = FUNC
+ pred DESC = ASC
+ pred INFO = DESC
+ pred MATCH = INFO
+ pred SAMPLE = MATCH
+ pred DEFAULT = SAMPLE
+ pred JSON = DEFAULT
+ pred ISO8601 = JSON
+ pred TO_ISO8601 = ISO8601
+ pred EPOCH_TIME = TO_ISO8601
+ pred TO_EPOCH_TIME = EPOCH_TIME
+ pred NOW = TO_EPOCH_TIME
+ pred IN_TIMEZONE = NOW
+ pred DURING = IN_TIMEZONE
+ pred DATE = DURING
+ pred TIME_OF_DAY = DATE
+ pred TIMEZONE = TIME_OF_DAY
+ pred YEAR = TIMEZONE
+ pred MONTH = YEAR
+ pred DAY = MONTH
+ pred DAY_OF_WEEK = DAY
+ pred DAY_OF_YEAR = DAY_OF_WEEK
+ pred HOURS = DAY_OF_YEAR
+ pred MINUTES = HOURS
+ pred SECONDS = MINUTES
+ pred TIME = SECONDS
+ pred MONDAY = TIME
+ pred TUESDAY = MONDAY
+ pred WEDNESDAY = TUESDAY
+ pred THURSDAY = WEDNESDAY
+ pred FRIDAY = THURSDAY
+ pred SATURDAY = FRIDAY
+ pred SUNDAY = SATURDAY
+ pred JANUARY = SUNDAY
+ pred FEBRUARY = JANUARY
+ pred MARCH = FEBRUARY
+ pred APRIL = MARCH
+ pred MAY = APRIL
+ pred JUNE = MAY
+ pred JULY = JUNE
+ pred AUGUST = JULY
+ pred SEPTEMBER = AUGUST
+ pred OCTOBER = SEPTEMBER
+ pred NOVEMBER = OCTOBER
+ pred DECEMBER = NOVEMBER
+ pred LITERAL = DECEMBER
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.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
+ = [(1, "DATUM", DATUM), (2, "MAKE_ARRAY", MAKE_ARRAY), (3, "MAKE_OBJ", MAKE_OBJ), (10, "VAR", VAR),
+ (11, "JAVASCRIPT", JAVASCRIPT), (12, "ERROR", ERROR), (13, "IMPLICIT_VAR", IMPLICIT_VAR), (14, "DB", DB),
+ (15, "TABLE", TABLE), (16, "GET", GET), (78, "GET_ALL", GET_ALL), (17, "EQ", EQ), (18, "NE", NE), (19, "LT", LT),
+ (20, "LE", LE), (21, "GT", GT), (22, "GE", GE), (23, "NOT", NOT), (24, "ADD", ADD), (25, "SUB", SUB), (26, "MUL", MUL),
+ (27, "DIV", DIV), (28, "MOD", MOD), (29, "APPEND", APPEND), (80, "PREPEND", PREPEND), (95, "DIFFERENCE", DIFFERENCE),
+ (88, "SET_INSERT", SET_INSERT), (89, "SET_INTERSECTION", SET_INTERSECTION), (90, "SET_UNION", SET_UNION),
+ (91, "SET_DIFFERENCE", SET_DIFFERENCE), (30, "SLICE", SLICE), (70, "SKIP", SKIP), (71, "LIMIT", LIMIT),
+ (87, "INDEXES_OF", INDEXES_OF), (93, "CONTAINS", CONTAINS), (31, "GET_FIELD", GET_FIELD), (94, "KEYS", KEYS),
+ (32, "HAS_FIELDS", HAS_FIELDS), (96, "WITH_FIELDS", WITH_FIELDS), (33, "PLUCK", PLUCK), (34, "WITHOUT", WITHOUT),
+ (35, "MERGE", MERGE), (36, "BETWEEN", BETWEEN), (37, "REDUCE", REDUCE), (38, "MAP", MAP), (39, "FILTER", FILTER),
+ (40, "CONCATMAP", CONCATMAP), (41, "ORDERBY", ORDERBY), (42, "DISTINCT", DISTINCT), (43, "COUNT", COUNT),
+ (86, "IS_EMPTY", IS_EMPTY), (44, "UNION", UNION), (45, "NTH", NTH), (46, "GROUPED_MAP_REDUCE", GROUPED_MAP_REDUCE),
+ (47, "GROUPBY", GROUPBY), (48, "INNER_JOIN", INNER_JOIN), (49, "OUTER_JOIN", OUTER_JOIN), (50, "EQ_JOIN", EQ_JOIN),
+ (72, "ZIP", ZIP), (82, "INSERT_AT", INSERT_AT), (83, "DELETE_AT", DELETE_AT), (84, "CHANGE_AT", CHANGE_AT),
+ (85, "SPLICE_AT", SPLICE_AT), (51, "COERCE_TO", COERCE_TO), (52, "TYPEOF", TYPEOF), (53, "UPDATE", UPDATE),
+ (54, "DELETE", DELETE), (55, "REPLACE", REPLACE), (56, "INSERT", INSERT), (57, "DB_CREATE", DB_CREATE),
+ (58, "DB_DROP", DB_DROP), (59, "DB_LIST", DB_LIST), (60, "TABLE_CREATE", TABLE_CREATE), (61, "TABLE_DROP", TABLE_DROP),
+ (62, "TABLE_LIST", TABLE_LIST), (75, "INDEX_CREATE", INDEX_CREATE), (76, "INDEX_DROP", INDEX_DROP),
+ (77, "INDEX_LIST", INDEX_LIST), (64, "FUNCALL", FUNCALL), (65, "BRANCH", BRANCH), (66, "ANY", ANY), (67, "ALL", ALL),
+ (68, "FOREACH", FOREACH), (69, "FUNC", FUNC), (73, "ASC", ASC), (74, "DESC", DESC), (79, "INFO", INFO), (97, "MATCH", MATCH),
+ (81, "SAMPLE", SAMPLE), (92, "DEFAULT", DEFAULT), (98, "JSON", JSON), (99, "ISO8601", ISO8601),
+ (100, "TO_ISO8601", TO_ISO8601), (101, "EPOCH_TIME", EPOCH_TIME), (102, "TO_EPOCH_TIME", TO_EPOCH_TIME), (103, "NOW", NOW),
+ (104, "IN_TIMEZONE", IN_TIMEZONE), (105, "DURING", DURING), (106, "DATE", DATE), (126, "TIME_OF_DAY", TIME_OF_DAY),
+ (127, "TIMEZONE", TIMEZONE), (128, "YEAR", YEAR), (129, "MONTH", MONTH), (130, "DAY", DAY), (131, "DAY_OF_WEEK", DAY_OF_WEEK),
+ (132, "DAY_OF_YEAR", DAY_OF_YEAR), (133, "HOURS", HOURS), (134, "MINUTES", MINUTES), (135, "SECONDS", SECONDS),
+ (136, "TIME", TIME), (107, "MONDAY", MONDAY), (108, "TUESDAY", TUESDAY), (109, "WEDNESDAY", WEDNESDAY),
+ (110, "THURSDAY", THURSDAY), (111, "FRIDAY", FRIDAY), (112, "SATURDAY", SATURDAY), (113, "SUNDAY", SUNDAY),
+ (114, "JANUARY", JANUARY), (115, "FEBRUARY", FEBRUARY), (116, "MARCH", MARCH), (117, "APRIL", APRIL), (118, "MAY", MAY),
+ (119, "JUNE", JUNE), (120, "JULY", JULY), (121, "AUGUST", AUGUST), (122, "SEPTEMBER", SEPTEMBER), (123, "OCTOBER", OCTOBER),
+ (124, "NOVEMBER", NOVEMBER), (125, "DECEMBER", DECEMBER), (137, "LITERAL", LITERAL)]
+ reflectEnumInfo _
+ = P'.EnumInfo (P'.makePNF (P'.pack ".Ql2.Term.TermType") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "Term"] "TermType")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "Term", "TermType.hs"]
+ [(1, "DATUM"), (2, "MAKE_ARRAY"), (3, "MAKE_OBJ"), (10, "VAR"), (11, "JAVASCRIPT"), (12, "ERROR"), (13, "IMPLICIT_VAR"),
+ (14, "DB"), (15, "TABLE"), (16, "GET"), (78, "GET_ALL"), (17, "EQ"), (18, "NE"), (19, "LT"), (20, "LE"), (21, "GT"),
+ (22, "GE"), (23, "NOT"), (24, "ADD"), (25, "SUB"), (26, "MUL"), (27, "DIV"), (28, "MOD"), (29, "APPEND"), (80, "PREPEND"),
+ (95, "DIFFERENCE"), (88, "SET_INSERT"), (89, "SET_INTERSECTION"), (90, "SET_UNION"), (91, "SET_DIFFERENCE"), (30, "SLICE"),
+ (70, "SKIP"), (71, "LIMIT"), (87, "INDEXES_OF"), (93, "CONTAINS"), (31, "GET_FIELD"), (94, "KEYS"), (32, "HAS_FIELDS"),
+ (96, "WITH_FIELDS"), (33, "PLUCK"), (34, "WITHOUT"), (35, "MERGE"), (36, "BETWEEN"), (37, "REDUCE"), (38, "MAP"),
+ (39, "FILTER"), (40, "CONCATMAP"), (41, "ORDERBY"), (42, "DISTINCT"), (43, "COUNT"), (86, "IS_EMPTY"), (44, "UNION"),
+ (45, "NTH"), (46, "GROUPED_MAP_REDUCE"), (47, "GROUPBY"), (48, "INNER_JOIN"), (49, "OUTER_JOIN"), (50, "EQ_JOIN"),
+ (72, "ZIP"), (82, "INSERT_AT"), (83, "DELETE_AT"), (84, "CHANGE_AT"), (85, "SPLICE_AT"), (51, "COERCE_TO"), (52, "TYPEOF"),
+ (53, "UPDATE"), (54, "DELETE"), (55, "REPLACE"), (56, "INSERT"), (57, "DB_CREATE"), (58, "DB_DROP"), (59, "DB_LIST"),
+ (60, "TABLE_CREATE"), (61, "TABLE_DROP"), (62, "TABLE_LIST"), (75, "INDEX_CREATE"), (76, "INDEX_DROP"), (77, "INDEX_LIST"),
+ (64, "FUNCALL"), (65, "BRANCH"), (66, "ANY"), (67, "ALL"), (68, "FOREACH"), (69, "FUNC"), (73, "ASC"), (74, "DESC"),
+ (79, "INFO"), (97, "MATCH"), (81, "SAMPLE"), (92, "DEFAULT"), (98, "JSON"), (99, "ISO8601"), (100, "TO_ISO8601"),
+ (101, "EPOCH_TIME"), (102, "TO_EPOCH_TIME"), (103, "NOW"), (104, "IN_TIMEZONE"), (105, "DURING"), (106, "DATE"),
+ (126, "TIME_OF_DAY"), (127, "TIMEZONE"), (128, "YEAR"), (129, "MONTH"), (130, "DAY"), (131, "DAY_OF_WEEK"),
+ (132, "DAY_OF_YEAR"), (133, "HOURS"), (134, "MINUTES"), (135, "SECONDS"), (136, "TIME"), (107, "MONDAY"), (108, "TUESDAY"),
+ (109, "WEDNESDAY"), (110, "THURSDAY"), (111, "FRIDAY"), (112, "SATURDAY"), (113, "SUNDAY"), (114, "JANUARY"),
+ (115, "FEBRUARY"), (116, "MARCH"), (117, "APRIL"), (118, "MAY"), (119, "JUNE"), (120, "JULY"), (121, "AUGUST"),
+ (122, "SEPTEMBER"), (123, "OCTOBER"), (124, "NOVEMBER"), (125, "DECEMBER"), (137, "LITERAL")]
diff --git a/Database/RethinkDB/Protobuf/Ql2/VersionDummy.hs b/Database/RethinkDB/Protobuf/Ql2/VersionDummy.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/VersionDummy.hs
@@ -0,0 +1,56 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.VersionDummy (VersionDummy(..)) 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 VersionDummy = VersionDummy{}
+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable VersionDummy where
+ mergeAppend VersionDummy VersionDummy = VersionDummy
+
+instance P'.Default VersionDummy where
+ defaultValue = VersionDummy
+
+instance P'.Wire VersionDummy where
+ wireSize ft' self'@(VersionDummy)
+ = case ft' of
+ 10 -> calc'Size
+ 11 -> P'.prependMessageSize calc'Size
+ _ -> P'.wireSizeErr ft' self'
+ where
+ calc'Size = 0
+ wirePut ft' self'@(VersionDummy)
+ = case ft' of
+ 10 -> put'Fields
+ 11 -> do
+ P'.putSize (P'.wireSize 10 self')
+ put'Fields
+ _ -> P'.wirePutErr ft' self'
+ where
+ put'Fields
+ = do
+ Prelude'.return ()
+ 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
+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self
+
+instance P'.MessageAPI msg' (msg' -> VersionDummy) VersionDummy where
+ getVal m' f' = f' m'
+
+instance P'.GPB VersionDummy
+
+instance P'.ReflectDescriptor VersionDummy where
+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [])
+ reflectDescriptorInfo _
+ = Prelude'.read
+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".Ql2.VersionDummy\", haskellPrefix = [MName \"Database\",MName \"RethinkDB\",MName \"Protobuf\"], parentModule = [MName \"Ql2\"], baseName = MName \"VersionDummy\"}, descFilePath = [\"Database\",\"RethinkDB\",\"Protobuf\",\"Ql2\",\"VersionDummy.hs\"], isGroup = False, fields = fromList [], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = False, lazyFields = False}"
diff --git a/Database/RethinkDB/Protobuf/Ql2/VersionDummy/Version.hs b/Database/RethinkDB/Protobuf/Ql2/VersionDummy/Version.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Protobuf/Ql2/VersionDummy/Version.hs
@@ -0,0 +1,58 @@
+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
+module Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version (Version(..)) 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 Version = V0_1
+ | V0_2
+ deriving (Prelude'.Read, Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable, Prelude'.Data)
+
+instance P'.Mergeable Version
+
+instance Prelude'.Bounded Version where
+ minBound = V0_1
+ maxBound = V0_2
+
+instance P'.Default Version where
+ defaultValue = V0_1
+
+toMaybe'Enum :: Prelude'.Int -> P'.Maybe Version
+toMaybe'Enum 1063369270 = Prelude'.Just V0_1
+toMaybe'Enum 1915781601 = Prelude'.Just V0_2
+toMaybe'Enum _ = Prelude'.Nothing
+
+instance Prelude'.Enum Version where
+ fromEnum V0_1 = 1063369270
+ fromEnum V0_2 = 1915781601
+ toEnum
+ = P'.fromMaybe
+ (Prelude'.error "hprotoc generated code: toEnum failure for type Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version")
+ . toMaybe'Enum
+ succ V0_1 = V0_2
+ succ _ = Prelude'.error "hprotoc generated code: succ failure for type Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version"
+ pred V0_2 = V0_1
+ pred _ = Prelude'.error "hprotoc generated code: pred failure for type Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version"
+
+instance P'.Wire Version 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 Version
+
+instance P'.MessageAPI msg' (msg' -> Version) Version where
+ getVal m' f' = f' m'
+
+instance P'.ReflectEnum Version where
+ reflectEnum = [(1063369270, "V0_1", V0_1), (1915781601, "V0_2", V0_2)]
+ reflectEnumInfo _
+ = P'.EnumInfo
+ (P'.makePNF (P'.pack ".Ql2.VersionDummy.Version") ["Database", "RethinkDB", "Protobuf"] ["Ql2", "VersionDummy"] "Version")
+ ["Database", "RethinkDB", "Protobuf", "Ql2", "VersionDummy", "Version.hs"]
+ [(1063369270, "V0_1"), (1915781601, "V0_2")]
diff --git a/Database/RethinkDB/ReQL.hs b/Database/RethinkDB/ReQL.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/ReQL.hs
@@ -0,0 +1,427 @@
+{-# LANGUAGE ExistentialQuantification, RecordWildCards, ScopedTypeVariables,
+ FlexibleInstances, OverloadedStrings, PatternGuards #-}
+
+-- | Building RQL queries in Haskell
+module Database.RethinkDB.ReQL (
+ ReQL(..),
+ op,
+ BaseReQL(..),
+ BaseAttribute(..),
+ buildQuery,
+ BaseArray,
+ Backtrace, convertBacktrace,
+ Expr(..),
+ QuerySettings(..),
+ newVarId,
+ str,
+ num,
+ Attribute(..),
+ cons,
+ arr,
+ baseArray,
+ withQuerySettings,
+ Object(..),
+ Obj(..),
+ returnVals,
+ canReturnVals,
+ reqlToProtobuf
+ ) where
+
+import qualified Data.Vector as V
+import qualified Data.HashMap.Lazy as M
+import Data.Maybe (fromMaybe, catMaybes)
+import Data.String (IsString(..))
+import Data.List (intersperse)
+import qualified Data.Sequence as S
+import Control.Monad.State (State, get, put, runState)
+import Control.Applicative ((<$>))
+import Data.Default (Default, def)
+import qualified Data.Text as T
+import qualified Data.Aeson as J
+import Data.Foldable (toList)
+import Data.Time
+import Data.Time.Clock.POSIX
+import Control.Monad.Fix
+
+import Text.ProtocolBuffers hiding (Key, cons, Default)
+import Text.ProtocolBuffers.Basic hiding (Default)
+
+import Database.RethinkDB.Protobuf.Ql2.Term
+import qualified Database.RethinkDB.Protobuf.Ql2.Term as Term
+import Database.RethinkDB.Protobuf.Ql2.Term.TermType as TermType
+import Database.RethinkDB.Protobuf.Ql2.Term.AssocPair
+import qualified Database.RethinkDB.Protobuf.Ql2.Query as Query
+import Database.RethinkDB.Protobuf.Ql2.Query.QueryType
+import qualified Database.RethinkDB.Protobuf.Ql2.Datum as Datum
+import qualified Database.RethinkDB.Protobuf.Ql2.Datum.AssocPair as Datum
+import Database.RethinkDB.Protobuf.Ql2.Datum
+import qualified Database.RethinkDB.Protobuf.Ql2.Backtrace as QL
+import qualified Database.RethinkDB.Protobuf.Ql2.Frame as QL
+import Database.RethinkDB.Protobuf.Ql2.Datum.DatumType
+import Database.RethinkDB.Protobuf.Ql2.Frame.FrameType as QL
+
+import Database.RethinkDB.Objects as O
+
+-- | An RQL term
+data ReQL = ReQL { baseReQL :: State QuerySettings BaseReQL }
+
+data BaseReQL = BaseReQL {
+ termType :: TermType,
+ termDatum :: Maybe Datum.Datum,
+ termArgs :: BaseArray,
+ termOptArgs :: [BaseAttribute] }
+
+data QuerySettings = QuerySettings {
+ queryToken :: Int64,
+ queryDefaultDatabase :: Database,
+ queryVarIndex :: Int,
+ queryUseOutdated :: Maybe Bool,
+ queryReturnVals :: Maybe Bool
+ }
+
+instance Default QuerySettings where
+ def = QuerySettings 0 (Database "") 0 Nothing Nothing
+
+withQuerySettings :: (QuerySettings -> ReQL) -> ReQL
+withQuerySettings f = ReQL $ (baseReQL . f) =<< get
+
+-- | Include the value of single write operations in the returned object
+returnVals :: ReQL -> ReQL
+returnVals (ReQL t) = ReQL $ do
+ state <- get
+ put state{ queryReturnVals = Just True }
+ ret <- t
+ state' <- get
+ put state'{ queryReturnVals = queryReturnVals state }
+ return ret
+
+canReturnVals :: ReQL -> ReQL
+canReturnVals (ReQL t) = ReQL $ t >>= \ret -> do
+ qs <- get
+ case queryReturnVals qs of
+ Nothing -> return ret
+ Just rv -> return ret{
+ termOptArgs = BaseAttribute "return_vals" (baseBool rv) : termOptArgs ret }
+
+baseBool :: Bool -> BaseReQL
+baseBool b = BaseReQL DATUM (Just defaultValue{
+ Datum.type' = Just R_BOOL, r_bool = Just b }) [] []
+
+newVarId :: State QuerySettings Int
+newVarId = do
+ QuerySettings {..} <- get
+ let n = queryVarIndex + 1
+ put QuerySettings {queryVarIndex = n, ..}
+ return $ n
+
+instance Show BaseReQL where
+ show (BaseReQL DATUM (Just dat) _ _) = showD dat
+ show (BaseReQL MAKE_ARRAY _ x []) = "[" ++ (concat $ intersperse ", " $ map show x) ++ "]"
+ show (BaseReQL MAKE_OBJ _ [] x) = "{" ++ (concat $ intersperse ", " $ map show x) ++ "}"
+ show (BaseReQL VAR _ [BaseReQL DATUM (Just d) [] []] []) | Just x <- toDouble d =
+ "x" ++ show (round x)
+ show (BaseReQL FUNC _ [BaseReQL DATUM (Just d) [] [], body] []) | Just vars <- toDoubles d =
+ "(\\" ++ (concat $ intersperse " " $ map (("x"++) . show . round) $ vars)
+ ++ " -> " ++ show body ++ ")"
+ show (BaseReQL GET_FIELD _ [o, k] []) = show o ++ "!" ++ show k
+ show (BaseReQL fun _ args optargs) =
+ show fun ++ "(" ++
+ concat (intersperse ", " (map show args ++ map show optargs)) ++ ")"
+
+showD :: Datum.Datum -> String
+showD d = case Datum.type' d of
+ Just R_NUM -> show' $ r_num d
+ Just R_BOOL -> show' $ r_bool d
+ Just R_STR -> show' $ r_str d
+ Just R_ARRAY -> "[" ++ (concat $ intersperse ", " $ map showD $ toList $ r_array d) ++ "]"
+ Just R_OBJECT ->
+ "{" ++ (concat $ intersperse ", " $ map showDatumAttr $ toList $ r_object d) ++ "}"
+ Just R_NULL -> "null"
+ Nothing -> "Nothing"
+ where show' Nothing = "Nothing"
+ show' (Just a) = show a
+
+showDatumAttr:: Datum.AssocPair -> String
+showDatumAttr (Datum.AssocPair (Just k) (Just v)) = uToString k ++ ": " ++ showD v
+showDatumAttr x = show x
+
+-- | Convert other types into ReqL expressions
+class Expr e where
+ expr :: e -> ReQL
+
+instance Expr ReQL where
+ expr t = t
+
+-- | A list of terms
+data Array = Array { baseArray :: State QuerySettings BaseArray }
+
+type BaseArray = [BaseReQL]
+
+-- | Build arrays of exprs
+class Arr a where
+ arr :: a -> Array
+
+cons :: Expr e => e -> Array -> Array
+cons x xs = Array $ do
+ bt <- baseReQL (expr x)
+ xs' <- baseArray xs
+ return $ bt : xs'
+
+instance Arr () where
+ arr () = Array $ return []
+
+instance Expr a => Arr [a] where
+ arr [] = Array $ return []
+ arr (x:xs) = cons x (arr xs)
+
+instance (Expr a, Expr b) => Arr (a, b) where
+ arr (a,b) = cons a $ cons b $ arr ()
+
+instance (Expr a, Expr b, Expr c) => Arr (a, b, c) where
+ arr (a,b,c) = cons a $ cons b $ cons c $ arr ()
+
+instance (Expr a, Expr b, Expr c, Expr d) => Arr (a, b, c, d) where
+ arr (a,b,c,d) = cons a $ cons b $ cons c $ cons d $ arr ()
+
+instance Arr Array where
+ arr = id
+
+-- | A list of key/value pairs
+data Object = Object { baseObject :: State QuerySettings [BaseAttribute] }
+
+-- | A key/value pair used for building objects
+data Attribute = forall e . (Expr e) => T.Text := e
+
+data BaseAttribute = BaseAttribute T.Text BaseReQL
+
+mapBaseAttribute :: (BaseReQL -> BaseReQL) -> BaseAttribute -> BaseAttribute
+mapBaseAttribute f (BaseAttribute k v) = BaseAttribute k (f v)
+
+instance Show BaseAttribute where
+ show (BaseAttribute a b) = T.unpack a ++ ": " ++ show b
+
+-- | Convert into a ReQL object
+class Obj o where
+ obj :: o -> Object
+
+instance Obj [Attribute] where
+ obj = Object . mapM base
+ where base (k := e) = BaseAttribute k <$> baseReQL (expr e)
+
+instance Obj Object where
+ obj = id
+
+instance Obj () where
+ obj _ = Object $ return []
+
+-- | Build a term
+op :: (Arr a, Obj o) => TermType -> a -> o -> ReQL
+op t a b = ReQL $ do
+ a' <- baseArray (arr a)
+ b' <- baseObject (obj b)
+ case (t, a') of
+ (FUNCALL, (BaseReQL FUNC Nothing [argsFunDatum, fun] [] : argsCall)) |
+ BaseReQL DATUM (Just argsFunArray) [] [] <- argsFunDatum,
+ Just varsFun <- toDoubles argsFunArray,
+ length varsFun == length argsCall,
+ Just varsCall <- varsOf argsCall ->
+ return $ alphaRename (zip varsFun varsCall) fun
+ _ -> return $ BaseReQL t Nothing a' b'
+
+toDoubles :: Datum.Datum -> Maybe [Double]
+toDoubles Datum.Datum{
+ Datum.type' = Just R_ARRAY,
+ r_array = seq } =
+ sequence . map toDouble . toList $ seq
+toDoubles _ = Nothing
+
+toDouble :: Datum.Datum -> Maybe Double
+toDouble Datum.Datum{ type' = Just R_NUM, r_num = Just n } = Just n
+toDouble _ = Nothing
+
+varsOf :: [BaseReQL] -> Maybe [Double]
+varsOf = sequence . map varOf
+
+varOf :: BaseReQL -> Maybe Double
+varOf (BaseReQL VAR Nothing [BaseReQL DATUM (Just d) [] []] []) = toDouble d
+varOf _ = Nothing
+
+datumNumberArray :: [Int] -> Datum.Datum
+datumNumberArray a =
+ defaultValue{
+ Datum.type' = Just R_ARRAY,
+ r_array = S.fromList $ map datumInt a }
+
+datumInt :: Int -> Datum.Datum
+datumInt n =
+ defaultValue{
+ Datum.type' = Just R_NUM,
+ r_num = Just $ fromIntegral n }
+
+alphaRename :: [(Double, Double)] -> BaseReQL -> BaseReQL
+alphaRename assoc = fix $ \f x ->
+ case varOf x of
+ Just n
+ | Just n' <- lookup n assoc ->
+ BaseReQL VAR Nothing
+ [BaseReQL DATUM
+ (Just $ defaultValue{ Datum.type' = Just R_NUM, r_num = Just n' }) [] []] []
+ | otherwise -> x
+ _ -> updateChildren x f
+
+updateChildren :: BaseReQL -> (BaseReQL -> BaseReQL) -> BaseReQL
+updateChildren (BaseReQL t d a o) f = BaseReQL t d (map f a) (map (mapBaseAttribute f) o)
+
+datumTerm :: DatumType -> Datum.Datum -> ReQL
+datumTerm t d = ReQL $ return $ BaseReQL DATUM (Just d { Datum.type' = Just t }) [] []
+
+-- | A shortcut for inserting strings into ReQL expressions
+-- Useful when OverloadedStrings makes the type ambiguous
+str :: String -> ReQL
+str s = datumTerm R_STR defaultValue { r_str = Just (uFromString s) }
+
+-- | A shortcut for inserting numbers into ReQL expressions
+num :: Double -> ReQL
+num = expr
+
+instance Expr Int64 where
+ expr i = datumTerm R_NUM defaultValue { r_num = Just (fromIntegral i) }
+
+instance Expr Int where
+ expr i = datumTerm R_NUM defaultValue { r_num = Just (fromIntegral i) }
+
+instance Expr Integer where
+ expr i = datumTerm R_NUM defaultValue { r_num = Just (fromIntegral i) }
+
+instance Num ReQL where
+ fromInteger x = datumTerm R_NUM defaultValue { r_num = Just (fromInteger x) }
+ a + b = op ADD (a, b) ()
+ a * b = op MUL (a, b) ()
+ abs n = op BRANCH (op TermType.LT (n, 0 :: Double) (), negate n, n) ()
+ signum n = op BRANCH (op TermType.LT (n, 0 :: Double) (),
+ -1 :: Double,
+ op BRANCH (op TermType.EQ (n, 0 :: Double) (), 0 :: Double, 1 :: Double) ()) ()
+
+instance Expr T.Text where
+ expr t = datumTerm R_STR defaultValue { r_str = Just (uFromString $ T.unpack t) }
+
+instance Expr Bool where
+ expr b = datumTerm R_BOOL defaultValue { r_bool = Just b }
+
+instance Expr () where
+ expr _ = datumTerm R_NULL defaultValue
+
+instance IsString ReQL where
+ fromString s = datumTerm R_STR defaultValue { r_str = Just (uFromString $ s) }
+
+instance Expr (ReQL -> ReQL) where
+ expr f = ReQL $ do
+ v <- newVarId
+ baseReQL $ op FUNC (datumNumberArray [v], f (op VAR [v] ())) ()
+
+instance Expr (ReQL -> ReQL -> ReQL) where
+ expr f = ReQL $ do
+ a <- newVarId
+ b <- newVarId
+ baseReQL $ op FUNC (datumNumberArray [a, b], f (op VAR [a] ()) (op VAR [b] ())) ()
+
+instance Expr Datum.Datum where
+ expr d = ReQL $ return $ BaseReQL DATUM (Just d) [] []
+
+instance Expr Table where
+ expr (Table mdb name _) = withQuerySettings $ \QuerySettings {..} ->
+ op TABLE (fromMaybe queryDefaultDatabase mdb, name) $ catMaybes [
+ fmap ("use_outdated" :=) queryUseOutdated ]
+
+instance Expr Database where
+ expr (Database name) = op DB [name] ()
+
+instance Expr J.Value where
+ expr J.Null = expr ()
+ expr (J.Bool b) = expr b
+ expr (J.Number n) = expr (fromRational (toRational n) :: Double)
+ expr (J.String t) = expr t
+ expr (J.Array a) = expr a
+ expr (J.Object o) = expr o
+
+instance Expr Double where
+ expr d = datumTerm R_NUM defaultValue { r_num = Just d }
+
+instance Expr Rational where
+ expr x = expr (fromRational x :: Double)
+
+instance Expr x => Expr (V.Vector x) where
+ expr v = expr (V.toList v)
+
+instance Expr a => Expr [a] where
+ expr a = expr $ arr a
+
+instance Expr Array where
+ expr a = op MAKE_ARRAY a ()
+
+instance Expr e => Expr (M.HashMap T.Text e) where
+ expr m = expr $ obj $ map (uncurry (:=)) $ M.toList m
+
+instance Expr Object where
+ expr o = op MAKE_OBJ () o
+
+buildBaseReQL :: BaseReQL -> Term
+buildBaseReQL BaseReQL {..} = defaultValue {
+ Term.type' = Just termType,
+ datum = termDatum,
+ args = buildBaseArray termArgs,
+ optargs = buildTermAssoc termOptArgs }
+
+buildBaseArray :: BaseArray -> Seq Term
+buildBaseArray [] = S.empty
+buildBaseArray (x:xs) = buildBaseReQL x S.<| buildBaseArray xs
+
+buildTermAssoc :: [BaseAttribute] -> Seq AssocPair
+buildTermAssoc = S.fromList . map buildTermAttribute
+
+buildTermAttribute :: BaseAttribute -> AssocPair
+buildTermAttribute (BaseAttribute k v) = AssocPair (Just $ uFromString $ T.unpack k) (Just $ buildBaseReQL v)
+
+buildQuery :: ReQL -> Int64 -> Database -> (Query.Query, BaseReQL)
+buildQuery term token db = (defaultValue {
+ Query.type' = Just START,
+ Query.query = Just pterm },
+ bterm)
+ where bterm =
+ fst $ runState (baseReQL term) (def {queryToken = token,
+ queryDefaultDatabase = db })
+ pterm = buildBaseReQL bterm
+
+instance Show ReQL where
+ show t = show . snd $ buildQuery t 0 (Database "")
+
+reqlToProtobuf :: ReQL -> Query.Query
+reqlToProtobuf t = fst $ buildQuery t 0 (Database "")
+
+type Backtrace = [Frame]
+
+data Frame = FramePos Int64 | FrameOpt T.Text
+
+instance Show Frame where
+ show (FramePos n) = show n
+ show (FrameOpt k) = show k
+
+convertBacktrace :: QL.Backtrace -> Backtrace
+convertBacktrace = concatMap convertFrame . toList . QL.frames
+ where convertFrame QL.Frame { type' = Just QL.POS, pos = Just n } = [FramePos n]
+ convertFrame QL.Frame { type' = Just QL.OPT, opt = Just k } = [FrameOpt (T.pack $ uToString k)]
+ convertFrame _ = []
+
+instance Expr UTCTime where
+ expr t = op EPOCH_TIME [expr . toRational $ utcTimeToPOSIXSeconds t] ()
+
+instance Expr ZonedTime where
+ expr (ZonedTime
+ (LocalTime
+ date
+ (TimeOfDay hour minute seconds))
+ timezone) = let
+ (year, month, day) = toGregorian date
+ in op TIME [
+ expr year, expr month, expr day, expr hour, expr minute, expr (toRational seconds),
+ str $ timeZoneOffsetString timezone] ()
diff --git a/Database/RethinkDB/Time.hs b/Database/RethinkDB/Time.hs
new file mode 100644
--- /dev/null
+++ b/Database/RethinkDB/Time.hs
@@ -0,0 +1,106 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Database.RethinkDB.Time where
+
+import Data.Text (Text)
+import qualified Data.Time as Time
+import qualified Data.Time.Clock.POSIX as Time
+import Data.Aeson as JSON
+import Data.Aeson.Types (Parser)
+import Control.Monad
+import Control.Applicative
+
+import Database.RethinkDB.ReQL
+
+import Database.RethinkDB.Protobuf.Ql2.Term.TermType
+
+-- | The time and date when the query is executed
+now :: ReQL
+now = op NOW () ()
+
+-- | Build a time object from the year, month, day, hour, minute, second and timezone fields
+time :: ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL -> ReQL
+time y m d hh mm ss tz = op TIME [y, m, d, hh, mm, ss, tz] ()
+
+-- | Build a time object given the number of seconds since the unix epoch
+epochTime :: ReQL -> ReQL
+epochTime t = op EPOCH_TIME [t] ()
+
+-- | Build a time object given an iso8601 string
+iso8601 :: ReQL -> ReQL
+iso8601 t = op ISO8601 [t] ()
+
+-- | The same time in a different timezone
+inTimezone :: Expr time => ReQL -> time -> ReQL
+inTimezone tz t = op IN_TIMEZONE (t, tz) ()
+
+data Bound a =
+ Open { boundValue :: a } |
+ Closed { boundValue :: a }
+
+boundString :: Bound a -> Text
+boundString Open{} = "open"
+boundString Closed{} = "closed"
+
+-- | Test if a time is between two other times
+during :: (Expr left, Expr right, Expr time) => Bound left -> Bound right -> time -> ReQL
+during l r t = op DURING (t, boundValue l, boundValue r) [
+ "left_bound" := boundString l, "right_bound" := boundString r]
+
+-- | Extract part of a time value
+timezone, date, timeOfDay, year, month, day, dayOfWeek, dayOfYear, hours, minutes, seconds ::
+ Expr time => time -> ReQL
+timezone t = op TIMEZONE [t] ()
+date t = op DATE [t] ()
+timeOfDay t = op TIME_OF_DAY [t] ()
+year t = op YEAR [t] ()
+month t = op MONTH [t] ()
+day t = op DAY [t] ()
+dayOfWeek t = op DAY_OF_WEEK [t] ()
+dayOfYear t = op DAY_OF_YEAR [t] ()
+hours t = op HOURS [t] ()
+minutes t = op MINUTES [t] ()
+seconds t = op SECONDS [t] ()
+
+-- | Convert a time to another representation
+toIso8601, toEpochTime :: Expr t => t -> ReQL
+toIso8601 t = op TO_ISO8601 [t] ()
+toEpochTime t = op TO_EPOCH_TIME [t] ()
+
+-- | Time with no time zone
+-- The default FromJSON instance for Data.Time.UTCTime is incompatible with ReQL's time type
+newtype UTCTime = UTCTime Time.UTCTime
+
+-- | Time with a time zone
+-- The default FromJSON instance for Data.Time.ZonedTime is incompatible with ReQL's time type
+newtype ZonedTime = ZonedTime Time.ZonedTime
+
+instance FromJSON UTCTime where
+ parseJSON (JSON.Object v) = UTCTime . Time.posixSecondsToUTCTime . fromRational <$> v .: "epoch_time"
+ parseJSON _ = mzero
+
+instance FromJSON ZonedTime where
+ parseJSON (JSON.Object v) = do
+ tz <- v .: "timezone"
+ t <- v.: "epoch_time"
+ tz' <- parseTimeZone tz
+ return . ZonedTime $ Time.utcToZonedTime tz'
+ (Time.posixSecondsToUTCTime (fromRational t))
+ parseJSON _ = mzero
+
+parseTimeZone :: String -> Parser Time.TimeZone
+parseTimeZone "Z" = return Time.utc
+parseTimeZone tz = Time.minutesToTimeZone <$> case tz of
+ ('-':tz') -> negate <$> go tz'
+ _ -> go tz
+ where
+ go tz' = do
+ (h, _:m) <- return $ break (==':') tz'
+ ([(hh, "")], [(mm, "")]) <- return $ (reads h, reads m)
+ return $ hh * 60 + mm
+
+instance Expr UTCTime where
+ expr (UTCTime t) = expr t
+
+instance Expr ZonedTime where
+ expr (ZonedTime t) = expr t
diff --git a/Database/RethinkDB/Types.hs b/Database/RethinkDB/Types.hs
deleted file mode 100644
--- a/Database/RethinkDB/Types.hs
+++ /dev/null
@@ -1,20 +0,0 @@
--- | 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/rethinkdb.cabal b/rethinkdb.cabal
--- a/rethinkdb.cabal
+++ b/rethinkdb.cabal
@@ -1,10 +1,9 @@
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
+version: 1.8.0.0
+description: RethinkDB is a distributed document store with a powerful query language.
+synopsis: RethinkDB driver for Haskell
+homepage: http://github.com/atnnn/haskell-rethinkdb
+license: Apache
license-file: LICENSE
author: Etienne Laurin
maintainer: Etienne Laurin
@@ -12,58 +11,34 @@
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,
+ exposed-modules: Database.RethinkDB
+ Database.RethinkDB.Driver
+ Database.RethinkDB.Functions
+ Database.RethinkDB.Time
+ Database.RethinkDB.Objects
+ Database.RethinkDB.ReQL
+ Database.RethinkDB.Network
+ Database.RethinkDB.MapReduce
+ Database.RethinkDB.Protobuf.Ql2
+ Database.RethinkDB.Protobuf.Ql2.Backtrace
+ Database.RethinkDB.Protobuf.Ql2.Datum
+ Database.RethinkDB.Protobuf.Ql2.Datum.AssocPair
+ Database.RethinkDB.Protobuf.Ql2.Datum.DatumType
+ Database.RethinkDB.Protobuf.Ql2.Frame
+ Database.RethinkDB.Protobuf.Ql2.Frame.FrameType
+ Database.RethinkDB.Protobuf.Ql2.Query
+ Database.RethinkDB.Protobuf.Ql2.Query.AssocPair
+ Database.RethinkDB.Protobuf.Ql2.Query.QueryType
+ Database.RethinkDB.Protobuf.Ql2.Response
+ Database.RethinkDB.Protobuf.Ql2.Response.ResponseType
+ Database.RethinkDB.Protobuf.Ql2.Term
+ Database.RethinkDB.Protobuf.Ql2.Term.AssocPair
+ Database.RethinkDB.Protobuf.Ql2.Term.TermType
+ Database.RethinkDB.Protobuf.Ql2.VersionDummy
+ Database.RethinkDB.Protobuf.Ql2.VersionDummy.Version
+ build-depends: base >= 4 && < 5,
+ protocol-buffers,
unordered-containers,
text,
aeson,
@@ -72,5 +47,9 @@
attoparsec,
data-default,
network,
- ghc-prim >= 0.3,
- mtl
+ ghc-prim,
+ mtl,
+ vector,
+ protocol-buffers-descriptor,
+ time,
+ utf8-string