{-# language DataKinds #-}
{-# language FlexibleContexts #-}
{-# language FlexibleInstances #-}
{-# language LambdaCase #-}
{-# language MultiParamTypeClasses #-}
{-# language NamedFieldPuns #-}
{-# language ScopedTypeVariables #-}
{-# language StandaloneKindSignatures #-}
{-# language TypeApplications #-}
{-# language TypeFamilies #-}
{-# language UndecidableInstances #-}

module Rel8.Table.Nullify
  ( Nullify
  , aggregateNullify
  , guard
  , isNull
  )
where

-- base
import Control.Applicative ( liftA2 )
import Data.Functor.Const ( Const( Const ), getConst )
import Data.Functor.Identity ( runIdentity )
import Data.Kind ( Type )
import Prelude

-- comonad
import Control.Comonad ( Comonad, duplicate, extract, ComonadApply, (<@>) )

-- rel8
import Rel8.Aggregate ( Aggregate )
import Rel8.Expr ( Expr )
import Rel8.Expr.Bool ( (||.), false )
import qualified Rel8.Expr.Null as Expr
import Rel8.Kind.Context ( Reifiable, contextSing )
import Rel8.Schema.Context.Nullify
  ( Nullifiability( NAggregate, NExpr )
  , NonNullifiability
  , Nullifiable, nullifiability
  , nullifiableOrNot, absurd
  , guarder
  , nullifier
  , unnullifier
  )
import Rel8.Schema.Dict ( Dict( Dict ) )
import Rel8.Schema.HTable ( HTable )
import Rel8.Schema.HTable.Nullify
  ( HNullify, hnulls, hnullify, hunnullify
  , hguard
  , hproject
  )
import qualified Rel8.Schema.Kind as K
import Rel8.Schema.Null ( Nullity( NotNull, Null ) )
import qualified Rel8.Schema.Result as R
import Rel8.Table
  ( Table, Columns, Context, toColumns, fromColumns
  , FromExprs, fromResult, toResult
  , Transpose
  )
import Rel8.Schema.Spec ( Spec( Spec, nullity ) )
import Rel8.Table.Eq ( EqTable, eqTable )
import Rel8.Table.Ord ( OrdTable, ordTable )
import Rel8.Table.Projection ( Projectable, apply, project )

-- semigroupoids
import Data.Functor.Apply ( Apply, (<.>), liftF2 )
import Data.Functor.Bind ( Bind, (>>-) )
import Data.Functor.Extend ( Extend, duplicated )


type Nullify :: K.Context -> Type -> Type
data Nullify context a
  = Table (Nullifiability context) a
  | Fields (NonNullifiability context) (HNullify (Columns a) (Context a))


instance Projectable (Nullify context) where
  project :: Projection a b -> Nullify context a -> Nullify context b
project Projection a b
f = \case
    Table Nullifiability context
nullifiable a
a -> Nullifiability context -> b -> Nullify context b
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (Columns b (Context b) -> b
forall (context :: * -> *) a.
Table context a =>
Columns a context -> a
fromColumns (Projection a b -> Columns a (Context b) -> Columns b (Context b)
forall a b (context :: * -> *).
Projecting a b =>
Projection a b -> Columns a context -> Columns b context
apply Projection a b
f (a -> Columns a (Context b)
forall (context :: * -> *) a.
Table context a =>
a -> Columns a context
toColumns a
a)))
    Fields NonNullifiability context
nonNullifiable HNullify (Columns a) (Context a)
a -> NonNullifiability context
-> HNullify (Columns b) (Context b) -> Nullify context b
forall (context :: * -> *) a.
NonNullifiability context
-> HNullify (Columns a) (Context a) -> Nullify context a
Fields NonNullifiability context
nonNullifiable ((forall (ctx :: * -> *).
 Columns (Transpose (Field a) a) ctx
 -> Columns (Transpose (Field a) b) ctx)
-> HNullify (Columns (Transpose (Field a) a)) (Context b)
-> HNullify (Columns (Transpose (Field a) b)) (Context b)
forall (t :: HTable) (t' :: HTable) (context :: * -> *).
(forall (ctx :: * -> *). t ctx -> t' ctx)
-> HNullify t context -> HNullify t' context
hproject (Projection a b -> Columns a ctx -> Columns b ctx
forall a b (context :: * -> *).
Projecting a b =>
Projection a b -> Columns a context -> Columns b context
apply Projection a b
f) HNullify (Columns a) (Context a)
HNullify (Columns (Transpose (Field a) a)) (Context b)
a)


instance Nullifiable context => Functor (Nullify context) where
  fmap :: (a -> b) -> Nullify context a -> Nullify context b
fmap a -> b
f = \case
    Table Nullifiability context
nullifiable a
a -> Nullifiability context -> b -> Nullify context b
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (a -> b
f a
a)
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context
-> NonNullifiability context -> Nullify context b
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Foldable (Nullify context) where
  foldMap :: (a -> m) -> Nullify context a -> m
foldMap a -> m
f = \case
    Table Nullifiability context
_ a
a -> a -> m
f a
a
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context -> NonNullifiability context -> m
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Traversable (Nullify context) where
  traverse :: (a -> f b) -> Nullify context a -> f (Nullify context b)
traverse a -> f b
f = \case
    Table Nullifiability context
nullifiable a
a -> Nullifiability context -> b -> Nullify context b
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (b -> Nullify context b) -> f b -> f (Nullify context b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context
-> NonNullifiability context -> f (Nullify context b)
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Apply (Nullify context) where
  liftF2 :: (a -> b -> c)
-> Nullify context a -> Nullify context b -> Nullify context c
liftF2 a -> b -> c
f = \case
    Table Nullifiability context
nullifiable a
a -> \case
      Table Nullifiability context
_ b
b -> Nullifiability context -> c -> Nullify context c
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (a -> b -> c
f a
a b
b)
      Fields NonNullifiability context
notNullifiable HNullify (Columns b) (Context b)
_ -> Nullifiability context
-> NonNullifiability context -> Nullify context c
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
nullifiable NonNullifiability context
notNullifiable
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context
-> NonNullifiability context
-> Nullify context b
-> Nullify context c
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Applicative (Nullify context) where
  pure :: a -> Nullify context a
pure = Nullifiability context -> a -> Nullify context a
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability
  liftA2 :: (a -> b -> c)
-> Nullify context a -> Nullify context b -> Nullify context c
liftA2 = (a -> b -> c)
-> Nullify context a -> Nullify context b -> Nullify context c
forall (f :: * -> *) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2


instance Nullifiable context => Bind (Nullify context) where
  Table Nullifiability context
_ a
a >>- :: Nullify context a -> (a -> Nullify context b) -> Nullify context b
>>- a -> Nullify context b
f = a -> Nullify context b
f a
a
  Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ >>- a -> Nullify context b
_ = Nullifiability context
-> NonNullifiability context -> Nullify context b
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Monad (Nullify context) where
  >>= :: Nullify context a -> (a -> Nullify context b) -> Nullify context b
(>>=) = Nullify context a -> (a -> Nullify context b) -> Nullify context b
forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
(>>-)


instance Nullifiable context => Extend (Nullify context) where
  duplicated :: Nullify context a -> Nullify context (Nullify context a)
duplicated = \case
    Table Nullifiability context
nullifiable a
a -> Nullifiability context
-> Nullify context a -> Nullify context (Nullify context a)
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (Nullifiability context -> a -> Nullify context a
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable a
a)
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context
-> NonNullifiability context -> Nullify context (Nullify context a)
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable


instance Nullifiable context => Comonad (Nullify context) where
  extract :: Nullify context a -> a
extract = \case
    Table Nullifiability context
_ a
a -> a
a
    Fields NonNullifiability context
notNullifiable HNullify (Columns a) (Context a)
_ -> Nullifiability context -> NonNullifiability context -> a
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability context
forall (context :: * -> *).
Nullifiable context =>
Nullifiability context
nullifiability NonNullifiability context
notNullifiable
  duplicate :: Nullify context a -> Nullify context (Nullify context a)
duplicate = Nullify context a -> Nullify context (Nullify context a)
forall (w :: * -> *) a. Extend w => w a -> w (w a)
duplicated


instance Nullifiable context => ComonadApply (Nullify context) where
  <@> :: Nullify context (a -> b) -> Nullify context a -> Nullify context b
(<@>) = Nullify context (a -> b) -> Nullify context a -> Nullify context b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
(<.>)


instance (Table context a, Reifiable context, context ~ context') =>
  Table context' (Nullify context a)
 where
  type Columns (Nullify context a) = HNullify (Columns a)
  type Context (Nullify context a) = Context a
  type FromExprs (Nullify context a) = Maybe (FromExprs a)
  type Transpose to (Nullify context a) = Nullify to (Transpose to a)

  fromColumns :: Columns (Nullify context a) context' -> Nullify context a
fromColumns = case SContext context
-> Either (NonNullifiability context) (Nullifiability context)
forall (context :: * -> *).
SContext context
-> Either (NonNullifiability context) (Nullifiability context)
nullifiableOrNot SContext context
forall (context :: * -> *). Reifiable context => SContext context
contextSing of
    Left NonNullifiability context
notNullifiable -> NonNullifiability context
-> HNullify (Columns a) (Context a) -> Nullify context a
forall (context :: * -> *) a.
NonNullifiability context
-> HNullify (Columns a) (Context a) -> Nullify context a
Fields NonNullifiability context
notNullifiable
    Right Nullifiability context
nullifiable ->
      Nullifiability context -> a -> Nullify context a
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability context
nullifiable (a -> Nullify context a)
-> (HNullify (Columns a) context' -> a)
-> HNullify (Columns a) context'
-> Nullify context a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      Columns a context' -> a
forall (context :: * -> *) a.
Table context a =>
Columns a context -> a
fromColumns (Columns a context' -> a)
-> (HNullify (Columns a) context' -> Columns a context')
-> HNullify (Columns a) context'
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      Identity (Columns a context') -> Columns a context'
forall a. Identity a -> a
runIdentity (Identity (Columns a context') -> Columns a context')
-> (HNullify (Columns a) context' -> Identity (Columns a context'))
-> HNullify (Columns a) context'
-> Columns a context'
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (forall a. Spec a -> context' (Nullify a) -> Identity (context' a))
-> HNullify (Columns a) context' -> Identity (Columns a context')
forall (t :: HTable) (m :: * -> *) (context :: * -> *).
(HTable t, Apply m) =>
(forall a. Spec a -> context (Nullify a) -> m (context a))
-> HNullify t context -> m (t context)
hunnullify (\Spec a
spec -> context a -> Identity (context a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (context a -> Identity (context a))
-> (context' (Nullify a) -> context a)
-> context' (Nullify a)
-> Identity (context a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Nullifiability context
-> Spec a -> context (Nullify a) -> context a
forall (context :: * -> *) a.
Nullifiability context
-> Spec a -> context (Nullify a) -> context a
unnullifier Nullifiability context
nullifiable Spec a
spec)

  toColumns :: Nullify context a -> Columns (Nullify context a) context'
toColumns = \case
    Table Nullifiability context
nullifiable a
a -> (forall a. Spec a -> context' a -> context' (Nullify a))
-> Columns a context' -> HNullify (Columns a) context'
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. Spec a -> context a -> context (Nullify a))
-> t context -> HNullify t context
hnullify (Nullifiability context
-> Spec a
-> context a
-> context (Maybe (Unnullify' (IsMaybe a) a))
forall (context :: * -> *) a.
Nullifiability context
-> Spec a -> context a -> context (Nullify a)
nullifier Nullifiability context
nullifiable) (a -> Columns a context'
forall (context :: * -> *) a.
Table context a =>
a -> Columns a context
toColumns a
a)
    Fields NonNullifiability context
_ HNullify (Columns a) (Context a)
a -> HNullify (Columns a) (Context a)
Columns (Nullify context a) context'
a

  fromResult :: Columns (Nullify context a) Result -> FromExprs (Nullify context a)
fromResult = (Columns a Result -> FromExprs a)
-> Maybe (Columns a Result) -> Maybe (FromExprs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Table context' a => Columns a Result -> FromExprs a
forall (context :: * -> *) a.
Table context a =>
Columns a Result -> FromExprs a
fromResult @_ @a) (Maybe (Columns a Result) -> Maybe (FromExprs a))
-> (HNullify (Columns a) Result -> Maybe (Columns a Result))
-> HNullify (Columns a) Result
-> Maybe (FromExprs a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Spec a -> Result (Nullify a) -> Maybe (Result a))
-> HNullify (Columns a) Result -> Maybe (Columns a Result)
forall (t :: HTable) (m :: * -> *) (context :: * -> *).
(HTable t, Apply m) =>
(forall a. Spec a -> context (Nullify a) -> m (context a))
-> HNullify t context -> m (t context)
hunnullify forall a. Spec a -> Result (Nullify a) -> Maybe (Result a)
R.unnullifier

  toResult :: FromExprs (Nullify context a) -> Columns (Nullify context a) Result
toResult =
    HNullify (Columns a) Result
-> (Columns a Result -> HNullify (Columns a) Result)
-> Maybe (Columns a Result)
-> HNullify (Columns a) Result
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ((forall a. Spec a -> Result (Nullify a))
-> HNullify (Columns a) Result
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. Spec a -> context (Nullify a)) -> HNullify t context
hnulls (Result (Maybe (Unnullify' (IsMaybe a) a))
-> Spec a -> Result (Maybe (Unnullify' (IsMaybe a) a))
forall a b. a -> b -> a
const Result (Maybe (Unnullify' (IsMaybe a) a))
forall a. Result (Maybe a)
R.null)) ((forall a. Spec a -> Result a -> Result (Nullify a))
-> Columns a Result -> HNullify (Columns a) Result
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. Spec a -> context a -> context (Nullify a))
-> t context -> HNullify t context
hnullify forall a. Spec a -> Result a -> Result (Nullify a)
R.nullifier) (Maybe (Columns a Result) -> HNullify (Columns a) Result)
-> (Maybe (FromExprs a) -> Maybe (Columns a Result))
-> Maybe (FromExprs a)
-> HNullify (Columns a) Result
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    (FromExprs a -> Columns a Result)
-> Maybe (FromExprs a) -> Maybe (Columns a Result)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Table context' a => FromExprs a -> Columns a Result
forall (context :: * -> *) a.
Table context a =>
FromExprs a -> Columns a Result
toResult @_ @a)


instance (EqTable a, context ~ Expr) => EqTable (Nullify context a) where
  eqTable :: Columns (Nullify context a) (Dict (Sql DBEq))
eqTable = (forall a.
 Spec a -> Dict (Sql DBEq) a -> Dict (Sql DBEq) (Nullify a))
-> Columns a (Dict (Sql DBEq))
-> HNullify (Columns a) (Dict (Sql DBEq))
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. Spec a -> context a -> context (Nullify a))
-> t context -> HNullify t context
hnullify (\Spec a
_ Dict (Sql DBEq) a
Dict -> Dict (Sql DBEq) (Nullify a)
forall a (c :: a -> Constraint) (a :: a). c a => Dict c a
Dict) (EqTable a => Columns a (Dict (Sql DBEq))
forall a. EqTable a => Columns a (Dict (Sql DBEq))
eqTable @a)


instance (OrdTable a, context ~ Expr) => OrdTable (Nullify context a) where
  ordTable :: Columns (Nullify context a) (Dict (Sql DBOrd))
ordTable = (forall a.
 Spec a -> Dict (Sql DBOrd) a -> Dict (Sql DBOrd) (Nullify a))
-> Columns a (Dict (Sql DBOrd))
-> HNullify (Columns a) (Dict (Sql DBOrd))
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. Spec a -> context a -> context (Nullify a))
-> t context -> HNullify t context
hnullify (\Spec a
_ Dict (Sql DBOrd) a
Dict -> Dict (Sql DBOrd) (Nullify a)
forall a (c :: a -> Constraint) (a :: a). c a => Dict c a
Dict) (OrdTable a => Columns a (Dict (Sql DBOrd))
forall a. OrdTable a => Columns a (Dict (Sql DBOrd))
ordTable @a)


aggregateNullify :: ()
  => (exprs -> aggregates)
  -> Nullify Expr exprs
  -> Nullify Aggregate aggregates
aggregateNullify :: (exprs -> aggregates)
-> Nullify Expr exprs -> Nullify Aggregate aggregates
aggregateNullify exprs -> aggregates
f = \case
  Table Nullifiability Expr
_ exprs
a -> Nullifiability Aggregate
-> aggregates -> Nullify Aggregate aggregates
forall (context :: * -> *) a.
Nullifiability context -> a -> Nullify context a
Table Nullifiability Aggregate
NAggregate (exprs -> aggregates
f exprs
a)
  Fields NonNullifiability Expr
notNullifiable HNullify (Columns exprs) (Context exprs)
_ -> Nullifiability Expr
-> NonNullifiability Expr -> Nullify Aggregate aggregates
forall (context :: * -> *) a.
Nullifiability context -> NonNullifiability context -> a
absurd Nullifiability Expr
NExpr NonNullifiability Expr
notNullifiable


guard :: (Reifiable context, HTable t)
  => context tag
  -> (tag -> Bool)
  -> (Expr tag -> Expr Bool)
  -> HNullify t context
  -> HNullify t context
guard :: context tag
-> (tag -> Bool)
-> (Expr tag -> Expr Bool)
-> HNullify t context
-> HNullify t context
guard context tag
tag tag -> Bool
isNonNull Expr tag -> Expr Bool
isNonNullExpr =
  (forall a. context (Maybe a) -> context (Maybe a))
-> HNullify t context -> HNullify t context
forall (t :: HTable) (context :: * -> *).
HTable t =>
(forall a. context (Maybe a) -> context (Maybe a))
-> HNullify t context -> HNullify t context
hguard (SContext context
-> context tag
-> (tag -> Bool)
-> (Expr tag -> Expr Bool)
-> context (Maybe a)
-> context (Maybe a)
forall (context :: * -> *) tag a.
SContext context
-> context tag
-> (tag -> Bool)
-> (Expr tag -> Expr Bool)
-> context (Maybe a)
-> context (Maybe a)
guarder SContext context
forall (context :: * -> *). Reifiable context => SContext context
contextSing context tag
tag tag -> Bool
isNonNull Expr tag -> Expr Bool
isNonNullExpr)


isNull :: forall a. Table Expr a => Nullify Expr a -> Expr Bool
isNull :: Nullify Expr a -> Expr Bool
isNull =
  Expr Bool -> (Any -> Expr Bool) -> Maybe Any -> Expr Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Expr Bool
false Any -> Expr Bool
getAny (Maybe Any -> Expr Bool)
-> (Nullify Expr a -> Maybe Any) -> Nullify Expr a -> Expr Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Const (Maybe Any) (Columns a Expr) -> Maybe Any
forall a k (b :: k). Const a b -> a
getConst (Const (Maybe Any) (Columns a Expr) -> Maybe Any)
-> (Nullify Expr a -> Const (Maybe Any) (Columns a Expr))
-> Nullify Expr a
-> Maybe Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  (forall a.
 Spec a -> Expr (Nullify a) -> Const (Maybe Any) (Expr a))
-> HNullify (Columns a) Expr -> Const (Maybe Any) (Columns a Expr)
forall (t :: HTable) (m :: * -> *) (context :: * -> *).
(HTable t, Apply m) =>
(forall a. Spec a -> context (Nullify a) -> m (context a))
-> HNullify t context -> m (t context)
hunnullify (\Spec {Nullity a
nullity :: Nullity a
nullity :: forall a. Spec a -> Nullity a
nullity} Expr (Nullify a)
a -> Maybe Any -> Const (Maybe Any) (Expr a)
forall k a (b :: k). a -> Const a b
Const (Maybe Any -> Const (Maybe Any) (Expr a))
-> Maybe Any -> Const (Maybe Any) (Expr a)
forall a b. (a -> b) -> a -> b
$ case Nullity a
nullity of
    Nullity a
NotNull -> Any -> Maybe Any
forall a. a -> Maybe a
Just (Any -> Maybe Any) -> Any -> Maybe Any
forall a b. (a -> b) -> a -> b
$ Expr Bool -> Any
Any (Expr Bool -> Any) -> Expr Bool -> Any
forall a b. (a -> b) -> a -> b
$ Expr (Maybe a) -> Expr Bool
forall a. Expr (Maybe a) -> Expr Bool
Expr.isNull Expr (Maybe a)
Expr (Nullify a)
a
    Nullity a
Null -> Maybe Any
forall a. Maybe a
Nothing) (HNullify (Columns a) Expr -> Const (Maybe Any) (Columns a Expr))
-> (Nullify Expr a -> HNullify (Columns a) Expr)
-> Nullify Expr a
-> Const (Maybe Any) (Columns a Expr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Nullify Expr a -> HNullify (Columns a) Expr
forall (context :: * -> *) a.
Table context a =>
a -> Columns a context
toColumns


newtype Any = Any
  { Any -> Expr Bool
getAny :: Expr Bool
  }


instance Semigroup Any where
  Any Expr Bool
a <> :: Any -> Any -> Any
<> Any Expr Bool
b = Expr Bool -> Any
Any (Expr Bool
a Expr Bool -> Expr Bool -> Expr Bool
||. Expr Bool
b)