relational-query 0.8.6.0 → 0.8.7.0

raw patch · 9 files changed

+88/−30 lines, 9 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +4/−0
• relational-query.cabal +1/−1
• src/Database/Relational/Query.hs +2/−2
• src/Database/Relational/Query/Arrow.hs +10/−2
• src/Database/Relational/Query/Component.hs +2/−2
• src/Database/Relational/Query/Internal/BaseSQL.hs +8/−4
• src/Database/Relational/Query/Monad/Trans/Ordering.hs +19/−11
• test/sqlsEq.hs +21/−4
• test/sqlsEqArrow.hs +21/−4

@@ -1,5 +1,9 @@ <!-- -*- Markdown -*- --> +## 0.8.7.0++- add NULLS FIRST and NULLS LAST to ORDER BY clause.+ ## 0.8.6.0  - add Show instance of Pi.

@@ -1,5 +1,5 @@ name:                relational-query-version:             0.8.6.0+version:             0.8.7.0 synopsis:            Typeful, Modular, Relational, algebraic query engine description:         This package contiains typeful relation structure and                      relational-algebraic query building DSL which can

@@ -53,7 +53,7 @@ import Database.Relational.Query.Component   (NameConfig (..), SchemaNameMode (..), ProductUnitSupport (..), IdentifierQuotation (..),    Config (..), defaultConfig,-   AggregateKey, Order (..))+   AggregateKey, Order (..), Nulls (..)) import Database.Relational.Query.Sub (SubQuery, unitSQL, queryWidth) import Database.Relational.Query.Projection (Projection, list) import Database.Relational.Query.Projectable@@ -67,7 +67,7 @@    distinct, all', on) import Database.Relational.Query.Monad.Trans.Aggregating   (key, key', set, bkey, rollup, cube, groupingSets)-import Database.Relational.Query.Monad.Trans.Ordering (orderBy, asc, desc)+import Database.Relational.Query.Monad.Trans.Ordering (orderBy', orderBy, asc, desc) import Database.Relational.Query.Monad.Trans.Assigning (assignTo, (<-#)) import Database.Relational.Query.Monad.BaseType import Database.Relational.Query.Monad.Type

@@ -41,7 +41,7 @@    groupBy', key, key', set, bkey, rollup, cube, groupingSets, -  orderBy, asc, desc,+  orderBy', orderBy, asc, desc,    partitionBy, over, @@ -75,7 +75,7 @@    on, wheres, having, groupBy, placeholder,    relation, relation', aggregateRelation, aggregateRelation', uniqueRelation',    groupBy', key, key', set, bkey, rollup, cube, groupingSets,-   orderBy, asc, desc, partitionBy, over,+   orderBy', orderBy, asc, desc, partitionBy, over,    derivedUpdate', derivedUpdate,    derivedInsertValue', derivedInsertValue,    derivedDelete', derivedDelete,@@ -369,6 +369,14 @@ --   Finalize locally built 'AggregatingSetList'. groupingSets :: AggregatingSetList () a -> AggregateKey a groupingSets = runAofM Monadic.groupingSets++-- | Same as 'Monadic.orderBy''.+--   The result arrow is designed to be injected by local projections.+orderBy' :: Monad m+         => Order+         -> Nulls+         -> Orderings c m (Projection c t) ()+orderBy' o n = queryA $ \p -> Monadic.orderBy' p o n  -- | Same as 'Monadic.orderBy'. --   The result arrow is designed to be injected by local projections.

@@ -16,12 +16,12 @@          AggregateKey,           -- * Types for ordering-         Order (..),+         Order (..), Nulls (..),        ) where  import Database.Relational.Query.Internal.Config   (NameConfig (..),    ProductUnitSupport (..), SchemaNameMode (..), IdentifierQuotation (..),    Config (..), defaultConfig,)-import Database.Relational.Query.Internal.BaseSQL (Order (..),)+import Database.Relational.Query.Internal.BaseSQL (Order (..), Nulls (..),) import Database.Relational.Query.Internal.GroupingSQL (AggregateKey)

