git.iko.soy/rel8
on da76712 help sign in
rel8/src/Rel8/Table/Aggregate.hs
92 lines 3.0 kB history raw
1{-# language FlexibleContexts #-}
2{-# language NamedFieldPuns #-}
3{-# language ScopedTypeVariables #-}
4{-# language TypeApplications #-}
5{-# language TypeFamilies #-}
6{-# language ViewPatterns #-}
8module Rel8.Table.Aggregate
9 ( groupBy, hgroupBy
10 , listAgg, nonEmptyAgg
11 )
12where
14-- base
15import Data.Functor.Identity ( Identity( Identity ) )
16import Prelude
18-- rel8
19import Rel8.Aggregate ( Aggregate, Aggregates )
20import Rel8.Expr ( Expr )
21import Rel8.Expr.Aggregate
22 ( groupByExpr
23 , slistAggExpr
24 , snonEmptyAggExpr
25 )
26import Rel8.Schema.Dict ( Dict( Dict ) )
27import Rel8.Schema.HTable ( HTable, hfield, htabulate )
28import Rel8.Schema.HTable.Vectorize ( hvectorize )
29import Rel8.Schema.Null ( Sql )
30import Rel8.Schema.Spec ( Spec( Spec, info ) )
31import Rel8.Table ( toColumns, fromColumns )
32import Rel8.Table.Eq ( EqTable, eqTable )
33import Rel8.Table.List ( ListTable )
34import Rel8.Table.NonEmpty ( NonEmptyTable )
35import Rel8.Type.Eq ( DBEq )
38-- | Group equal tables together. This works by aggregating each column in the
39-- given table with 'groupByExpr'.
40--
41-- For example, if we have a table of items, we could group the items by the
42-- order they belong to:
43--
44-- @
45-- itemsByOrder :: Query (OrderId Expr, ListTable Expr (Item Expr))
46-- itemsByOrder = aggregate $ do
47-- item <- each itemSchema
48-- let orderId = groupBy (itemOrderId item)
49-- let orderItems = listAgg item
50-- pure (orderId, orderItems)
51-- @
52groupBy :: forall exprs aggregates. (EqTable exprs, Aggregates aggregates exprs)
53 => exprs -> aggregates
54groupBy = fromColumns . hgroupBy (eqTable @exprs) . toColumns
57hgroupBy :: HTable t => t (Dict (Sql DBEq)) -> t Expr -> t Aggregate
58hgroupBy eqs exprs = htabulate $ \field ->
59 case hfield eqs field of
60 Dict -> case hfield exprs field of
61 expr -> groupByExpr expr
64-- | Aggregate rows into a single row containing an array of all aggregated
65-- rows. This can be used to associate multiple rows with a single row, without
66-- changing the over cardinality of the query. This allows you to essentially
67-- return a tree-like structure from queries.
68--
69-- For example, if we have a table of orders and each orders contains multiple
70-- items, we could aggregate the table of orders, pairing each order with its
71-- items:
72--
73-- @
74-- ordersWithItems :: Query (Order Expr, ListTable Expr (Item Expr))
75-- ordersWithItems = do
76-- order <- each orderSchema
77-- items <- aggregate $ listAgg <$> itemsFromOrder order
78-- return (order, items)
79-- @
80listAgg :: Aggregates aggregates exprs => exprs -> ListTable Aggregate aggregates
81listAgg (toColumns -> exprs) = fromColumns $
82 hvectorize
83 (\Spec {info} (Identity a) -> slistAggExpr info a)
84 (pure exprs)
87-- | Like 'listAgg', but the result is guaranteed to be a non-empty list.
88nonEmptyAgg :: Aggregates aggregates exprs => exprs -> NonEmptyTable Aggregate aggregates
89nonEmptyAgg (toColumns -> exprs) = fromColumns $
90 hvectorize
91 (\Spec {info} (Identity a) -> snonEmptyAggExpr info a)
92 (pure exprs)