{-| Module : Support Description : Predicates and aggregates useful to relational querying Copyright : © Thor Michael Støre, 2015 License : GPL v2 without "any later version" clause Maintainer : thormichael át gmâïl døt cöm Stability : experimental Predicates and aggregates useful to relational querying. These are not part of the relational algebra but are useful in relational queries in restriction predicates, and extension and summarization expressions. It also has great utility in non-relational queries, such as when performing aggregations. -} module Database.HaskRel.Support ( -- * Predicates (&=), plusminus, (+-), (±), between, (>=<=), (≥≤), xBetween, (><), (>=<), (≥<), (><=), (>≤), (≤), (≥), (≠), -- * Aggregates avg, minx, maxx ) where import Data.List (genericLength) infix 5 &= {-| Reverse predicate application. As "Data.Function.&", the reverse function application operator, but restricted to a boolean result. -} (&=) :: a -> ( a -> Bool ) -> Bool (&=) x f = f x {- -- TODO: Perhaps congruence (or a variation thereof?) is useful? (≅) :: Eq a => t -> t -> (t -> a) -> Bool (≅) a b f = f a == f b >>> 38 ≅ 58 \$ ( `mod` 10 ) True -} -- |>>> plusminus 9 3 10 --True plusminus :: (Ord a, Num a) => a -> a -> a -> Bool plusminus x y c = c >= ( x - y ) && c <= ( x + y ) infix 7 ± infix 7 +- {-| >>> 10 &= 9 ± 3 True >>> rPrint\$ p ∣ (\[pun|weight|] -> weight &= 9 ± 3) ┌─────┬───────┬───────┬────────┬────────┐ │ pno │ pName │ color │ weight │ city │ ╞═════╪═══════╪═══════╪════════╪════════╡ │ P1 │ Nut │ Red │ 12 % 1 │ London │ │ P5 │ Cam │ Blue │ 12 % 1 │ Paris │ └─────┴───────┴───────┴────────┴────────┘ -} (±) :: (Ord a, Num a) => a -> a -> a -> Bool (±) = plusminus -- |>>> 10 &= 9 +- 3 --True (+-) :: (Ord a, Num a) => a -> a -> a -> Bool (+-) = plusminus -- |>>> 5 `between` (5,9) --True between :: Ord a => a -> (a, a) -> Bool between c (l,h) = c >= l && c <= h {-| >>> 5 &= 5 >=<= 9 True -} (>=<=) :: Ord a => a -> a -> a -> Bool (>=<=) l h c = c >= l && c <= h {-| >>> 5 &= 5 ≥≤ 9 True >>> rPrint\$ p ∣ (\[pun|weight|] -> weight &= 11 ≥≤ 14) ┌─────┬───────┬───────┬────────┬────────┐ │ pno │ pName │ color │ weight │ city │ ╞═════╪═══════╪═══════╪════════╪════════╡ │ P1 │ Nut │ Red │ 12 % 1 │ London │ │ P4 │ Screw │ Red │ 14 % 1 │ London │ │ P5 │ Cam │ Blue │ 12 % 1 │ Paris │ └─────┴───────┴───────┴────────┴────────┘ -} (≥≤) :: Ord a => a -> a -> a -> Bool (≥≤) l h c = c >= l && c <= h {-| Between exclusive >>> 5 `xBetween` (5,9) False -} xBetween :: Ord a => a -> (a, a) -> Bool xBetween c (l,h) = c > l && c < h {-| >>> 5 &= 5 >< 9 False >>> rPrint\$ p ∣ (\[pun|weight|] -> weight &= 11 >< 14) ┌─────┬───────┬───────┬────────┬────────┐ │ pno │ pName │ color │ weight │ city │ ╞═════╪═══════╪═══════╪════════╪════════╡ │ P1 │ Nut │ Red │ 12 % 1 │ London │ │ P5 │ Cam │ Blue │ 12 % 1 │ Paris │ └─────┴───────┴───────┴────────┴────────┘ -} (><) :: Ord a => a -> a -> a -> Bool (><) l h c = c > l && c < h -- |>>> 5 &= 5 >=< 9 --True (>=<) :: Ord a => a -> a -> a -> Bool (>=<) l h c = c >= l && c < h -- |>>> 5 &= 5 ≥< 9 --True (≥<) :: Ord a => a -> a -> a -> Bool (≥<) l h c = c >= l && c < h -- |>>> 5 &= 5 ><= 9 --False (><=) :: Ord a => a -> a -> a -> Bool (><=) l h c = c > l && c <= h -- |>>> 5 &= 5 >≤ 9 --False (>≤) :: Ord a => a -> a -> a -> Bool (>≤) l h c = c > l && c <= h -- | Synonym for <= (≤) :: Ord a => a -> a -> Bool (≤) x y = x <= y -- | Synonym for >= (≥) :: Ord a => a -> a -> Bool (≥) x y = x >= y -- | Synonym for /= (≠) :: Eq a => a -> a -> Bool (≠) x y = x /= y {-| Average of a list of values >>> let _qtys a = Label .=. a :: Tagged "qtys" Double >>> pt\$ group sp (rHdr (pno,qty)) (_qtys . avg . agg qty) ┌────────────────────┬───────────────┐ │ qtys :: Double │ sno :: String │ ╞════════════════════╪═══════════════╡ │ 200.0 │ S3 │ │ 216.66666666666666 │ S1 │ │ 300.0 │ S4 │ │ 350.0 │ S2 │ └────────────────────┴───────────────┘ Note the explicit type in the definition of @_qtys@; it is neccessary to provide a specific type for 'pt' to format it as a table, even when an expression would otherwise be correct without this. The following would blow up if prefixed with "pt\$": >>> group sp (rHdr (pno,qty)) ((qtys .=.) . avg . agg qty) fromList [Record{qtys=200.0,sno="S3"},Record{qtys=216.66666666666666,sno="S1"},Record{qtys=300.0,sno="S4"},Record{qtys=350.0,sno="S2"}] -} avg :: (Fractional a, Real a1) => [a1] -> a avg xs = realToFrac (sum xs) / genericLength xs {- | Minimum of several values, defaulting to the second argument if there are no elements. >>> pt\$ group sp (rHdr (pno,qty)) ((qtys .=.) . (`minx` 0) . agg qty) ┌─────────────────┬───────────────┐ │ qtys :: Integer │ sno :: String │ ╞═════════════════╪═══════════════╡ │ 100 │ S1 │ │ 200 │ S3 │ │ 200 │ S4 │ │ 300 │ S2 │ └─────────────────┴───────────────┘ -} minx :: Ord a => [a] -> a -> a minx [] d = d minx xs _ = minimum xs {- Or perhaps with Foldable: minx :: (Ord a, Foldable t) => t a -> a -> a minx fl d = if F.null fl then d else F.minimum fl -} {- | Maximum of several values, defaulting to the second argument if there are no elements >>> pt\$ group sp (rHdr (pno,qty)) ((qtys .=.) . (`maxx` 0) . agg qty) ┌─────────────────┬───────────────┐ │ qtys :: Integer │ sno :: String │ ╞═════════════════╪═══════════════╡ │ 200 │ S3 │ │ 400 │ S1 │ │ 400 │ S2 │ │ 400 │ S4 │ └─────────────────┴───────────────┘ -} maxx :: Ord a => [a] -> a -> a maxx [] d = d maxx xs _ = maximum xs