@@ -10,7 +10,7 @@ -- This module provides base structure of SQL syntax tree. module Database.Relational.Query.Internal.BaseSQL (   Duplication (..), showsDuplication,-  Order (..), OrderColumn, OrderingTerm, composeOrderBy,+  Order (..), Nulls (..), OrderColumn, OrderingTerm, composeOrderBy,   AssignColumn, AssignTerm, Assignment, composeSets,   composeChunkValues, composeChunkValuesWithColumns,   ) where@@ -37,21 +37,25 @@ -- | Order direction. Ascendant or Descendant. data Order = Asc | Desc  deriving Show +-- | Order of null.+data Nulls =  NullsFirst | NullsLast deriving Show+ -- | Type for order-by column type OrderColumn = StringSQL  -- | Type for order-by term-type OrderingTerm = (Order, OrderColumn)+type OrderingTerm = ((Order, Maybe Nulls), OrderColumn)  -- | Compose ORDER BY clause from OrderingTerms composeOrderBy :: [OrderingTerm] -> StringSQL composeOrderBy =  d where   d []       = mempty   d ts@(_:_) = ORDER <> BY <> SQL.fold (|*|) (map showsOt ts)-  showsOt (o, e) = e <> order o+  showsOt ((o, mn), e) = e <> order o <> maybe mempty ((NULLS <>) . nulls) mn   order Asc  = ASC   order Desc = DESC-+  nulls NullsFirst = FIRST+  nulls NullsLast  = LAST  -- | Column SQL String of assignment type AssignColumn = StringSQL

@@ -19,7 +19,7 @@   Orderings, orderings,    -- * API of query with ordering-  orderBy, asc, desc,+  orderBy', orderBy, asc, desc,    -- * Result   extractOrderingTerms@@ -32,7 +32,7 @@ import Data.DList (DList, toList)  import Database.Relational.Query.Internal.BaseSQL-  (Order(Asc, Desc), OrderColumn, OrderingTerm)+  (Order (..), Nulls (..), OrderColumn, OrderingTerm)  import Database.Relational.Query.Projection (Projection) import qualified Database.Relational.Query.Projection as Projection@@ -84,30 +84,38 @@  -- | Add ordering terms. updateOrderBys :: (Monad m, ProjectableOrdering (Projection c))-               => Order            -- ^ Order direction-               -> Projection c t   -- ^ Ordering terms to add-               -> Orderings c m () -- ^ Result context with ordering-updateOrderBys order p = Orderings . mapM_ tell $ terms  where-  terms = curry pure order `map` orderTerms p+               => (Order, Maybe Nulls) -- ^ Order direction+               -> Projection c t       -- ^ Ordering terms to add+               -> Orderings c m ()     -- ^ Result context with ordering+updateOrderBys opair p = Orderings . mapM_ tell $ terms  where+  terms = curry pure opair `map` orderTerms p +-- | Add ordering terms with null ordering.+orderBy' :: (Monad m, ProjectableOrdering (Projection c))+         => Projection c t   -- ^ Ordering terms to add+         -> Order            -- ^ Order direction+         -> Nulls            -- ^ Order of null+         -> Orderings c m () -- ^ Result context with ordering+orderBy' p o n = updateOrderBys (o, Just n) p+ -- | Add ordering terms. orderBy :: (Monad m, ProjectableOrdering (Projection c))         => Projection c t   -- ^ Ordering terms to add-        -> Order            -- ^ Order direction+        -> Order        -- ^ Order direction         -> Orderings c m () -- ^ Result context with ordering-orderBy = flip updateOrderBys+orderBy p o = updateOrderBys (o, Nothing) p  -- | Add ascendant ordering term. asc :: (Monad m, ProjectableOrdering (Projection c))     => Projection c t   -- ^ Ordering terms to add     -> Orderings c m () -- ^ Result context with ordering-asc  =  updateOrderBys Asc+asc  =  updateOrderBys (Asc, Nothing)  -- | Add descendant ordering term. desc :: (Monad m, ProjectableOrdering (Projection c))      => Projection c t   -- ^ Ordering terms to add      -> Orderings c m () -- ^ Result context with ordering-desc =  updateOrderBys Desc+desc =  updateOrderBys (Desc, Nothing)  -- | Run 'Orderings' to get 'OrderingTerms' extractOrderingTerms :: (Monad m, Functor m) => Orderings c m a -> m (a, [OrderingTerm])

