esqueleto 1.4.1 → 1.4.1.1

raw patch · 5 files changed

+211/−225 lines, 5 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• esqueleto.cabal +16/−17
• src/Database/Esqueleto.hs +1/−3
• src/Database/Esqueleto/Internal/Language.hs +58/−74
• src/Database/Esqueleto/Internal/Sql.hs +88/−88
• test/Test.hs +48/−43

@@ -1,6 +1,6 @@ name:                esqueleto-version:             1.4.1-synopsis:            Bare bones, type-safe EDSL for SQL queries on persistent backends.+version:             1.4.1.1+synopsis:            Type-safe EDSL for SQL queries on persistent backends. homepage:            https://github.com/meteficha/esqueleto license:             BSD3 license-file:        LICENSE@@ -11,27 +11,26 @@ build-type:          Simple cabal-version:       >=1.8 description:-  @persistent@ is a library for type-safe data serialization.  It-  has many kinds of backends, such as SQL backends-  (@persistent-mysql@, @persistent-postgresql@,-  @persistent-sqlite@) and NoSQL backends (@persistent-mongoDB@).-  .-  While @persistent@ is a nice library for storing and retrieving-  records, currently it has a poor interface for SQL backends-  compared to SQL itself.  For example, it's extremely hard to do-  a type-safe @JOIN@ on a many-to-one relation, and simply-  impossible to do any other kinds of @JOIN@s (including for the-  very common many-to-many relations).  Users have the option of-  writing raw SQL, but that's error prone and not type-checked.-  .   @esqueleto@ is a bare bones, type-safe EDSL for SQL queries   that works with unmodified @persistent@ SQL backends.  Its-  language closely resembles SQL, so (a) you don't have to learn-  new concepts, just new syntax, and (b) it's fairly easy to+  language closely resembles SQL, so you don't have to learn+  new concepts, just new syntax, and it's fairly easy to   predict the generated SQL and optimize it for your backend.   Most kinds of errors committed when writing SQL are caught as   compile-time errors---although it is possible to write   type-checked @esqueleto@ queries that fail at runtime.+  .+  @persistent@ is a library for type-safe data serialization.  It+  has many kinds of backends, such as SQL backends+  (@persistent-mysql@, @persistent-postgresql@,+  @persistent-sqlite@) and NoSQL backends (@persistent-mongoDB@).+  While @persistent@ is a nice library for storing and retrieving+  records, including with filters, it does not try to support+  some of the features that are specific to SQL backends.  In+  particular, @esqueleto@ is the recommended library for+  type-safe @JOIN@s on @persistent@ SQL backends.  (The+  alternative is using raw SQL, but that's error prone and does+  not offer any composability.)   .   Currently, @SELECT@s, @UPDATE@s, @INSERT@s and @DELETE@s are supported.   Not all SQL features are available, but most of them can be easily added

