opaleye 0.7.5.0 → 0.7.6.0

raw patch · 13 files changed

+88/−34 lines, 13 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• opaleye.cabal +1/−1
• src/Opaleye/Internal/Constant.hs +9/−0
• src/Opaleye/Internal/Inferrable.hs +3/−0
• src/Opaleye/Internal/Join.hs +8/−19
• src/Opaleye/Internal/MaybeFields.hs +17/−12
• src/Opaleye/Internal/PGTypesExternal.hs +17/−0
• src/Opaleye/Internal/QueryArr.hs +6/−0
• src/Opaleye/Internal/Rebind.hs +5/−2
• src/Opaleye/Internal/RunQuery.hs +9/−0
• src/Opaleye/MaybeFields.hs +1/−0
• src/Opaleye/Order.hs +1/−0
• src/Opaleye/SqlTypes.hs +5/−0

@@ -1,3 +1,9 @@+## 0.7.6.0++* Added `matchMaybe`++* Added `SqlVarcharN` and supporting functions+ ## 0.7.5.0  * Added `enumMapperWithSchema`.  Thanks to Steve Mao.

@@ -1,6 +1,6 @@ name:            opaleye copyright:       Copyright (c) 2014-2018 Purely Agile Limited; 2019-2021 Tom Ellis-version:         0.7.5.0+version:         0.7.6.0 synopsis:        An SQL-generating DSL targeting PostgreSQL description:     An SQL-generating DSL targeting PostgreSQL.  Allows                  Postgres queries to be written within Haskell in a

@@ -68,6 +68,15 @@ instance D.Default ToFields LT.Text (Column T.SqlText) where   def = toToFields T.sqlLazyText +instance D.Default ToFields String (Column T.SqlVarcharN) where+  def = toToFields T.sqlStringVarcharN++instance D.Default ToFields ST.Text (Column T.SqlVarcharN) where+  def = toToFields T.sqlStrictTextVarcharN++instance D.Default ToFields LT.Text (Column T.SqlVarcharN) where+  def = toToFields T.sqlLazyTextVarcharN+ instance D.Default ToFields Sci.Scientific (Column T.SqlNumeric) where   def = toToFields T.sqlNumeric 

@@ -56,6 +56,9 @@ instance text ~ ST.Text => D.Default (Inferrable FromField) T.SqlText text where   def = Inferrable D.def +instance varchar ~ ST.Text => D.Default (Inferrable FromField) T.SqlVarcharN varchar where+  def = Inferrable D.def+ instance (Typeable h, D.Default (Inferrable FromField) f h, hs ~ [h])   => D.Default (Inferrable FromField) (T.SqlArray f) hs where   def = Inferrable (RQ.fromFieldArray (runInferrable D.def))

@@ -13,6 +13,7 @@ import qualified Opaleye.Internal.Operators as Op import qualified Opaleye.Internal.PrimQuery as PQ import qualified Opaleye.Internal.PGTypesExternal as T+import qualified Opaleye.Internal.Rebind as Rebind import qualified Opaleye.SqlTypes as T import qualified Opaleye.Column as C import           Opaleye.Field   (Field)@@ -72,28 +73,16 @@                   -> Q.Query a                   -> Q.QueryArr (a -> Column T.PGBool) nullableA leftJoinAExplicit uA nullmaker rq =-  Q.QueryArr $ \(p, t1) ->-    let (columnsR, primQueryR, t2) = Q.runSimpleQueryArr rq ((), t1)-        (newColumnsR, ljPEsR) = PM.run $ U.runUnpackspec uA (extractLeftJoinFields 2 t2) columnsR+  Q.leftJoinQueryArr $ \(p, t1) ->+    let (newColumnsR, right, tag') = flip Q.runSimpleQueryArr ((), t1) $ proc () -> do+          a <- rq -< ()+          Rebind.rebindExplicit uA -< a         renamedNullable = toNullable nullmaker newColumnsR         Column cond = p newColumnsR     in ( renamedNullable-       , \lat primQueryL -> PQ.Join-           PQ.LeftJoin-           cond-           (PQ.NonLateral, primQueryL)-           --- ^ I am reasonably confident that we don't need to rebind any-           --- column names here.  Columns that can become NULL need-           --- to be written here so that we can wrap them.  If we-           --- don't constant columns can avoid becoming NULL.-           --- However, these are the left columns and cannot become-           --- NULL in a left join, so we are fine.-           ----           --- Report about the "avoiding NULL" bug:-           ----           ---     https://github.com/tomjaguarpaw/haskell-opaleye/issues/223-           (lat, (PQ.Rebind True ljPEsR primQueryR))-       , T.next t2)+       , cond+       , right+       , tag')  optionalRestrict :: D.Default U.Unpackspec a a                  => S.Select a

