esqueleto 2.2.8 → 2.2.9

raw patch · 5 files changed

+48/−7 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• esqueleto.cabal +1/−1
• src/Database/Esqueleto.hs +2/−2
• src/Database/Esqueleto/Internal/Language.hs +25/−1
• src/Database/Esqueleto/Internal/Sql.hs +4/−1
• test/Test.hs +16/−2

@@ -1,5 +1,5 @@ name:                esqueleto-version:             2.2.8+version:             2.2.9 synopsis:            Type-safe EDSL for SQL queries on persistent backends. homepage:            https://github.com/prowdsponsor/esqueleto license:             BSD3

@@ -45,9 +45,9 @@              , (==.), (>=.), (>.), (<=.), (<.), (!=.), (&&.), (||.)              , (+.), (-.), (/.), (*.)              , random_, round_, ceiling_, floor_-             , min_, max_, sum_, avg_, lower_+             , min_, max_, sum_, avg_, castNum, castNumM              , coalesce, coalesceDefault-             , like, ilike, (%), concat_, (++.)+             , lower_, like, ilike, (%), concat_, (++.)              , subList_select, subList_selectDistinct, valList              , in_, notIn, exists, notExists              , set, (=.), (+=.), (-=.), (*=.), (/=.)

@@ -350,8 +350,30 @@   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))-  lower_   :: (PersistField a, IsString a) => expr (Value a) -> expr (Value a) +  -- | Allow a number of one type to be used as one of another+  -- type via an implicit cast.  An explicit cast is not made,+  -- this function changes only the types on the Haskell side.+  --+  -- /Caveat/: Trying to use @castNum@ from @Double@ to @Int@+  -- will not result in an integer, the original fractional+  -- number will still be used!  Use 'round_', 'ceiling_' or+  -- 'floor_' instead.+  --+  -- /Safety/: This operation is mostly safe due to the 'Num'+  -- constraint between the types and the fact that RDBMSs+  -- usually allow numbers of different types to be used+  -- interchangeably.  However, there may still be issues with+  -- the query not being accepted by the RDBMS or @persistent@+  -- not being able to parse it.+  --+  -- /Since: 2.2.9/+  castNum :: (Num a, Num b) => expr (Value a) -> expr (Value b)+  -- | Same as 'castNum', but for nullable values.+  --+  -- /Since: 2.2.9/+  castNumM :: (Num a, Num b) => expr (Value (Maybe a)) -> expr (Value (Maybe b))+   -- | @COALESCE@ function. Evaluates the arguments in order and   -- returns the value of the first non-NULL expression, or NULL   -- (Nothing) otherwise. Some RDBMSs (such as SQLite) require@@ -368,6 +390,8 @@   -- /Since: 1.4.3/   coalesceDefault :: PersistField a => [expr (Value (Maybe a))] -> expr (Value a) -> expr (Value a) +  -- | @LOWER@ function.+  lower_ :: (PersistField a, IsString a) => expr (Value a) -> expr (Value a)   -- | @LIKE@ operator.   like :: (PersistField s, IsString s) => expr (Value s) -> expr (Value s) -> expr (Value Bool)   -- | @ILIKE@ operator (case-insensitive @LIKE@).

@@ -475,11 +475,14 @@   min_     = unsafeSqlFunction "MIN"   max_     = unsafeSqlFunction "MAX"   avg_     = unsafeSqlFunction "AVG"-  lower_   = unsafeSqlFunction "LOWER" +  castNum  = veryUnsafeCoerceSqlExprValue+  castNumM = veryUnsafeCoerceSqlExprValue+   coalesce              = unsafeSqlFunctionParens "COALESCE"   coalesceDefault exprs = unsafeSqlFunctionParens "COALESCE" . (exprs ++) . return . just +  lower_  = unsafeSqlFunction "LOWER"   like    = unsafeSqlBinOp    " LIKE "   ilike   = unsafeSqlBinOp    " ILIKE "   (%)     = unsafeSqlValue    "'%'"

@@ -118,6 +118,9 @@     name String     Foreign Point fkpoint centerX centerY     deriving Eq Show+  Numbers+    int    Int+    double Double |]  -- | this could be achieved with S.fromList, but not all lists@@ -1205,8 +1208,8 @@           ret <- select $ from (\(_::(SqlExpr (Entity BlogPost))) -> return countRows)           liftIO $ ret `shouldBe` [Value (3::Int)] -    describe "rand works" $ do-      it "returns result in random order" $+    describe "Math-related functions" $ do+      it "rand returns result in random order" $         run $ do           replicateM_ 20 $ do             _ <- insert p1@@ -1225,6 +1228,17 @@                     return (p ^. PersonId)            liftIO $ (ret1 == ret2) `shouldBe` False++      it "castNum works for multiplying Int and Double" $+        run $ do+          mapM_ insert [Numbers 2 3.4, Numbers 7 1.1]+          ret <-+            select $+            from $ \n -> do+            let r = castNum (n ^. NumbersInt) *. n ^. NumbersDouble+            orderBy [asc r]+            return r+          liftIO $ ret `shouldBe` [Value 6.8, Value 7.7]      describe "case" $ do       it "Works for a simple value based when - False" $