{-# language FlexibleContexts #-}
{-# language MonoLocalBinds #-}
{-# language ScopedTypeVariables #-}
{-# language TypeApplications #-}

module Rel8.Query.Aggregate
  ( aggregate
  , countRows
  , mode
  )
where

-- base
import Data.Functor.Contravariant ( (>$<) )
import Data.Int ( Int64 )
import Prelude

-- opaleye
import qualified Opaleye.Aggregate as Opaleye

-- rel8
import Rel8.Aggregate ( Aggregates )
import Rel8.Expr ( Expr )
import Rel8.Expr.Aggregate ( countStar )
import Rel8.Expr.Order ( desc )
import Rel8.Query ( Query )
import Rel8.Query.Limit ( limit )
import Rel8.Query.Maybe ( optional )
import Rel8.Query.Opaleye ( mapOpaleye )
import Rel8.Query.Order ( orderBy )
import Rel8.Table ( toColumns )
import Rel8.Table.Aggregate ( hgroupBy )
import Rel8.Table.Cols ( Cols( Cols ), fromCols )
import Rel8.Table.Eq ( EqTable, eqTable )
import Rel8.Table.Opaleye ( aggregator )
import Rel8.Table.Maybe ( maybeTable )


-- | Apply an aggregation to all rows returned by a 'Query'.
aggregate :: Aggregates aggregates exprs => Query aggregates -> Query exprs
aggregate :: forall aggregates exprs.
Aggregates aggregates exprs =>
Query aggregates -> Query exprs
aggregate = forall a b. (Select a -> Select b) -> Query a -> Query b
mapOpaleye (forall a b. Aggregator a b -> Select a -> Select b
Opaleye.aggregate forall aggregates exprs.
Aggregates aggregates exprs =>
Aggregator aggregates exprs
aggregator)


-- | Count the number of rows returned by a query. Note that this is different
-- from @countStar@, as even if the given query yields no rows, @countRows@
-- will return @0@.
countRows :: Query a -> Query (Expr Int64)
countRows :: forall a. Query a -> Query (Expr Int64)
countRows = forall (f :: Context) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b a. Table Expr b => b -> (a -> b) -> MaybeTable Expr a -> b
maybeTable Expr Int64
0 forall a. a -> a
id) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Query a -> Query (MaybeTable Expr a)
optional forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall aggregates exprs.
Aggregates aggregates exprs =>
Query aggregates -> Query exprs
aggregate forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Context) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. a -> b -> a
const Aggregate Int64
countStar)


-- | Return the most common row in a query.
mode :: forall a. EqTable a => Query a -> Query a
mode :: forall a. EqTable a => Query a -> Query a
mode Query a
rows = forall a. Word -> Query a -> Query a
limit Word
1 forall a b. (a -> b) -> a -> b
$ forall (f :: Context) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (context :: Context) a.
Table context a =>
Cols context (Columns a) -> a
fromCols forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) forall a b. (a -> b) -> a -> b
$ forall a. Order a -> Query a -> Query a
orderBy (forall a b. (a, b) -> a
fst forall (f :: Context) a b.
Contravariant f =>
(a -> b) -> f b -> f a
>$< forall a. DBOrd a => Order (Expr a)
desc) forall a b. (a -> b) -> a -> b
$ do
  forall aggregates exprs.
Aggregates aggregates exprs =>
Query aggregates -> Query exprs
aggregate forall a b. (a -> b) -> a -> b
$ do
    Columns a Expr
row <- forall (context :: Context) a.
Table context a =>
a -> Columns a context
toColumns forall (f :: Context) a b. Functor f => (a -> b) -> f a -> f b
<$> Query a
rows
    forall (f :: Context) a. Applicative f => a -> f a
pure (Aggregate Int64
countStar, forall (context :: Context) (columns :: HTable).
columns context -> Cols context columns
Cols forall a b. (a -> b) -> a -> b
$ forall (t :: HTable).
HTable t =>
t (Dict (Sql DBEq)) -> t Expr -> t Aggregate
hgroupBy (forall a. EqTable a => Columns a (Dict (Sql DBEq))
eqTable @a) Columns a Expr
row)