@@ -50,8 +50,6 @@              , in_, notIn, exists, notExists              , set, (=.), (+=.), (-=.), (*=.), (/=.) )   , from-  , Value(..)-  , unValue   , ValueList(..)   , OrderBy     -- ** Joins@@ -372,7 +370,7 @@ -- | @valkey i = val (Key (PersistInt64 i))@ -- (<https://github.com/meteficha/esqueleto/issues/9>). valkey :: Esqueleto query expr backend =>-          Int64 -> expr (Value (Key entity))+          Int64 -> expr (Key entity) valkey = val . Key . PersistInt64  

@@ -15,8 +15,6 @@   ( -- * The pretty face     Esqueleto(..)   , from-  , Value(..)-  , unValue   , ValueList(..)   , SomeValue(..)   , ToSomeValues(..)@@ -82,7 +80,7 @@     -> query a    -- | @WHERE@ clause: restrict the query's result.-  where_ :: expr (Value Bool) -> query ()+  where_ :: expr Bool -> query ()    -- | @ON@ clause: restrict the a @JOIN@'s result.  The @ON@   -- clause will be applied to the /last/ @JOIN@ that does not@@ -131,7 +129,7 @@   -- If the order was /not/ reversed, then @test2@ would be   -- broken: @query1@'s 'on' would refer to @query2@'s   -- 'LeftOuterJoin'.-  on :: expr (Value Bool) -> query ()+  on :: expr Bool -> query ()    -- | @GROUP BY@ clause. You can enclose multiple columns   -- in a tuple.@@ -145,7 +143,7 @@   --   -- With groupBy you can sort by aggregate functions, like so (we   -- used @let@ to restrict the more general `countRows` to-  -- @SqlExpr (Value Int)@ to avoid ambiguity):+  -- @SqlExpr Int@ to avoid ambiguity):   --   -- @   -- r \<- select $ from \\(foo ``InnerJoin`` bar) -> do@@ -154,7 +152,7 @@   --   let countRows' = countRows   --   orderBy [asc countRows']   --   return (bar ^. BarName, countRows')-  -- forM_ r $ \\((Value name), (Value count)) -> do+  -- forM_ r $ \\(name, count) -> do   --   print name   --   print (count :: Int)   -- @@@ -164,10 +162,10 @@   orderBy :: [expr OrderBy] -> query ()    -- | Ascending order of this field or expression.-  asc :: PersistField a => expr (Value a) -> expr OrderBy+  asc :: PersistField a => expr a -> expr OrderBy    -- | Descending order of this field or expression.-  desc :: PersistField a => expr (Value a) -> expr OrderBy+  desc :: PersistField a => expr a -> expr OrderBy    -- | @LIMIT@.  Limit the number of returned rows.   limit :: Int64 -> query ()@@ -183,78 +181,78 @@   -- | @HAVING@.   --   -- /Since: 1.2.2/-  having :: expr (Value Bool) -> query ()+  having :: expr Bool -> query ()    -- | Execute a subquery @SELECT@ in an expression.  Returns a   -- simple value so should be used only when the @SELECT@ query   -- is guaranteed to return just one row.-  sub_select :: PersistField a => query (expr (Value a)) -> expr (Value a)+  sub_select :: PersistField a => query (expr a) -> expr a    -- | Same as 'sub_select' but using @SELECT DISTINCT@.-  sub_selectDistinct :: PersistField a => query (expr (Value a)) -> expr (Value a)+  sub_selectDistinct :: PersistField a => query (expr a) -> expr a    -- | Project a field of an entity.   (^.) :: (PersistEntity val, PersistField typ) =>-          expr (Entity val) -> EntityField val typ -> expr (Value typ)+          expr (Entity val) -> EntityField val typ -> expr typ    -- | Project a field of an entity that may be null.   (?.) :: (PersistEntity val, PersistField typ) =>-          expr (Maybe (Entity val)) -> EntityField val typ -> expr (Value (Maybe typ))+          expr (Maybe (Entity val)) -> EntityField val typ -> expr (Maybe typ)    -- | Lift a constant value from Haskell-land to the query.-  val  :: PersistField typ => typ -> expr (Value typ)+  val  :: PersistField typ => typ -> expr typ    -- | @IS NULL@ comparison.-  isNothing :: PersistField typ => expr (Value (Maybe typ)) -> expr (Value Bool)+  isNothing :: PersistField typ => expr (Maybe typ) -> expr Bool    -- | Analogous to 'Just', promotes a value of type @typ@ into   -- one of type @Maybe typ@.  It should hold that @val . Just   -- === just . val@.-  just :: expr (Value typ) -> expr (Value (Maybe typ))+  just :: expr typ -> expr (Maybe typ)    -- | @NULL@ value.-  nothing :: expr (Value (Maybe typ))+  nothing :: expr (Maybe typ)    -- | Join nested 'Maybe's in a 'Value' into one. This is useful when   -- calling aggregate functions on nullable fields.-  joinV :: expr (Value (Maybe (Maybe typ))) -> expr (Value (Maybe typ))+  joinV :: expr (Maybe (Maybe typ)) -> expr (Maybe typ)    -- | @COUNT(*)@ value.-  countRows :: Num a => expr (Value a)+  countRows :: Num a => expr a    -- | @COUNT@.-  count :: (Num a) => expr (Value typ) -> expr (Value a)+  count :: (Num a) => expr typ -> expr a -  not_ :: expr (Value Bool) -> expr (Value Bool)+  not_ :: expr Bool -> expr Bool -  (==.) :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)-  (>=.) :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)-  (>.)  :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)-  (<=.) :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)-  (<.)  :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)-  (!=.) :: PersistField typ => expr (Value typ) -> expr (Value typ) -> expr (Value Bool)+  (==.) :: PersistField typ => expr typ -> expr typ -> expr Bool+  (>=.) :: PersistField typ => expr typ -> expr typ -> expr Bool+  (>.)  :: PersistField typ => expr typ -> expr typ -> expr Bool+  (<=.) :: PersistField typ => expr typ -> expr typ -> expr Bool+  (<.)  :: PersistField typ => expr typ -> expr typ -> expr Bool+  (!=.) :: PersistField typ => expr typ -> expr typ -> expr Bool -  (&&.) :: expr (Value Bool) -> expr (Value Bool) -> expr (Value Bool)-  (||.) :: expr (Value Bool) -> expr (Value Bool) -> expr (Value Bool)+  (&&.) :: expr Bool -> expr Bool -> expr Bool+  (||.) :: expr Bool -> expr Bool -> expr Bool -  (+.)  :: PersistField a => expr (Value a) -> expr (Value a) -> expr (Value a)-  (-.)  :: PersistField a => expr (Value a) -> expr (Value a) -> expr (Value a)-  (/.)  :: PersistField a => expr (Value a) -> expr (Value a) -> expr (Value a)-  (*.)  :: PersistField a => expr (Value a) -> expr (Value a) -> expr (Value a)+  (+.)  :: PersistField a => expr a -> expr a -> expr a+  (-.)  :: PersistField a => expr a -> expr a -> expr a+  (/.)  :: PersistField a => expr a -> expr a -> expr a+  (*.)  :: PersistField a => expr a -> expr a -> expr a  -  random_  :: (PersistField a, Num a) => expr (Value a)-  round_   :: (PersistField a, Num a, PersistField b, Num b) => expr (Value a) -> expr (Value b)-  ceiling_ :: (PersistField a, Num a, PersistField b, Num b) => expr (Value a) -> expr (Value b)-  floor_   :: (PersistField a, Num a, PersistField b, Num b) => expr (Value a) -> expr (Value b)+  random_  :: (PersistField a, Num a) => expr a+  round_   :: (PersistField a, Num a, PersistField b, Num b) => expr a -> expr b+  ceiling_ :: (PersistField a, Num a, PersistField b, Num b) => expr a -> expr b+  floor_   :: (PersistField a, Num a, PersistField b, Num b) => expr a -> expr b -  sum_     :: (PersistField a, PersistField b) => expr (Value a) -> expr (Value (Maybe b))-  min_     :: (PersistField a) => expr (Value a) -> expr (Value (Maybe a))-  max_     :: (PersistField a) => expr (Value a) -> expr (Value (Maybe a))-  avg_     :: (PersistField a, PersistField b) => expr (Value a) -> expr (Value (Maybe b))+  sum_     :: (PersistField a, PersistField b) => expr a -> expr (Maybe b)+  min_     :: (PersistField a) => expr a -> expr (Maybe a)+  max_     :: (PersistField a) => expr a -> expr (Maybe a)+  avg_     :: (PersistField a, PersistField b) => expr a -> expr (Maybe b)    -- | @LIKE@ operator.-  like :: (PersistField s, IsString s) => expr (Value s) -> expr (Value s) -> expr (Value Bool)+  like :: (PersistField s, IsString s) => expr s -> expr s -> expr Bool   -- | The string @'%'@.  May be useful while using 'like' and   -- concatenation ('concat_' or '++.', depending on your   -- database).  Note that you always to type the parenthesis,@@ -263,30 +261,30 @@   -- @   -- name ``'like'`` (%) ++. val "John" ++. (%)   -- @-  (%) :: (PersistField s, IsString s) => expr (Value s)+  (%) :: (PersistField s, IsString s) => expr s   -- | The @CONCAT@ function with a variable number of   -- parameters.  Supported by MySQL and PostgreSQL.-  concat_ :: (PersistField s, IsString s) => [expr (Value s)] -> expr (Value s)+  concat_ :: (PersistField s, IsString s) => [expr s] -> expr s   -- | The @||@ string concatenation operator (named after   -- Haskell's '++' in order to avoid naming clash with '||.').   -- Supported by SQLite and PostgreSQL.-  (++.) :: (PersistField s, IsString s) => expr (Value s) -> expr (Value s) -> expr (Value s)+  (++.) :: (PersistField s, IsString s) => expr s -> expr s -> expr s    -- | Execute a subquery @SELECT@ in an expression.  Returns a   -- list of values.-  subList_select :: PersistField a => query (expr (Value a)) -> expr (ValueList a)+  subList_select :: PersistField a => query (expr a) -> expr (ValueList a)    -- | Same as 'sublist_select' but using @SELECT DISTINCT@.-  subList_selectDistinct :: PersistField a => query (expr (Value a)) -> expr (ValueList a)+  subList_selectDistinct :: PersistField a => query (expr a) -> expr (ValueList a)    -- | Lift a list of constant value from Haskell-land to the query.   valList :: PersistField typ => [typ] -> expr (ValueList typ)    -- | @IN@ operator.-  in_ :: PersistField typ => expr (Value typ) -> expr (ValueList typ) -> expr (Value Bool)+  in_ :: PersistField typ => expr typ -> expr (ValueList typ) -> expr Bool    -- | @NOT IN@ operator.-  notIn :: PersistField typ => expr (Value typ) -> expr (ValueList typ) -> expr (Value Bool)+  notIn :: PersistField typ => expr typ -> expr (ValueList typ) -> expr Bool    -- | @EXISTS@ operator.  For example:   --@@ -298,27 +296,27 @@   --          where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)   -- return person   -- @-  exists :: query () -> expr (Value Bool)+  exists :: query () -> expr Bool    -- | @NOT EXISTS@ operator.-  notExists :: query () -> expr (Value Bool)+  notExists :: query () -> expr Bool    -- | @SET@ clause used on @UPDATE@s.  Note that while it's not   -- a type error to use this function on a @SELECT@, it will   -- most certainly result in a runtime error.   set :: PersistEntity val => expr (Entity val) -> [expr (Update val)] -> query () -  (=.)  :: (PersistEntity val, PersistField typ) => EntityField val typ -> expr (Value typ) -> expr (Update val)-  (+=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr (Value a) -> expr (Update val)-  (-=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr (Value a) -> expr (Update val)-  (*=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr (Value a) -> expr (Update val)-  (/=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr (Value a) -> expr (Update val)+  (=.)  :: (PersistEntity val, PersistField typ) => EntityField val typ -> expr typ -> expr (Update val)+  (+=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr a -> expr (Update val)+  (-=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr a -> expr (Update val)+  (*=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr a -> expr (Update val)+  (/=.) :: (PersistEntity val, PersistField a) => EntityField val a -> expr a -> expr (Update val)    -- | Apply a 'PersistField' constructor to @expr Value@ arguments.-  (<#) :: (a -> b) -> expr (Value a) -> expr (Insertion b)+  (<#) :: (a -> b) -> expr a -> expr (Insertion b)    -- | Apply extra @expr Value@ arguments to a 'PersistField' constructor-  (<&>) :: expr (Insertion (a -> b)) -> expr (Value a) -> expr (Insertion b)+  (<&>) :: expr (Insertion (a -> b)) -> expr a -> expr (Insertion b)   -- Fixity declarations@@ -331,20 +329,6 @@ infixr 2 ||., `InnerJoin`, `CrossJoin`, `LeftOuterJoin`, `RightOuterJoin`, `FullOuterJoin`, `like`  --- | A single value (as opposed to a whole entity).  You may use--- @('^.')@ or @('?.')@ to get a 'Value' from an 'Entity'.-data Value a = Value a deriving (Eq, Ord, Show, Typeable)--- Note: because of GHC bug #6124 we use @data@ instead of @newtype@.--- <https://ghc.haskell.org/trac/ghc/ticket/6124>----- | Unwrap a 'Value'.------ /Since: 1.4.1/-unValue :: Value a -> a-unValue (Value a) = a-- -- | A list of single values.  There's a limited set of functions -- able to work with this data type (such as 'subList_select', -- 'valList', 'in_' and 'exists').@@ -353,9 +337,9 @@ -- <https://ghc.haskell.org/trac/ghc/ticket/6124>  --- | A wrapper type for for any @expr (Value a)@ for all a.+-- | A wrapper type for for any @expr a@ for all a. data SomeValue expr where-  SomeValue :: Esqueleto query expr backend => expr (Value a) -> SomeValue expr+  SomeValue :: Esqueleto query expr backend => expr a -> SomeValue expr  -- | A class of things that can be converted into a list of SomeValue. It has -- instances for tuples and is the reason why groupBy can take tuples, like

