relational-query 0.1.0.1 → 0.2.0.0

raw patch · 9 files changed

+56/−48 lines, 9 files

Files

• relational-query.cabal +1/−1
• src/Database/Relational/Query/Monad/Aggregate.hs +11/−10
• src/Database/Relational/Query/Monad/Simple.hs +13/−11
• src/Database/Relational/Query/Monad/Trans/Ordering.hs +1/−4
• src/Database/Relational/Query/Monad/Type.hs +8/−2
• src/Database/Relational/Query/Monad/Unique.hs +3/−2
• src/Database/Relational/Query/Projectable.hs +5/−1
• src/Database/Relational/Query/Relation.hs +13/−16
• test/SQLs.hs +1/−1

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

@@ -36,7 +36,7 @@   (AggregateColumnRef, Duplication, QueryRestriction, OrderingTerms, AggregateElem, composeOver) import Database.Relational.Query.Sub (SubQuery, aggregatedSubQuery, JoinProduct) import qualified Database.Relational.Query.Sub as SubQuery-import Database.Relational.Query.Projectable (SqlProjectable, unsafeProjectSql, unsafeShowSql)+import Database.Relational.Query.Projectable (PlaceHolders, SqlProjectable, unsafeProjectSql, unsafeShowSql)  import Database.Relational.Query.Monad.Class (MonadRestrict(..), MonadQualify(..), MonadPartition (..)) import Database.Relational.Query.Monad.Trans.Join (join')@@ -45,15 +45,16 @@ import Database.Relational.Query.Monad.Trans.Aggregating   (aggregatings, extractAggregateTerms, AggregatingSetT, PartitioningSet) import Database.Relational.Query.Monad.Trans.Ordering-  (Orderings, orderings, OrderedQuery, extractOrderingTerms)-import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)+  (Orderings, orderings, extractOrderingTerms)+import Database.Relational.Query.Monad.Type+  (ConfigureQuery, askConfig, QueryCore, extractCore, OrderedQuery)   -- | Aggregated query monad type. type QueryAggregate     = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) --- | Aggregated query type. AggregatedQuery r == QueryAggregate (Projection Aggregated r).-type AggregatedQuery  r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) r+-- | Aggregated query type. 'AggregatedQuery' p r == 'QueryAggregate' ('PlaceHolders' p, 'Projection' 'Aggregated' r).+type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r  -- | Partition monad type for partition-by clause. type Window           c = Orderings c (PartitioningSet c)@@ -70,8 +71,8 @@ instance MonadQualify ConfigureQuery QueryAggregate where   liftQualify = aggregatedQuery -extract :: AggregatedQuery r-        -> ConfigureQuery ((((((Projection Aggregated r, OrderingTerms),+extract :: AggregatedQuery p r+        -> ConfigureQuery (((((((PlaceHolders p, Projection Aggregated r), OrderingTerms),                                QueryRestriction Aggregated),                               [AggregateElem]),                              QueryRestriction Flat),@@ -79,15 +80,15 @@ extract =  extractCore . extractAggregateTerms . extractRestrict . extractOrderingTerms  -- | Run 'AggregatedQuery' to get SQL with 'ConfigureQuery' computation.-toSQL :: AggregatedQuery r     -- ^ 'AggregatedQuery' to run+toSQL :: AggregatedQuery p r     -- ^ 'AggregatedQuery' to run       -> ConfigureQuery String -- ^ Result SQL string with 'ConfigureQuery' computation toSQL =  fmap SubQuery.toSQL . toSubQuery  -- | Run 'AggregatedQuery' to get 'SubQuery' with 'ConfigureQuery' computation.-toSubQuery :: AggregatedQuery r       -- ^ 'AggregatedQuery' to run+toSubQuery :: AggregatedQuery p r       -- ^ 'AggregatedQuery' to run            -> ConfigureQuery SubQuery -- ^ Result 'SubQuery' with 'ConfigureQuery' computation toSubQuery q = do-  ((((((pj, ot), grs), ag), rs), pd), da) <- extract q+  (((((((_ph, pj), ot), grs), ag), rs), pd), da) <- extract q   c <- askConfig   return $ aggregatedSubQuery c (Projection.untype pj) da pd rs ag grs ot 

@@ -19,7 +19,7 @@   simple,    toSQL,-  toSubQuery+  toSubQuery,   ) where  import Database.Relational.Query.Context (Flat)@@ -30,19 +30,21 @@ import Database.Relational.Query.Monad.Trans.Join (join') import Database.Relational.Query.Monad.Trans.Restricting (restrictings) import Database.Relational.Query.Monad.Trans.Ordering-  (Orderings, orderings, OrderedQuery, extractOrderingTerms)-import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)+  (Orderings, orderings, extractOrderingTerms)+import Database.Relational.Query.Monad.Type+  (ConfigureQuery, askConfig, QueryCore, extractCore, OrderedQuery)+import Database.Relational.Query.Projectable (PlaceHolders)  import Database.Relational.Query.Component (Duplication, QueryRestriction, OrderingTerms) import Database.Relational.Query.Sub (SubQuery, flatSubQuery, JoinProduct) import qualified Database.Relational.Query.Sub as SubQuery  --- | Simple query (not-aggregated) monad type.+-- | Simple (not-aggregated) query monad type. type QuerySimple = Orderings Flat QueryCore --- | Simple query (not-aggregated) query type. 'SimpleQuery' r == 'QuerySimple' ('Projection' r).-type SimpleQuery r = OrderedQuery Flat QueryCore r+-- | Simple (not-aggregated) query type. 'SimpleQuery'' p r == 'QuerySimple' ('PlaceHolders' p, 'Projection' r).+type SimpleQuery p r = OrderedQuery Flat QueryCore p r  -- | Lift from qualified table forms into 'QuerySimple'. simple :: ConfigureQuery a -> QuerySimple a@@ -52,20 +54,20 @@ instance MonadQualify ConfigureQuery (Orderings Flat QueryCore) where   liftQualify = simple -extract :: SimpleQuery r-        -> ConfigureQuery ((((Projection Flat r, OrderingTerms), QueryRestriction Flat),+extract :: SimpleQuery p r+        -> ConfigureQuery (((((PlaceHolders p, Projection Flat r), OrderingTerms), QueryRestriction Flat),                            JoinProduct), Duplication) extract =  extractCore . extractOrderingTerms  -- | Run 'SimpleQuery' to get SQL string with 'Qualify' computation.-toSQL :: SimpleQuery r         -- ^ 'SimpleQuery' to run+toSQL :: SimpleQuery p r         -- ^ 'SimpleQuery' to run       -> ConfigureQuery String -- ^ Result SQL string with 'Qualify' computation toSQL =  fmap SubQuery.toSQL . toSubQuery  -- | Run 'SimpleQuery' to get 'SubQuery' with 'Qualify' computation.-toSubQuery :: SimpleQuery r           -- ^ 'SimpleQuery' to run+toSubQuery :: SimpleQuery p r        -- ^ 'SimpleQuery'' to run            -> ConfigureQuery SubQuery -- ^ Result 'SubQuery' with 'Qualify' computation toSubQuery q = do-   ((((pj, ot), rs), pd), da) <- extract q+   (((((_ph, pj), ot), rs), pd), da) <- extract q    c <- askConfig    return $ flatSubQuery c (Projection.untype pj) da pd rs ot

@@ -16,7 +16,7 @@ -- from query into query with ordering. module Database.Relational.Query.Monad.Trans.Ordering (   -- * Transformer into query with ordering-  Orderings, orderings, OrderedQuery, OrderingTerms,+  Orderings, orderings, OrderingTerms,    -- * API of query with ordering   orderBy, asc, desc,@@ -67,9 +67,6 @@ -- | 'MonadPartition' with ordering. instance MonadPartition m => MonadPartition (Orderings c m) where   unsafeAddPartitionKey = orderings . unsafeAddPartitionKey---- | OrderedQuery type synonym. Projection must be the same as 'Orderings' type parameter 'p'-type OrderedQuery c m r = Orderings c m (Projection c r)  -- | Ordering term projection type interface. class ProjectableOrdering p where

@@ -10,7 +10,8 @@ -- This module defines core query type. module Database.Relational.Query.Monad.Type (   -- * Core query monad-  ConfigureQuery, configureQuery, qualifyQuery, askConfig, QueryCore, extractCore+  ConfigureQuery, configureQuery, qualifyQuery, askConfig, QueryCore, extractCore,+  OrderedQuery,   ) where  import Data.Functor.Identity (Identity, runIdentity)@@ -18,12 +19,14 @@ import Database.Relational.Query.Component (Config, Duplication, QueryRestriction) import Database.Relational.Query.Sub (Qualified, JoinProduct) import Database.Relational.Query.Context (Flat)+import Database.Relational.Query.Projection (Projection)+import Database.Relational.Query.Projectable (PlaceHolders) import qualified Database.Relational.Query.Monad.Trans.Qualify as Qualify import Database.Relational.Query.Monad.Trans.Qualify (Qualify, qualify, evalQualifyPrime) import Database.Relational.Query.Monad.Trans.Config (QueryConfig, runQueryConfig, askQueryConfig) import Database.Relational.Query.Monad.Trans.Join (QueryJoin, extractProduct) import Database.Relational.Query.Monad.Trans.Restricting (Restrictings, extractRestrict)-+import Database.Relational.Query.Monad.Trans.Ordering (Orderings)  -- | Thin monad type for untyped structure. type ConfigureQuery = Qualify (QueryConfig Identity)@@ -47,3 +50,6 @@ extractCore :: QueryCore a             -> ConfigureQuery (((a, QueryRestriction Flat), JoinProduct), Duplication) extractCore =  extractProduct . extractRestrict++-- | OrderedQuery monad type with placeholder type 'p'. Projection must be the same as 'Orderings' context type parameter 'c'.+type OrderedQuery c m p r = Orderings c m (PlaceHolders p, Projection c r)

@@ -28,6 +28,7 @@ import Database.Relational.Query.Monad.Trans.Join (join') import Database.Relational.Query.Monad.Trans.Restricting (restrictings) import Database.Relational.Query.Monad.Type (ConfigureQuery, askConfig, QueryCore, extractCore)+import Database.Relational.Query.Projectable (PlaceHolders)  import Database.Relational.Query.Component (Duplication, QueryRestriction) import Database.Relational.Query.Sub (SubQuery, flatSubQuery, JoinProduct)@@ -49,9 +50,9 @@ extract (QueryUnique c) = extractCore c  -- | Run 'SimpleQuery' to get 'SubQuery' with 'Qualify' computation.-toSubQuery :: QueryUnique (Projection c r) -- ^ 'QueryUnique' to run+toSubQuery :: QueryUnique (PlaceHolders p, Projection c r) -- ^ 'QueryUnique' to run            -> ConfigureQuery SubQuery      -- ^ Result 'SubQuery' with 'Qualify' computation toSubQuery q = do-  (((pj, rs), pd), da) <- extract q+  ((((_ph, pj), rs), pd), da) <- extract q   c <- askConfig   return $ flatSubQuery c (Projection.untype pj) da pd rs []

@@ -27,7 +27,7 @@    -- * Placeholders   PlaceHolders, addPlaceHolders, unsafePlaceHolders,-  placeholder', placeholder,+  placeholder', placeholder, unitPlaceHolder,    -- * Projectable into SQL strings   unsafeShowSqlExpr,@@ -499,6 +499,10 @@ -- | Unsafely get placeholder parameter unsafePlaceHolders :: PlaceHolders p unsafePlaceHolders =  PlaceHolders++-- | No placeholder semantics+unitPlaceHolder :: PlaceHolders ()+unitPlaceHolder =  unsafePlaceHolders  -- | Unsafely cast placeholder parameter type. unsafeCastPlaceHolders :: PlaceHolders a -> PlaceHolders b

@@ -73,7 +73,7 @@   (Projection, ListProjection, unsafeListProjectionFromSubQuery) import qualified Database.Relational.Query.Projection as Projection import Database.Relational.Query.Projectable-  (PlaceHolders, addPlaceHolders, unsafePlaceHolders, projectZip)+  (PlaceHolders, unitPlaceHolder, addPlaceHolders, unsafePlaceHolders, projectZip) import Database.Relational.Query.ProjectableExtended ((!))  @@ -153,27 +153,24 @@           -> m (ListProjection (Projection c) r) queryList =  queryList0 -unsafeRelation :: SimpleQuery rp -> Relation p r-unsafeRelation =  SubQuery . Simple.toSubQuery+addUnitPH :: Functor f => f t -> f (PlaceHolders (), t)+addUnitPH =  ((,) unitPlaceHolder <$>) +-- | Finalize 'QuerySimple' monad and generate 'Relation' with place-holder parameter 'p'.+relation' :: SimpleQuery p r -> Relation p r+relation' =  SubQuery . Simple.toSubQuery+ -- | Finalize 'QuerySimple' monad and generate 'Relation'. relation :: QuerySimple (Projection Flat r) -> Relation () r-relation =  unsafeRelation---- | Finalize 'QuerySimple' monad and generate 'Relation' with place-holder parameter 'p'.-relation' :: QuerySimple (PlaceHolders p, Projection Flat r) -> Relation p r-relation' =  unsafeRelation . fmap snd+relation =  relation' . addUnitPH -unsafeAggregateRelation :: AggregatedQuery rp -> Relation p r-unsafeAggregateRelation =  SubQuery . Aggregate.toSubQuery+-- | Finalize 'QueryAggregate' monad and geneate 'Relation' with place-holder parameter 'p'.+aggregateRelation' :: AggregatedQuery p r -> Relation p r+aggregateRelation' =  SubQuery . Aggregate.toSubQuery  -- | Finalize 'QueryAggregate' monad and geneate 'Relation'. aggregateRelation :: QueryAggregate (Projection Aggregated r) -> Relation () r-aggregateRelation =  unsafeAggregateRelation---- | Finalize 'QueryAggregate' monad and geneate 'Relation' with place-holder parameter 'p'.-aggregateRelation' :: QueryAggregate (PlaceHolders p, Projection Aggregated r) -> Relation p r-aggregateRelation' =  unsafeAggregateRelation . fmap snd+aggregateRelation =  aggregateRelation' . addUnitPH   -- | Restriction function type for direct style join operator.@@ -419,7 +416,7 @@  -- | Finalize 'QueryUnique' monad and generate 'UniqueRelation'. uniqueRelation' :: QueryUnique (PlaceHolders p, Projection c r) -> UniqueRelation p c r-uniqueRelation' =  unsafeUnique . SubQuery . Unique.toSubQuery . fmap snd+uniqueRelation' =  unsafeUnique . SubQuery . Unique.toSubQuery  -- | Aggregated 'UniqueRelation'. aggregatedUnique :: Relation ph r

@@ -98,7 +98,7 @@    wheres $ a ?! strA2' .=. b ! mayStrB1' -  return $ fromMaybe' (value 1) (a ?! intA0') >< b+  return $ fromMaybe (value 1) (a ?! intA0') >< b  maybes :: [Test] maybes =  [ eqShow "isJust" justX