rethinkdb 0.1.0.0 → 1.8.0.0

raw patch · 74 files changed

+3400/−5025 lines, 74 filesdep +protocol-buffers-descriptordep +timedep +utf8-stringdep ~aesondep ~attoparsecdep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: protocol-buffers-descriptor, time, utf8-string, vector

Dependency ranges changed: aeson, attoparsec, base, bytestring, containers, data-default, ghc-prim, mtl, network, protocol-buffers, text, unordered-containers

API changes (from Hackage documentation)

Files

• Database/RethinkDB.hs +82/−69
• Database/RethinkDB/Driver.hs +89/−1224
• Database/RethinkDB/Driver.hs-boot +0/−13
• Database/RethinkDB/Functions.hs +323/−361
• Database/RethinkDB/Functions.hs-boot +0/−9
• Database/RethinkDB/Internal/Query_Language/Builtin.hs +0/−123
• Database/RethinkDB/Internal/Query_Language/Builtin/BuiltinType.hs +0/−231
• Database/RethinkDB/Internal/Query_Language/Builtin/Comparison.hs +0/−82
• Database/RethinkDB/Internal/Query_Language/Builtin/ConcatMap.hs +0/−58
• Database/RethinkDB/Internal/Query_Language/Builtin/Filter.hs +0/−59
• Database/RethinkDB/Internal/Query_Language/Builtin/GroupedMapReduce.hs +0/−68
• Database/RethinkDB/Internal/Query_Language/Builtin/Map.hs +0/−58
• Database/RethinkDB/Internal/Query_Language/Builtin/OrderBy.hs +0/−59
• Database/RethinkDB/Internal/Query_Language/Builtin/Range.hs +0/−68
• Database/RethinkDB/Internal/Query_Language/Mapping.hs +0/−69
• Database/RethinkDB/Internal/Query_Language/MetaQuery.hs +0/−73
• Database/RethinkDB/Internal/Query_Language/MetaQuery/CreateTable.hs +0/−67
• Database/RethinkDB/Internal/Query_Language/MetaQuery/MetaQueryType.hs +0/−87
• Database/RethinkDB/Internal/Query_Language/Predicate.hs +0/−60
• Database/RethinkDB/Internal/Query_Language/Query.hs +0/−80
• Database/RethinkDB/Internal/Query_Language/Query/QueryType.hs +0/−74
• Database/RethinkDB/Internal/Query_Language/ReadQuery.hs +0/−72
• Database/RethinkDB/Internal/Query_Language/Reduction.hs +0/−65
• Database/RethinkDB/Internal/Query_Language/Response.hs +0/−74
• Database/RethinkDB/Internal/Query_Language/Response/Backtrace.hs +0/−57
• Database/RethinkDB/Internal/Query_Language/Response/StatusCode.hs +0/−92
• Database/RethinkDB/Internal/Query_Language/TableRef.hs +0/−62
• Database/RethinkDB/Internal/Query_Language/Term.hs +0/−150
• Database/RethinkDB/Internal/Query_Language/Term.hs-boot +0/−32
• Database/RethinkDB/Internal/Query_Language/Term/Call.hs +0/−61
• Database/RethinkDB/Internal/Query_Language/Term/GetByKey.hs +0/−65
• Database/RethinkDB/Internal/Query_Language/Term/If.hs +0/−64
• Database/RethinkDB/Internal/Query_Language/Term/Let.hs +0/−61
• Database/RethinkDB/Internal/Query_Language/Term/Table.hs +0/−59
• Database/RethinkDB/Internal/Query_Language/Term/TermType.hs +0/−134
• Database/RethinkDB/Internal/Query_Language/VarTermTuple.hs +0/−60
• Database/RethinkDB/Internal/Query_Language/WriteQuery.hs +0/−122
• Database/RethinkDB/Internal/Query_Language/WriteQuery/Delete.hs +0/−58
• Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs +0/−64
• Database/RethinkDB/Internal/Query_Language/WriteQuery/ForEach.hs-boot +0/−30
• Database/RethinkDB/Internal/Query_Language/WriteQuery/Insert.hs +0/−66
• Database/RethinkDB/Internal/Query_Language/WriteQuery/Mutate.hs +0/−61
• Database/RethinkDB/Internal/Query_Language/WriteQuery/PointDelete.hs +0/−65
• Database/RethinkDB/Internal/Query_Language/WriteQuery/PointMutate.hs +0/−69
• Database/RethinkDB/Internal/Query_Language/WriteQuery/PointUpdate.hs +0/−69
• Database/RethinkDB/Internal/Query_Language/WriteQuery/Update.hs +0/−61
• Database/RethinkDB/Internal/Query_Language/WriteQuery/WriteQueryType.hs +0/−98
• Database/RethinkDB/Internal/Types.hs +0/−83
• Database/RethinkDB/MapReduce.hs +114/−0
• Database/RethinkDB/Network.hs +344/−0
• Database/RethinkDB/Objects.hs +45/−0
• Database/RethinkDB/Protobuf/Ql2.hs +21/−0
• Database/RethinkDB/Protobuf/Ql2/Backtrace.hs +58/−0
• Database/RethinkDB/Protobuf/Ql2/Datum.hs +88/−0
• Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs +61/−0
• Database/RethinkDB/Protobuf/Ql2/Datum/AssocPair.hs-boot +30/−0
• Database/RethinkDB/Protobuf/Ql2/Datum/DatumType.hs +78/−0
• Database/RethinkDB/Protobuf/Ql2/Frame.hs +63/−0
• Database/RethinkDB/Protobuf/Ql2/Frame/FrameType.hs +56/−0
• Database/RethinkDB/Protobuf/Ql2/Query.hs +75/−0
• Database/RethinkDB/Protobuf/Ql2/Query/AssocPair.hs +61/−0
• Database/RethinkDB/Protobuf/Ql2/Query/QueryType.hs +61/−0
• Database/RethinkDB/Protobuf/Ql2/Response.hs +70/−0
• Database/RethinkDB/Protobuf/Ql2/Response/ResponseType.hs +81/−0
• Database/RethinkDB/Protobuf/Ql2/Term.hs +80/−0
• Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs +61/−0
• Database/RethinkDB/Protobuf/Ql2/Term/AssocPair.hs-boot +30/−0
• Database/RethinkDB/Protobuf/Ql2/Term/TermType.hs +744/−0
• Database/RethinkDB/Protobuf/Ql2/VersionDummy.hs +56/−0
• Database/RethinkDB/Protobuf/Ql2/VersionDummy/Version.hs +58/−0
• Database/RethinkDB/ReQL.hs +427/−0
• Database/RethinkDB/Time.hs +106/−0
• Database/RethinkDB/Types.hs +0/−20
• rethinkdb.cabal +38/−59

@@ -1,100 +1,113 @@---- | RethinkDB client library for Haskell--- --- Modelled upon the official Javascript and Python API: <http://www.rethinkdb.com/api/>--- +-- | Haskell client driver for RethinkDB +--+-- Based upon the official Javascript, Python and Ruby API: <http://www.rethinkdb.com/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

@@ -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

@@ -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)

@@ -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))))

@@ -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

@@ -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}"

@@ -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")]

@@ -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")]

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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")]

@@ -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}"

@@ -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}"

@@ -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")]

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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")]

@@ -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}"

@@ -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}"

@@ -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

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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")]

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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}"

@@ -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")]

@@ -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)

@@ -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) ()

@@ -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

@@ -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

@@ -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")

@@ -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}"