@@ -7,6 +7,8 @@            , MultiParamTypeClasses            , OverloadedStrings            , UndecidableInstances+           , OverlappingInstances+           , IncoherentInstances  #-} -- | This is an internal module, anything exported by this module -- may change without a major version bump.  Please use only@@ -112,18 +114,18 @@ -- | A part of a @FROM@ clause. data FromClause =     FromStart Ident (EntityDef SqlType)-  | FromJoin FromClause JoinKind FromClause (Maybe (SqlExpr (Value Bool)))-  | OnClause (SqlExpr (Value Bool))+  | FromJoin FromClause JoinKind FromClause (Maybe (SqlExpr Bool))+  | OnClause (SqlExpr Bool)   -- | A part of a @SET@ clause.-newtype SetClause = SetClause (SqlExpr (Value ()))+newtype SetClause = SetClause (SqlExpr ())   -- | Collect 'OnClause's on 'FromJoin's.  Returns the first -- unmatched 'OnClause's data on error.  Returns a list without -- 'OnClauses' on success.-collectOnClauses :: [FromClause] -> Either (SqlExpr (Value Bool)) [FromClause]+collectOnClauses :: [FromClause] -> Either (SqlExpr Bool) [FromClause] collectOnClauses = go []   where     go []  (f@(FromStart _ _):fs) = fmap (f:) (go [] fs) -- fast path@@ -149,7 +151,7 @@   -- | A complete @WHERE@ clause.-data WhereClause = Where (SqlExpr (Value Bool))+data WhereClause = Where (SqlExpr Bool)                  | NoWhere  instance Monoid WhereClause where@@ -247,18 +249,18 @@   -- connection (mainly for escaping names) and returns both an   -- string ('TLB.Builder') and a list of values to be   -- interpolated by the SQL backend.-  ERaw     :: NeedParens -> (IdentInfo -> (TLB.Builder, [PersistValue])) -> SqlExpr (Value a)+  ERaw     :: NeedParens -> (IdentInfo -> (TLB.Builder, [PersistValue])) -> SqlExpr a    -- 'EList' and 'EEmptyList' are used by list operators.-  EList      :: SqlExpr (Value a) -> SqlExpr (ValueList a)+  EList      :: SqlExpr a -> SqlExpr (ValueList a)   EEmptyList :: SqlExpr (ValueList a)    -- A 'SqlExpr' accepted only by 'orderBy'.-  EOrderBy :: OrderByType -> SqlExpr (Value a) -> SqlExpr OrderBy+  EOrderBy :: OrderByType -> SqlExpr a -> SqlExpr OrderBy   EOrderRandom :: SqlExpr OrderBy    -- A 'SqlExpr' accepted only by 'set'.-  ESet :: (SqlExpr (Entity val) -> SqlExpr (Value ())) -> SqlExpr (Update val)+  ESet :: (SqlExpr (Entity val) -> SqlExpr ()) -> SqlExpr (Update val)    -- An internal 'SqlExpr' used by the 'from' hack.   EPreprocessedFrom :: a -> FromClause -> SqlExpr (PreprocessedFrom a)@@ -335,7 +337,7 @@    EMaybe r ?. field = maybelize (r ^. field)     where-      maybelize :: SqlExpr (Value a) -> SqlExpr (Value (Maybe a))+      maybelize :: SqlExpr a -> SqlExpr (Maybe a)       maybelize (ERaw p f) = ERaw p f    val = ERaw Never . const . (,) "?" . return . toPersistValue@@ -409,7 +411,7 @@     in (fb <> ", " <> gb, fv ++ gv)  -instance ToSomeValues SqlExpr (SqlExpr (Value a)) where+instance ToSomeValues SqlExpr (SqlExpr a) where   toSomeValues a = [SomeValue a]  fieldName :: (PersistEntity val, PersistField typ)@@ -418,24 +420,24 @@  setAux :: (PersistEntity val, PersistField typ)        => EntityField val typ-       -> (SqlExpr (Entity val) -> SqlExpr (Value typ))+       -> (SqlExpr (Entity val) -> SqlExpr typ)        -> SqlExpr (Update val) setAux field mkVal = ESet $ \ent -> unsafeSqlBinOp " = " name (mkVal ent)   where name = ERaw Never $ \info -> (fieldName info field, mempty) -sub :: PersistField a => Mode -> SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)+sub :: PersistField a => Mode -> SqlQuery (SqlExpr a) -> SqlExpr a sub mode query = ERaw Parens $ \info -> toRawSql mode info query  fromDBName :: IdentInfo -> DBName -> TLB.Builder fromDBName (conn, _) = TLB.fromText . connEscapeName conn -existsHelper :: SqlQuery () -> SqlExpr (Value Bool)+existsHelper :: SqlQuery () -> SqlExpr Bool existsHelper = sub SELECT . (>> return true)   where-    true :: SqlExpr (Value Bool)+    true :: SqlExpr Bool     true = val True -ifNotEmptyList :: SqlExpr (ValueList a) -> Bool -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)+ifNotEmptyList :: SqlExpr (ValueList a) -> Bool -> SqlExpr Bool -> SqlExpr Bool ifNotEmptyList EEmptyList b _ = val b ifNotEmptyList (EList _)  _ x = x @@ -449,13 +451,13 @@ -- signature.  For example: -- -- @--- (==.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value Bool)+-- (==.) :: SqlExpr a -> SqlExpr a -> SqlExpr Bool -- (==.) = unsafeSqlBinOp " = " -- @ -- -- In the example above, we constraint the arguments to be of the -- same type and constraint the result to be a boolean value.-unsafeSqlBinOp :: TLB.Builder -> SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)+unsafeSqlBinOp :: TLB.Builder -> SqlExpr a -> SqlExpr b -> SqlExpr c unsafeSqlBinOp op (ERaw p1 f1) (ERaw p2 f2) = ERaw Parens f   where     f info = let (b1, vals1) = f1 info@@ -467,7 +469,7 @@  -- | (Internal) A raw SQL value.  The same warning from -- 'unsafeSqlBinOp' applies to this function as well.-unsafeSqlValue :: TLB.Builder -> SqlExpr (Value a)+unsafeSqlValue :: TLB.Builder -> SqlExpr a unsafeSqlValue v = ERaw Never $ \_ -> (v, mempty) {-# INLINE unsafeSqlValue #-} @@ -475,7 +477,7 @@ -- | (Internal) A raw SQL function.  Once again, the same warning -- from 'unsafeSqlBinOp' applies to this function as well. unsafeSqlFunction :: UnsafeSqlFunctionArgument a =>-                     TLB.Builder -> a -> SqlExpr (Value b)+                     TLB.Builder -> a -> SqlExpr b unsafeSqlFunction name arg =   ERaw Never $ \info ->     let (argsTLB, argsVals) =@@ -487,7 +489,7 @@ -- -- Since: 1.3.6. unsafeSqlExtractSubField :: UnsafeSqlFunctionArgument a =>-                     TLB.Builder -> a -> SqlExpr (Value b)+                     TLB.Builder -> a -> SqlExpr b unsafeSqlExtractSubField subField arg =   ERaw Never $ \info ->     let (argsTLB, argsVals) =@@ -496,8 +498,8 @@   class UnsafeSqlFunctionArgument a where-  toArgList :: a -> [SqlExpr (Value ())]-instance (a ~ Value b) => UnsafeSqlFunctionArgument (SqlExpr a) where+  toArgList :: a -> [SqlExpr ()]+instance (a ~ b) => UnsafeSqlFunctionArgument (SqlExpr a) where   toArgList = (:[]) . veryUnsafeCoerceSqlExprValue instance UnsafeSqlFunctionArgument a =>          UnsafeSqlFunctionArgument [a] where@@ -520,16 +522,16 @@   --- | (Internal) Coerce a value's type from 'SqlExpr (Value a)' to--- 'SqlExpr (Value b)'.  You should /not/ use this function+-- | (Internal) Coerce a value's type from 'SqlExpr a' to+-- 'SqlExpr b'.  You should /not/ use this function -- unless you know what you're doing!-veryUnsafeCoerceSqlExprValue :: SqlExpr (Value a) -> SqlExpr (Value b)+veryUnsafeCoerceSqlExprValue :: SqlExpr a -> SqlExpr b veryUnsafeCoerceSqlExprValue (ERaw p f) = ERaw p f   -- | (Internal) Coerce a value's type from 'SqlExpr (ValueList--- a)' to 'SqlExpr (Value a)'.  Does not work with empty lists.-veryUnsafeCoerceSqlExprValueList :: SqlExpr (ValueList a) -> SqlExpr (Value a)+-- a)' to 'SqlExpr a'.  Does not work with empty lists.+veryUnsafeCoerceSqlExprValueList :: SqlExpr (ValueList a) -> SqlExpr a veryUnsafeCoerceSqlExprValueList (EList v)  = v veryUnsafeCoerceSqlExprValueList EEmptyList =   error "veryUnsafeCoerceSqlExprValueList: empty list."@@ -564,7 +566,7 @@           Just (Left err) -> liftIO $ throwIO $ PersistMarshalError err           Nothing         -> return () -      process = sqlSelectProcessRow+      process = sqlSelectProcessRow query   -- | Execute an @esqueleto@ @SELECT@ query inside @persistent@'s@@ -873,7 +875,7 @@      makeOnClause (ERaw _ f) = first (" ON " <>) (f info) -    mkExc :: SqlExpr (Value Bool) -> OnClauseWithoutMatchingJoinException+    mkExc :: SqlExpr Bool -> OnClauseWithoutMatchingJoinException     mkExc (ERaw _ f) =       OnClauseWithoutMatchingJoinException $       TL.unpack $ TLB.toLazyText $ fst (f info)@@ -933,17 +935,17 @@ -- This looks very similar to @RawSql@, and it is!  However, -- there are some crucial differences and ultimately they're -- different classes.-class SqlSelect a r | a -> r, r -> a where+class SqlSelect a r | a -> r where   -- | Creates the variable part of the @SELECT@ query and   -- returns the list of 'PersistValue's that will be given to   -- 'rawQuery'.   sqlSelectCols :: IdentInfo -> a -> (TLB.Builder, [PersistValue])    -- | Number of columns that will be consumed.-  sqlSelectColCount :: Proxy a -> Int+  sqlSelectColCount :: proxy a -> Int    -- | Transform a row of the result into the data type.-  sqlSelectProcessRow :: [PersistValue] -> Either T.Text r+  sqlSelectProcessRow :: proxy a -> [PersistValue] -> Either T.Text r    -- | Create @INSERT INTO@ clause instead.   sqlInsertInto :: IdentInfo -> a -> (TLB.Builder, [PersistValue])@@ -960,8 +962,8 @@         table  = fromDBName info . entityDB . entityDef $ p     in ("INSERT INTO " <> table <> parens fields <> "\n", [])   sqlSelectCols info (EInsertFinal (EInsert _ f)) = f info-  sqlSelectColCount   = const 0-  sqlSelectProcessRow = const (Right (error msg))+  sqlSelectColCount     = const 0+  sqlSelectProcessRow _ = const (Right (error msg))     where       msg = "sqlSelectProcessRow/SqlSelect/InsertionFinal: never here" @@ -970,7 +972,7 @@ instance SqlSelect () () where   sqlSelectCols _ _ = ("1", [])   sqlSelectColCount _ = 1-  sqlSelectProcessRow _ = Right ()+  sqlSelectProcessRow _ _ = Right ()   -- | You may return an 'Entity' from a 'select' query.@@ -989,15 +991,16 @@         -- name of the table (which doesn't allow self-joins, for         -- example).         name = useIdent info ident <> "."-        ret = let ed = entityDef $ getEntityVal $ return expr+        ret = let ed = entityDef $ getEntityVal $ retProxy expr+                  retProxy = return :: a -> Proxy a               in (process ed, mempty)   sqlSelectColCount = (+1) . length . entityFields . entityDef . getEntityVal-  sqlSelectProcessRow (idCol:ent) =+  sqlSelectProcessRow _ (idCol:ent) =     Entity <$> fromPersistValue idCol            <*> fromPersistValues ent-  sqlSelectProcessRow _ = Left "SqlSelect (Entity a): wrong number of columns."+  sqlSelectProcessRow _ _ = Left "SqlSelect (Entity a): wrong number of columns." -getEntityVal :: Proxy (SqlExpr (Entity a)) -> Proxy a+getEntityVal :: proxy (SqlExpr (Entity a)) -> Proxy a getEntityVal = const Proxy  @@ -1005,22 +1008,22 @@ instance PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a)) where   sqlSelectCols info (EMaybe ent) = sqlSelectCols info ent   sqlSelectColCount = sqlSelectColCount . fromEMaybe-    where-      fromEMaybe :: Proxy (SqlExpr (Maybe e)) -> Proxy (SqlExpr e)-      fromEMaybe = const Proxy-  sqlSelectProcessRow cols+  sqlSelectProcessRow proxy cols     | all (== PersistNull) cols = return Nothing-    | otherwise                 = Just <$> sqlSelectProcessRow cols+    | otherwise                 = Just <$> sqlSelectProcessRow (fromEMaybe proxy) cols +fromEMaybe :: proxy (SqlExpr (Maybe e)) -> Proxy (SqlExpr e)+fromEMaybe = const Proxy + -- | You may return any single value (i.e. a single column) from -- a 'select' query.-instance PersistField a => SqlSelect (SqlExpr (Value a)) (Value a) where+instance PersistField a => SqlSelect (SqlExpr a) a where   sqlSelectCols info (ERaw p f) = let (b, vals) = f info                                   in (parensM p b, vals)   sqlSelectColCount = const 1-  sqlSelectProcessRow [pv] = Value <$> fromPersistValue pv-  sqlSelectProcessRow _    = Left "SqlSelect (Value a): wrong number of columns."+  sqlSelectProcessRow _ [pv] = fromPersistValue pv+  sqlSelectProcessRow _ _    = Left "SqlSelect a: wrong number of columns."   -- | You may return tuples (up to 16-tuples) and tuples of tuples@@ -1034,25 +1037,22 @@       , sqlSelectCols esc b       ]   sqlSelectColCount = uncurry (+) . (sqlSelectColCount *** sqlSelectColCount) . fromTuple-    where-      fromTuple :: Proxy (a,b) -> (Proxy a, Proxy b)-      fromTuple = const (Proxy, Proxy)-  sqlSelectProcessRow =-    let x = getType processRow-        getType :: SqlSelect a r => (z -> Either y (r,x)) -> Proxy a-        getType = const Proxy--        colCountFst = sqlSelectColCount x+  sqlSelectProcessRow proxy =+    let (proxyFst, proxySnd) = fromTuple proxy+        colCountFst = sqlSelectColCount proxyFst          processRow row =             let (rowFst, rowSnd) = splitAt colCountFst row-            in (,) <$> sqlSelectProcessRow rowFst-                   <*> sqlSelectProcessRow rowSnd+            in (,) <$> sqlSelectProcessRow proxyFst rowFst+                   <*> sqlSelectProcessRow proxySnd rowSnd      in colCountFst `seq` processRow        -- Avoids recalculating 'colCountFst'. +fromTuple :: proxy (a,b) -> (Proxy a, Proxy b)+fromTuple = const (Proxy, Proxy) + instance ( SqlSelect a ra          , SqlSelect b rb          , SqlSelect c rc@@ -1063,10 +1063,10 @@       , sqlSelectCols esc b       , sqlSelectCols esc c       ]-  sqlSelectColCount   = sqlSelectColCount . from3P-  sqlSelectProcessRow = fmap to3 . sqlSelectProcessRow+  sqlSelectColCount = sqlSelectColCount . from3P+  sqlSelectProcessRow = (fmap to3 .) . sqlSelectProcessRow . from3P -from3P :: Proxy (a,b,c) -> Proxy ((a,b),c)+from3P :: proxy (a,b,c) -> Proxy ((a,b),c) from3P = const Proxy  from3 :: (a,b,c) -> ((a,b),c)@@ -1089,9 +1089,9 @@       , sqlSelectCols esc d       ]   sqlSelectColCount   = sqlSelectColCount . from4P-  sqlSelectProcessRow = fmap to4 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to4 .) . sqlSelectProcessRow . from4P -from4P :: Proxy (a,b,c,d) -> Proxy ((a,b),(c,d))+from4P :: proxy (a,b,c,d) -> Proxy ((a,b),(c,d)) from4P = const Proxy  from4 :: (a,b,c,d) -> ((a,b),(c,d))@@ -1116,9 +1116,9 @@       , sqlSelectCols esc e       ]   sqlSelectColCount   = sqlSelectColCount . from5P-  sqlSelectProcessRow = fmap to5 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to5 .) . sqlSelectProcessRow . from5P -from5P :: Proxy (a,b,c,d,e) -> Proxy ((a,b),(c,d),e)+from5P :: proxy (a,b,c,d,e) -> Proxy ((a,b),(c,d),e) from5P = const Proxy  to5 :: ((a,b),(c,d),e) -> (a,b,c,d,e)@@ -1142,9 +1142,9 @@       , sqlSelectCols esc f       ]   sqlSelectColCount   = sqlSelectColCount . from6P-  sqlSelectProcessRow = fmap to6 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to6 .) . sqlSelectProcessRow . from6P -from6P :: Proxy (a,b,c,d,e,f) -> Proxy ((a,b),(c,d),(e,f))+from6P :: proxy (a,b,c,d,e,f) -> Proxy ((a,b),(c,d),(e,f)) from6P = const Proxy  to6 :: ((a,b),(c,d),(e,f)) -> (a,b,c,d,e,f)@@ -1170,9 +1170,9 @@       , sqlSelectCols esc g       ]   sqlSelectColCount   = sqlSelectColCount . from7P-  sqlSelectProcessRow = fmap to7 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to7 .) . sqlSelectProcessRow . from7P -from7P :: Proxy (a,b,c,d,e,f,g) -> Proxy ((a,b),(c,d),(e,f),g)+from7P :: proxy (a,b,c,d,e,f,g) -> Proxy ((a,b),(c,d),(e,f),g) from7P = const Proxy  to7 :: ((a,b),(c,d),(e,f),g) -> (a,b,c,d,e,f,g)@@ -1200,9 +1200,9 @@       , sqlSelectCols esc h       ]   sqlSelectColCount   = sqlSelectColCount . from8P-  sqlSelectProcessRow = fmap to8 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to8 .) . sqlSelectProcessRow . from8P -from8P :: Proxy (a,b,c,d,e,f,g,h) -> Proxy ((a,b),(c,d),(e,f),(g,h))+from8P :: proxy (a,b,c,d,e,f,g,h) -> Proxy ((a,b),(c,d),(e,f),(g,h)) from8P = const Proxy  to8 :: ((a,b),(c,d),(e,f),(g,h)) -> (a,b,c,d,e,f,g,h)@@ -1231,9 +1231,9 @@       , sqlSelectCols esc i       ]   sqlSelectColCount   = sqlSelectColCount . from9P-  sqlSelectProcessRow = fmap to9 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to9 .) . sqlSelectProcessRow . from9P -from9P :: Proxy (a,b,c,d,e,f,g,h,i) -> Proxy ((a,b),(c,d),(e,f),(g,h),i)+from9P :: proxy (a,b,c,d,e,f,g,h,i) -> Proxy ((a,b),(c,d),(e,f),(g,h),i) from9P = const Proxy  to9 :: ((a,b),(c,d),(e,f),(g,h),i) -> (a,b,c,d,e,f,g,h,i)@@ -1264,9 +1264,9 @@       , sqlSelectCols esc j       ]   sqlSelectColCount   = sqlSelectColCount . from10P-  sqlSelectProcessRow = fmap to10 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to10 .) . sqlSelectProcessRow . from10P -from10P :: Proxy (a,b,c,d,e,f,g,h,i,j) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j))+from10P :: proxy (a,b,c,d,e,f,g,h,i,j) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j)) from10P = const Proxy  to10 :: ((a,b),(c,d),(e,f),(g,h),(i,j)) -> (a,b,c,d,e,f,g,h,i,j)@@ -1300,9 +1300,9 @@       , sqlSelectCols esc k       ]   sqlSelectColCount   = sqlSelectColCount . from11P-  sqlSelectProcessRow = fmap to11 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to11 .) . sqlSelectProcessRow . from11P -from11P :: Proxy (a,b,c,d,e,f,g,h,i,j,k) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),k)+from11P :: proxy (a,b,c,d,e,f,g,h,i,j,k) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),k) from11P = const Proxy  to11 :: ((a,b),(c,d),(e,f),(g,h),(i,j),k) -> (a,b,c,d,e,f,g,h,i,j,k)@@ -1337,9 +1337,9 @@       , sqlSelectCols esc l       ]   sqlSelectColCount   = sqlSelectColCount . from12P-  sqlSelectProcessRow = fmap to12 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to12 .) . sqlSelectProcessRow . from12P -from12P :: Proxy (a,b,c,d,e,f,g,h,i,j,k,l) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l))+from12P :: proxy (a,b,c,d,e,f,g,h,i,j,k,l) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l)) from12P = const Proxy  to12 :: ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l)) -> (a,b,c,d,e,f,g,h,i,j,k,l)@@ -1376,9 +1376,9 @@       , sqlSelectCols esc m       ]   sqlSelectColCount   = sqlSelectColCount . from13P-  sqlSelectProcessRow = fmap to13 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to13 .) . sqlSelectProcessRow . from13P -from13P :: Proxy (a,b,c,d,e,f,g,h,i,j,k,l,m) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),m)+from13P :: proxy (a,b,c,d,e,f,g,h,i,j,k,l,m) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),m) from13P = const Proxy  to13 :: ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),m) -> (a,b,c,d,e,f,g,h,i,j,k,l,m)@@ -1417,9 +1417,9 @@       , sqlSelectCols esc n       ]   sqlSelectColCount   = sqlSelectColCount . from14P-  sqlSelectProcessRow = fmap to14 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to14 .) . sqlSelectProcessRow . from14P -from14P :: Proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n))+from14P :: proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n)) from14P = const Proxy  to14 :: ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n)) -> (a,b,c,d,e,f,g,h,i,j,k,l,m,n)@@ -1460,9 +1460,9 @@       , sqlSelectCols esc o       ]   sqlSelectColCount   = sqlSelectColCount . from15P-  sqlSelectProcessRow = fmap to15 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to15 .) . sqlSelectProcessRow . from15P -from15P :: Proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n, o) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),o)+from15P :: proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n, o) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),o) from15P = const Proxy  to15 :: ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),o) -> (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)@@ -1505,9 +1505,9 @@       , sqlSelectCols esc p       ]   sqlSelectColCount   = sqlSelectColCount . from16P-  sqlSelectProcessRow = fmap to16 . sqlSelectProcessRow+  sqlSelectProcessRow = (fmap to16 .) . sqlSelectProcessRow . from16P -from16P :: Proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),(o,p))+from16P :: proxy (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) -> Proxy ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),(o,p)) from16P = const Proxy  to16 :: ((a,b),(c,d),(e,f),(g,h),(i,j),(k,l),(m,n),(o,p)) -> (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)