@@ -506,17 +506,28 @@   on $ just (a ! strA2') .=. b ?! strB2'    orderBy (a ! strA1') Asc-  orderBy (b ?! mayStrB1') Desc+  orderBy' (b ?! mayStrB1') Desc NullsLast    return $ (,) |$| a |*| b +ordFlatY :: Relation () (SetA, Maybe SetB)+ordFlatY =  relation $ do+  a <- query setA+  b <- queryMaybe setB+  on $ just (a ! strA2') .=. b ?! strB2'++  orderBy (a ! strA1') Asc+  orderBy' b Desc NullsLast++  return $ (,) |$| a |*| b+ ordAggX :: Relation () (String, Int64) ordAggX =  aggregateRelation $ do   c <- query setC    gc1 <- groupBy $ c ! strC1' -  orderBy (sum' $ c ! intC0') Asc+  orderBy' (sum' $ c ! intC0') Asc NullsFirst    return $ gc1 >< count (c ! intC0') @@ -529,10 +540,16 @@     "SELECT ALL T0.int_a0 AS f0, T0.str_a1 AS f1, T0.str_a2 AS f2, \     \           T1.int_b0 AS f3, T1.may_str_b1 AS f4, T1.str_b2 AS f5 \     \  FROM TEST.set_a T0 LEFT JOIN TEST.set_b T1 ON (T0.str_a2 = T1.str_b2) \-    \  ORDER BY T0.str_a1 ASC, T1.may_str_b1 DESC"+    \  ORDER BY T0.str_a1 ASC, T1.may_str_b1 DESC NULLS LAST"+  , eqProp "order-by - flag 2" ordFlatY+    "SELECT ALL T0.int_a0 AS f0, T0.str_a1 AS f1, T0.str_a2 AS f2, \+    \           T1.int_b0 AS f3, T1.may_str_b1 AS f4, T1.str_b2 AS f5 \+    \  FROM TEST.set_a T0 LEFT JOIN TEST.set_b T1 ON (T0.str_a2 = T1.str_b2) \+    \  ORDER BY T0.str_a1 ASC, T1.int_b0 DESC NULLS LAST, \+    \           T1.may_str_b1 DESC NULLS LAST, T1.str_b2 DESC NULLS LAST"   , eqProp "order-by - aggregated" ordAggX     "SELECT ALL T0.str_c1 AS f0, COUNT(T0.int_c0) AS f1 \-    \  FROM TEST.set_c T0 GROUP BY T0.str_c1 ORDER BY SUM(T0.int_c0) ASC"+    \  FROM TEST.set_c T0 GROUP BY T0.str_c1 ORDER BY SUM(T0.int_c0) ASC NULLS FIRST"   ]  partitionX :: Relation () (String, Int64)

@@ -416,17 +416,28 @@   on -< just (a ! strA2') .=. b ?! strB2'    orderBy Asc  -< a ! strA1'-  orderBy Desc -< b ?! mayStrB1'+  orderBy' Desc NullsLast -< b ?! mayStrB1'    returnA -< (,) |$| a |*| b +ordFlatY :: Relation () (SetA, Maybe SetB)+ordFlatY =  relation $ proc () -> do+  a <- query setA -< ()+  b <- queryMaybe setB -< ()+  on -< just (a ! strA2') .=. b ?! strB2'++  orderBy Asc  -< a ! strA1'+  orderBy' Desc NullsLast -< b++  returnA -< (,) |$| a |*| b+ ordAggX :: Relation () (String, Int64) ordAggX =  aggregateRelation $ proc () -> do   c <- query setC -< ()    gc1 <- groupBy -< c ! strC1' -  orderBy Asc -< sum' $ c ! intC0'+  orderBy' Asc NullsFirst -< sum' $ c ! intC0'    returnA -< gc1 >< count (c ! intC0') @@ -439,10 +450,16 @@     "SELECT ALL T0.int_a0 AS f0, T0.str_a1 AS f1, T0.str_a2 AS f2, \     \           T1.int_b0 AS f3, T1.may_str_b1 AS f4, T1.str_b2 AS f5 \     \  FROM TEST.set_a T0 LEFT JOIN TEST.set_b T1 ON (T0.str_a2 = T1.str_b2) \-    \  ORDER BY T0.str_a1 ASC, T1.may_str_b1 DESC"+    \  ORDER BY T0.str_a1 ASC, T1.may_str_b1 DESC NULLS LAST"+  , eqProp "order-by - flat 2" ordFlatY+    "SELECT ALL T0.int_a0 AS f0, T0.str_a1 AS f1, T0.str_a2 AS f2, \+    \           T1.int_b0 AS f3, T1.may_str_b1 AS f4, T1.str_b2 AS f5 \+    \  FROM TEST.set_a T0 LEFT JOIN TEST.set_b T1 ON (T0.str_a2 = T1.str_b2) \+    \  ORDER BY T0.str_a1 ASC, T1.int_b0 DESC NULLS LAST, \+    \           T1.may_str_b1 DESC NULLS LAST, T1.str_b2 DESC NULLS LAST"   , eqProp "order-by - aggregated" ordAggX     "SELECT ALL T0.str_c1 AS f0, COUNT(T0.int_c0) AS f1 \-    \  FROM TEST.set_c T0 GROUP BY T0.str_c1 ORDER BY SUM(T0.int_c0) ASC"+    \  FROM TEST.set_c T0 GROUP BY T0.str_c1 ORDER BY SUM(T0.int_c0) ASC NULLS FIRST"   ]  partitionX :: Relation () (String, Int64)