Database.Relational.Query.ProjectableExtended

This module defines operators on various polymorphic projections which needs extended GHC features.

Projection for nested Maybes

class ProjectableFlattenMaybe a b where

Interface to compose phantom Maybe nested type.

Minimal complete definition

flatten

Methods

flatten :: ProjectableMaybe p => p a -> p b

Instances

ProjectableFlattenMaybe (Maybe a) b => ProjectableFlattenMaybe (Maybe (Maybe a)) b

Compose Maybe type in projection phantom type.

Methods

flatten :: ProjectableMaybe p => p (Maybe (Maybe a)) -> p b

ProjectableFlattenMaybe (Maybe a) (Maybe a)

Not Maybe type is not processed.

Methods

flatten :: ProjectableMaybe p => p (Maybe a) -> p (Maybe a)

flattenPiMaybe

Arguments

:: (ProjectableMaybe (Projection cont), ProjectableFlattenMaybe (Maybe b) c)

=> Projection cont (Maybe a)

Source Projection. Maybe phantom type

-> Pi a b

Projection path

-> Projection cont c

Narrower Projection. Flatten Maybe phantom type

Get narrower projection with flatten leaf phantom Maybe types along with projection path.

Get narrower projections

(!) infixl 8

Arguments

:: Projection c a

Source projection

-> Pi a b

Projection path

-> Projection c b

Narrower projected object

Get narrower projection along with projection path.

(?!) infixl 8

Arguments

:: Projection c (Maybe a)

Source Projection. Maybe type

-> Pi a b

Projection path

-> Projection c (Maybe b)

Narrower projected object. Maybe type result

Get narrower projection along with projection path Maybe phantom functor is map-ed.

(?!?) infixl 8

Arguments

:: Projection c (Maybe a)

Source Projection. Maybe phantom type

-> Pi a (Maybe b)

Projection path. Maybe type leaf

-> Projection c (Maybe b)

Narrower projected object. Maybe phantom type result

Get narrower projection along with projection path and project into result projection type. Source record Maybe phantom functor and projection path leaf Maybe functor are join-ed.

(!??) infixl 8

Arguments

:: (ProjectableMaybe (Projection cont), ProjectableFlattenMaybe (Maybe b) c)

=> Projection cont (Maybe a)

Source Projection. Maybe phantom type

-> Pi a b

Projection path

-> Projection cont c

Narrower flatten and projected object.

Get narrower projection with flatten leaf phantom Maybe types along with projection path.

Aggregate functions

unsafeAggregateOp :: (AggregatedContext ac, SqlProjectable (p ac)) => Keyword -> Projection Flat a -> p ac b

Unsafely make aggregation uni-operator from SQL keyword.

count :: (Integral b, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat a -> p ac b

Aggregation function COUNT.

sum' :: (Num a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat a -> p ac (Maybe a)

Aggregation function SUM.

sumMaybe :: (Num a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe a) -> p ac (Maybe a)

Aggregation function SUM.

avg :: (Num a, Fractional b, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat a -> p ac (Maybe b)

Aggregation function AVG.

avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe a) -> p ac (Maybe b)

Aggregation function AVG.

max' :: (Ord a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat a -> p ac (Maybe a)

Aggregation function MAX.

maxMaybe :: (Ord a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe a) -> p ac (Maybe a)

Aggregation function MAX.

min' :: (Ord a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat a -> p ac (Maybe a)

Aggregation function MIN.

minMaybe :: (Ord a, AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe a) -> p ac (Maybe a)

Aggregation function MIN.

every :: (AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe Bool) -> p ac (Maybe Bool)

Aggregation function EVERY.

any' :: (AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe Bool) -> p ac (Maybe Bool)

Aggregation function ANY.

some' :: (AggregatedContext ac, SqlProjectable (p ac)) => Projection Flat (Maybe Bool) -> p ac (Maybe Bool)

Aggregation function SOME.

Zipping projection type trick

class ProjectableApplicative p => ProjectableIdZip p where

Zipping except for identity element laws.

Minimal complete definition

leftId, rightId

Methods

leftId :: p ((), a) -> p a

rightId :: p (a, ()) -> p a

Instances

ProjectableIdZip PlaceHolders

Zipping except for identity element laws against placeholder parameter type.

Methods

leftId :: PlaceHolders ((), a) -> PlaceHolders a

rightId :: PlaceHolders (a, ()) -> PlaceHolders a

class ProjectableRunIdsZip a b where

Interface to run recursively identity element laws.

Minimal complete definition

runIds

Methods

runIds :: ProjectableIdZip p => p a -> p b

Instances

ProjectableRunIdsZip a a

Base case definition to run recursively identity element laws.

Methods

runIds :: ProjectableIdZip p => p a -> p a

ProjectableRunIdsZip a b => ProjectableRunIdsZip ((), a) b

Run left identity element law.

Methods

runIds :: ProjectableIdZip p => p ((), a) -> p b

ProjectableRunIdsZip a b => ProjectableRunIdsZip (a, ()) b

Run right identity element law.

Methods

runIds :: ProjectableIdZip p => p (a, ()) -> p b

flattenPh :: ProjectableRunIdsZip a b => PlaceHolders a -> PlaceHolders b

Specialize runIds for PlaceHolders type.