@@ -71,13 +71,13 @@     describe "select" $ do       it "works for a single value" $         run $ do-          ret <- select $ return $ val (3 :: Int)-          liftIO $ ret `shouldBe` [ Value 3 ]+          ret <- select $ return $ (val 3 :: SqlExpr Int)+          liftIO $ ret `shouldBe` [ 3 ]        it "works for a pair of a single value and ()" $         run $ do-          ret <- select $ return (val (3 :: Int), ())-          liftIO $ ret `shouldBe` [ (Value 3, ()) ]+          ret <- select $ return (val 3 :: SqlExpr Int, ())+          liftIO $ ret `shouldBe` [ (3, ()) ]        it "works for a single ()" $         run $ do@@ -86,8 +86,8 @@        it "works for a single NULL value" $         run $ do-          ret <- select $ return $ nothing-          liftIO $ ret `shouldBe` [ Value (Nothing :: Maybe Int) ]+          ret <- select $ return $ (nothing :: SqlExpr (Maybe Int))+          liftIO $ ret `shouldBe` [ Nothing ]      describe "select/from" $ do       it "works for a simple example" $@@ -95,14 +95,15 @@           p1e <- insert' p1           ret <- select $                  from $ \person ->-                 return person+                 return (person :: SqlExpr (Entity Person))           liftIO $ ret `shouldBe` [ p1e ]        it "works for a simple self-join (one entity)" $         run $ do           p1e <- insert' p1           ret <- select $-                 from $ \(person1, person2) ->+                 from $ \(person1, person2) -> do+                 let _ = person1 `asTypeOf` person2 :: SqlExpr (Entity Person)                  return (person1, person2)           liftIO $ ret `shouldBe` [ (p1e, p1e) ] @@ -111,7 +112,8 @@           p1e <- insert' p1           p2e <- insert' p2           ret <- select $-                 from $ \(person1, person2) ->+                 from $ \(person1, person2) -> do+                 let _ = person1 `asTypeOf` person2 :: SqlExpr (Entity Person)                  return (person1, person2)           liftIO $ ret `shouldSatisfy` sameElementsAs [ (p1e, p1e)                                                       , (p1e, p2e)@@ -154,23 +156,24 @@           p1k <- insert p1           p2k <- insert p2           ret <- select $-                 from $ \p ->+                 from $ \(p :: SqlExpr (Entity Person)) ->                  return (p ^. PersonId, p ^. PersonName)-          liftIO $ ret `shouldBe` [ (Value p1k, Value (personName p1))-                                  , (Value p2k, Value (personName p2)) ]+          liftIO $ ret `shouldBe` [ (p1k, personName p1)+                                  , (p2k, personName p2) ]        it "works for a simple projection with a simple implicit self-join" $         run $ do           _ <- insert p1           _ <- insert p2           ret <- select $-                 from $ \(pa, pb) ->+                 from $ \(pa, pb) -> do+                 let _ = pa `asTypeOf` pb :: SqlExpr (Entity Person)                  return (pa ^. PersonName, pb ^. PersonName)           liftIO $ ret `shouldSatisfy` sameElementsAs-                                  [ (Value (personName p1), Value (personName p1))-                                  , (Value (personName p1), Value (personName p2))-                                  , (Value (personName p2), Value (personName p1))-                                  , (Value (personName p2), Value (personName p2)) ]+                                  [ (personName p1, personName p1)+                                  , (personName p1, personName p2)+                                  , (personName p2, personName p1)+                                  , (personName p2, personName p2) ]        it "works with many kinds of LIMITs and OFFSETs" $         run $ do@@ -322,14 +325,14 @@           _ <- insert' p3           _ <- insert' p4           ret <- select $-                 from $ \p->+                 from $ \(p :: SqlExpr (Entity Person)) ->                  return $ joinV $ sum_ (p ^. PersonAge) #if   defined(WITH_POSTGRESQL)-          liftIO $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Rational ) ]+          liftIO $ ret `shouldBe` [ Just (36 + 17 + 17 :: Rational ) ] #elif defined(WITH_MYSQL)-          liftIO $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Double ) ]+          liftIO $ ret `shouldBe` [ Just (36 + 17 + 17 :: Double ) ] #else-          liftIO $ ret `shouldBe` [ Value $ Just (36 + 17 + 17 :: Int) ]+          liftIO $ ret `shouldBe` [ Just (36 + 17 + 17 :: Int) ] #endif        it "works with avg_" $@@ -339,9 +342,9 @@           _ <- insert' p3           _ <- insert' p4           ret <- select $-                 from $ \p->+                 from $ \(p :: SqlExpr (Entity Person)) ->                  return $ joinV $ avg_ (p ^. PersonAge)-          liftIO $ ret `shouldBe` [ Value $ Just ((36 + 17 + 17) / 3 :: Double) ]+          liftIO $ ret `shouldBe` [ Just ((36 + 17 + 17) / 3 :: Double) ]        it "works with min_" $         run $ do@@ -350,9 +353,9 @@           _ <- insert' p3           _ <- insert' p4           ret <- select $-                 from $ \p->+                 from $ \(p :: SqlExpr (Entity Person)) ->                  return $ joinV $ min_ (p ^. PersonAge)-          liftIO $ ret `shouldBe` [ Value $ Just (17 :: Int) ]+          liftIO $ ret `shouldBe` [ Just (17 :: Int) ]        it "works with max_" $         run $ do@@ -361,23 +364,23 @@           _ <- insert' p3           _ <- insert' p4           ret <- select $-                 from $ \p->+                 from $ \(p :: SqlExpr (Entity Person)) ->                  return $ joinV $ max_ (p ^. PersonAge)-          liftIO $ ret `shouldBe` [ Value $ Just (36 :: Int) ]+          liftIO $ ret `shouldBe` [ Just (36 :: Int) ]        it "works with random_" $         run $ do #if defined(WITH_POSTGRESQL) || defined(WITH_MYSQL)           _ <- select $ return (random_ :: SqlExpr (Value Double)) #else-          _ <- select $ return (random_ :: SqlExpr (Value Int))+          _ <- select $ return (random_ :: SqlExpr Int) #endif           return ()        it "works with round_" $         run $ do-          ret <- select $ return $ round_ (val (16.2 :: Double))-          liftIO $ ret `shouldBe` [ Value (16 :: Double) ]+          ret <- select $ return (round_ $ val (16.2 :: Double) :: SqlExpr Double)+          liftIO $ ret `shouldBe` [ 16 ]        it "works with isNothing" $         run $ do@@ -526,7 +529,7 @@                                  return (p ^. PersonName)                          ]                  return (b ^. BlogPostId)-          liftIO $ ret `shouldBe` (Value <$> [b2k, b3k, b4k, b1k])+          liftIO $ ret `shouldBe` [b2k, b3k, b4k, b1k]        it "works with asc random_" $         run $ do@@ -539,8 +542,8 @@             replicateM 11 $             select $             from $ \p -> do-            orderBy [asc (random_ :: SqlExpr (Value Double))]-            return (p ^. PersonId :: SqlExpr (Value PersonId))+            orderBy [asc (random_ :: SqlExpr Double)]+            return (p ^. PersonId :: SqlExpr PersonId)           -- There are 2^4 = 16 possible orderings.  The chance           -- of 11 random samplings returning the same ordering           -- is 1/2^40, so this test should pass almost everytime.@@ -558,7 +561,7 @@                  let title = b ^. BlogPostTitle                  orderBy [asc title]                  return title-          liftIO $ ret `shouldBe` [ Value t1, Value t2, Value t3 ]+          liftIO $ ret `shouldBe` [ t1, t2, t3 ]      describe "text functions" $       it "like, (%) and (++.) work on a simple example" $@@ -673,9 +676,9 @@                  let cnt = count (b ^. BlogPostId)                  orderBy [ asc cnt ]                  return (p, cnt)-          liftIO $ ret `shouldBe` [ (Entity p2k p2, Value (0 :: Int))-                                  , (Entity p1k p1, Value 3)-                                  , (Entity p3k p3, Value 7) ]+          liftIO $ ret `shouldBe` [ (Entity p2k p2, 0 :: Int)+                                  , (Entity p1k p1, 3)+                                  , (Entity p3k p3, 7) ]        it "GROUP BY works with HAVING" $         run $ do@@ -692,8 +695,8 @@                  having (cnt >. (val 0))                  orderBy [ asc cnt ]                  return (p, cnt)-          liftIO $ ret `shouldBe` [ (Entity p1k p1, Value (3 :: Int))-                                  , (Entity p3k p3, Value 7) ]+          liftIO $ ret `shouldBe` [ (Entity p1k p1, 3 :: Int)+                                  , (Entity p3k p3, 7) ]      describe "lists of values" $ do       it "IN works for valList" $@@ -792,8 +795,10 @@           _ <- insert p3           insertSelect $ from $ \p -> do             return $ BlogPost <# val "FakePost" <&> (p ^. PersonId)-          ret <- select $ from (\(_::(SqlExpr (Entity BlogPost))) -> return countRows)-          liftIO $ ret `shouldBe` [Value (3::Int)]+          ret <- select $+                 from $ \(_::(SqlExpr (Entity BlogPost))) ->+                 return (countRows :: SqlExpr Int)+          liftIO $ ret `shouldBe` [3]      describe "rand works" $ do       it "returns result in random order" $@@ -807,10 +812,10 @@             _ <- insert $ Person "Mark"  Nothing             _ <- insert $ Person "Sarah" Nothing             insert $ Person "Paul"  Nothing-          ret1 <- fmap (map unValue) $ select $ from $ \p -> do+          ret1 <- select $ from $ \(p :: SqlExpr (Entity Person)) -> do                     orderBy [rand]                     return (p ^. PersonId)-          ret2 <- fmap (map unValue) $ select $ from $ \p -> do+          ret2 <- select $ from $ \(p :: SqlExpr (Entity Person)) -> do                     orderBy [rand]                     return (p ^. PersonId)