git.iko.soy/rel8
on bdb75e6 help sign in
rel8/src/Rel8/Expr/Aggregate.hs
202 lines 5.8 kB history raw
1{-# language DataKinds #-}
2{-# language FlexibleContexts #-}
3{-# language ScopedTypeVariables #-}
4{-# language TypeFamilies #-}
6{-# options_ghc -fno-warn-redundant-constraints #-}
8module Rel8.Expr.Aggregate
9 ( count, countDistinct, countStar, countWhere
10 , and, or
11 , min, max
12 , sum, sumWhere
13 , stringAgg
14 , groupByExpr
15 , headAggExpr
16 , array1DAggExpr, listAggExpr, nonEmptyAggExpr
17 )
18where
20-- base
21import Data.Int ( Int64 )
22import Data.List.NonEmpty ( NonEmpty )
23import Prelude hiding ( and, max, min, null, or, sum )
25-- opaleye
26import qualified Opaleye.Internal.HaskellDB.PrimQuery as Opaleye
28-- rel8
29import Rel8.Aggregate ( Aggregate, Aggregator(..), unsafeMakeAggregate )
30import Rel8.Expr ( Expr )
31import Rel8.Expr.Bool ( caseExpr )
32import Rel8.Expr.Opaleye
33 ( castExpr
34 , fromPrimExpr
35 , fromPrimExpr
36 , toPrimExpr
37 )
38import Rel8.Expr.Null ( null )
39import Rel8.Expr.Serialize ( litExpr )
40import Rel8.Schema.Null ( Sql )
41import Rel8.Type.Array ( fromPrimArray )
42import Rel8.Type.Array1D ( Array1D, NotArray )
43import Rel8.Type.Eq ( DBEq )
44import Rel8.Type.Num ( DBNum )
45import Rel8.Type.Ord ( DBMax, DBMin )
46import Rel8.Type.String ( DBString )
47import Rel8.Type.Sum ( DBSum )
50-- | Count the occurances of a single column. Corresponds to @COUNT(a)@
51count :: Expr a -> Aggregate (Expr Int64)
52count = unsafeMakeAggregate toPrimExpr fromPrimExpr $
53 Just Aggregator
54 { operation = Opaleye.AggrCount
55 , ordering = []
56 , distinction = Opaleye.AggrAll
57 }
60-- | Count the number of distinct occurances of a single column. Corresponds to
61-- @COUNT(DISTINCT a)@
62countDistinct :: Sql DBEq a => Expr a -> Aggregate (Expr Int64)
63countDistinct = unsafeMakeAggregate toPrimExpr fromPrimExpr $
64 Just Aggregator
65 { operation = Opaleye.AggrCount
66 , ordering = []
67 , distinction = Opaleye.AggrDistinct
68 }
71-- | Corresponds to @COUNT(*)@.
72countStar :: Aggregate (Expr Int64)
73countStar = count (litExpr True)
76-- | A count of the number of times a given expression is @true@.
77countWhere :: Expr Bool -> Aggregate (Expr Int64)
78countWhere condition = count (caseExpr [(condition, litExpr (Just True))] null)
81-- | Corresponds to @bool_and@.
82and :: Expr Bool -> Aggregate (Expr Bool)
83and = unsafeMakeAggregate toPrimExpr fromPrimExpr $
84 Just Aggregator
85 { operation = Opaleye.AggrBoolAnd
86 , ordering = []
87 , distinction = Opaleye.AggrAll
88 }
91-- | Corresponds to @bool_or@.
92or :: Expr Bool -> Aggregate (Expr Bool)
93or = unsafeMakeAggregate toPrimExpr fromPrimExpr $
94 Just Aggregator
95 { operation = Opaleye.AggrBoolOr
96 , ordering = []
97 , distinction = Opaleye.AggrAll
98 }
101-- | Produce an aggregation for @Expr a@ using the @max@ function.
102max :: Sql DBMax a => Expr a -> Aggregate (Expr a)
103max = unsafeMakeAggregate toPrimExpr fromPrimExpr $
104 Just Aggregator
105 { operation = Opaleye.AggrMax
106 , ordering = []
107 , distinction = Opaleye.AggrAll
108 }
111-- | Produce an aggregation for @Expr a@ using the @max@ function.
112min :: Sql DBMin a => Expr a -> Aggregate (Expr a)
113min = unsafeMakeAggregate toPrimExpr fromPrimExpr $
114 Just Aggregator
115 { operation = Opaleye.AggrMin
116 , ordering = []
117 , distinction = Opaleye.AggrAll
118 }
120-- | Corresponds to @sum@. Note that in SQL, @sum@ is type changing - for
121-- example the @sum@ of @integer@ returns a @bigint@. Rel8 doesn't support
122-- this, and will add explicit cast back to the original input type. This can
123-- lead to overflows, and if you anticipate very large sums, you should upcast
124-- your input.
125sum :: Sql DBSum a => Expr a -> Aggregate (Expr a)
126sum = unsafeMakeAggregate toPrimExpr (castExpr . fromPrimExpr) $
127 Just Aggregator
128 { operation = Opaleye.AggrSum
129 , ordering = []
130 , distinction = Opaleye.AggrAll
131 }
134-- | Take the sum of all expressions that satisfy a predicate.
135sumWhere :: (Sql DBNum a, Sql DBSum a)
136 => Expr Bool -> Expr a -> Aggregate (Expr a)
137sumWhere condition a = sum (caseExpr [(condition, a)] 0)
140-- | Corresponds to @string_agg()@.
141stringAgg :: Sql DBString a
142 => Expr db -> Expr a -> Aggregate (Expr a)
143stringAgg delimiter =
144 unsafeMakeAggregate toPrimExpr (castExpr . fromPrimExpr) $
145 Just Aggregator
146 { operation = Opaleye.AggrStringAggr (toPrimExpr delimiter)
147 , ordering = []
148 , distinction = Opaleye.AggrAll
149 }
152-- | Aggregate a value by grouping by it.
153groupByExpr :: Sql DBEq a => Expr a -> Aggregate (Expr a)
154groupByExpr = unsafeMakeAggregate toPrimExpr fromPrimExpr Nothing
157-- | Keep only the first value.
158headAggExpr :: Expr a -> Aggregate (Expr a)
159headAggExpr = unsafeMakeAggregate toPrimExpr from $ Just
160 Aggregator
161 { operation = Opaleye.AggrArr
162 , ordering = []
163 , distinction = Opaleye.AggrAll
164 }
165 where
166 from = fromPrimExpr . flip Opaleye.ArrayIndex one
167 where
168 one = Opaleye.ConstExpr (Opaleye.NumericLit 1)
171-- | Collect expressions values as an array.
172array1DAggExpr :: NotArray a => Expr a -> Aggregate (Expr (Array1D a))
173array1DAggExpr = unsafeMakeAggregate toPrimExpr fromPrimExpr $ Just
174 Aggregator
175 { operation = Opaleye.AggrArr
176 , ordering = []
177 , distinction = Opaleye.AggrAll
178 }
181-- | Collect expressions values as a list.
182listAggExpr :: Expr a -> Aggregate (Expr [a])
183listAggExpr = unsafeMakeAggregate toPrimExpr from $ Just
184 Aggregator
185 { operation = Opaleye.AggrArr
186 , ordering = []
187 , distinction = Opaleye.AggrAll
188 }
189 where
190 from = fromPrimExpr . fromPrimArray
193-- | Collect expressions values as a non-empty list.
194nonEmptyAggExpr :: Expr a -> Aggregate (Expr (NonEmpty a))
195nonEmptyAggExpr = unsafeMakeAggregate toPrimExpr from $ Just
196 Aggregator
197 { operation = Opaleye.AggrArr
198 , ordering = []
199 , distinction = Opaleye.AggrAll
200 }
201 where
202 from = fromPrimExpr . fromPrimArray