@@ -16,15 +16,12 @@ import qualified Opaleye.Internal.Binary as B import qualified Opaleye.Internal.Column as IC import qualified Opaleye.ToFields as Constant-import qualified Opaleye.Internal.PackMap as PM import qualified Opaleye.Internal.HaskellDB.PrimQuery as HPQ import           Opaleye.Internal.Inferrable (Inferrable(Inferrable),                                               runInferrable)-import qualified Opaleye.Internal.PrimQuery as PQ import qualified Opaleye.Internal.QueryArr as IQ import qualified Opaleye.Internal.Rebind as Rebind import qualified Opaleye.Internal.RunQuery as RQ-import qualified Opaleye.Internal.Tag as Tag import qualified Opaleye.Internal.Unpackspec as U import qualified Opaleye.Internal.Values as V import           Opaleye.Select (Select, SelectArr)@@ -35,7 +32,7 @@                                              ifExplict, IfPP, EqPP(EqPP)) import qualified Opaleye.Internal.Lateral import qualified Opaleye.SqlTypes-import           Opaleye.SqlTypes (SqlBool, IsSqlType)+import           Opaleye.SqlTypes (SqlBool, IsSqlType, SqlInt4)  import           Control.Monad (replicateM_) @@ -92,6 +89,18 @@ maybeFields :: PP.Default IfPP b b => b -> (a -> b) -> MaybeFields a -> b maybeFields = maybeFieldsExplicit PP.def +-- | Use a Haskell @\\case@ expression to pattern match on a+-- 'MaybeFields'.+--+-- @+-- example :: MaybeFields (Field SqlInt4) -> Field SqlInt4+-- example mf = matchMaybe mf $ \\case+--   Nothing -> 0+--   Just x  -> x * 100+-- @+matchMaybe :: PP.Default IfPP b b => MaybeFields a -> (Maybe a -> b) -> b+matchMaybe mf f = maybeFields (f Nothing) (f . Just) mf+ -- | The Opaleye analogue of 'Data.Maybe.fromMaybe' fromMaybeFields :: PP.Default IfPP b b => b -> MaybeFields b -> b fromMaybeFields = fromMaybeFieldsExplicit PP.def@@ -129,19 +138,15 @@   where isNotNull = Opaleye.Internal.Operators.not . Opaleye.Field.isNull  optionalInternal :: (Field (Opaleye.Column.Nullable SqlBool) -> a -> r) -> Select a -> Select r-optionalInternal f = IQ.QueryArr . go-  where+optionalInternal f query = IQ.leftJoinQueryArr $ \arg ->     -- This is basically a left join on TRUE, but Shane (@duairc)     -- wrote it to ensure that we don't need an Unpackspec a a.-    go query arg = (r, join, Tag.next tag')-      where-        (r, right, tag') = flip IQ.runSimpleQueryArr arg $ proc () -> do+    let (r, right, tag') = flip IQ.runSimpleQueryArr arg $ proc () -> do           a <- query -< ()           true_ <- Rebind.rebind -< Opaleye.Column.toNullable (IC.Column true)           returnA -< f true_ a--        join lat left = PQ.Join PQ.LeftJoin true (PQ.NonLateral, left) (lat, right)-    true = HPQ.ConstExpr (HPQ.BoolLit True)+        true = HPQ.ConstExpr (HPQ.BoolLit True)+    in (r, true, right, tag')   -- | An example to demonstrate how the functionality of (lateral)

@@ -51,6 +51,9 @@ instance C.SqlString SqlText where   sqlFromString = pgString +instance C.SqlString SqlVarcharN where+  sqlFromString = sqlStringVarcharN+ instance C.SqlString SqlCitext where   sqlFromString = pgCiLazyText . CI.mk . LText.pack @@ -71,6 +74,15 @@ pgLazyText :: LText.Text -> Column PGText pgLazyText = IPT.literalColumn . HPQ.StringLit . LText.unpack +sqlStringVarcharN :: String -> Column SqlVarcharN+sqlStringVarcharN = IPT.literalColumn . HPQ.StringLit++sqlStrictTextVarcharN :: SText.Text -> Column SqlVarcharN+sqlStrictTextVarcharN = IPT.literalColumn . HPQ.StringLit . SText.unpack++sqlLazyTextVarcharN :: LText.Text -> Column SqlVarcharN+sqlLazyTextVarcharN = IPT.literalColumn . HPQ.StringLit . LText.unpack+ pgNumeric :: Sci.Scientific -> Column PGNumeric pgNumeric = IPT.literalColumn . HPQ.NumericLit @@ -190,6 +202,8 @@   showSqlType _ = "numeric" instance IsSqlType SqlText where   showSqlType _ = "text"+instance IsSqlType SqlVarcharN where+  showSqlType _ = "varchar" instance IsSqlType SqlTime where   showSqlType _ = "time" instance IsSqlType SqlTimestamp where@@ -249,6 +263,9 @@ data SqlInterval data SqlNumeric data SqlText+-- | @VARCHAR(n)@ for any @n@.  Opaleye does not do anything to check+-- that the @n@ you choose is correctly adhered to!+data SqlVarcharN data SqlTime data SqlTimestamp -- | Be careful if you use Haskell's `Time.ZonedTime` with

@@ -58,6 +58,12 @@   where g (a0, t0) = (a1, \lat primQuery -> PQ.times lat primQuery primQuery', t1)           where (a1, primQuery', t1) = f (a0, t0) +leftJoinQueryArr :: ((a, Tag) -> (b, HPQ.PrimExpr, PQ.PrimQuery, Tag)) -> QueryArr a b+leftJoinQueryArr f = QueryArr g+  where g (a0, t0) = (a1, \lat primQueryL ->+                            PQ.Join PQ.LeftJoin cond (PQ.NonLateral, primQueryL) (lat, primQuery'), t1)+          where (a1, cond, primQuery', t1) = f (a0, t0)+ {-# DEPRECATED simpleQueryArr "Use 'productQueryArr' instead. Its name indicates better what it actually does" #-} simpleQueryArr :: ((a, Tag) -> (b, PQ.PrimQuery, Tag)) -> QueryArr a b simpleQueryArr = productQueryArr

@@ -10,6 +10,9 @@ import qualified Opaleye.Internal.Tag as Tag  rebind :: Default Unpackspec a a => SelectArr a a-rebind = QueryArr (\(a, tag) ->-                     let (b, bindings) = PM.run (runUnpackspec def (PM.extractAttr "rebind" tag) a)+rebind = rebindExplicit def++rebindExplicit :: Unpackspec a b -> SelectArr a b+rebindExplicit u = QueryArr (\(a, tag) ->+                     let (b, bindings) = PM.run (runUnpackspec u (PM.extractAttr "rebind" tag) a)                      in (b, \_ -> PQ.Rebind True bindings, Tag.next tag))

@@ -232,6 +232,15 @@ instance DefaultFromField T.SqlText LT.Text where   defaultFromField = fromPGSFromField +instance DefaultFromField T.SqlVarcharN String where+  defaultFromField = fromPGSFromField++instance DefaultFromField T.SqlVarcharN ST.Text where+  defaultFromField = fromPGSFromField++instance DefaultFromField T.SqlVarcharN LT.Text where+  defaultFromField = fromPGSFromField+ instance DefaultFromField T.SqlDate Time.Day where   defaultFromField = fromPGSFromField 

@@ -10,6 +10,7 @@   MaybeFields,   nothingFields,   justFields,+  matchMaybe,   fromMaybeFields,   maybeFields,   maybeFieldsToSelect,

@@ -166,6 +166,7 @@ instance SqlOrd T.SqlInt2 instance SqlOrd T.SqlNumeric instance SqlOrd T.SqlText+instance SqlOrd T.SqlVarcharN instance SqlOrd T.SqlTime instance SqlOrd T.SqlTimestamptz instance SqlOrd T.SqlTimestamp

@@ -51,10 +51,14 @@   sqlString,   sqlStrictText,   sqlLazyText,+  P.sqlStringVarcharN,+  P.sqlStrictTextVarcharN,+  P.sqlLazyTextVarcharN,   sqlCiStrictText,   sqlCiLazyText,   -- ** Types   SqlText,+  SqlVarcharN,   SqlCitext,   -- * Array   -- ** Creating values@@ -95,6 +99,7 @@                                                    SqlInt2,                                                    SqlNumeric,                                                    SqlText,+                                                   SqlVarcharN,                                                    SqlTime,                                                    SqlTimestamp,                                                    SqlTimestamptz,