{-# OPTIONS_HADDOCK not-home #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE Arrows #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
module Opaleye.Internal.MaybeFields where
import Control.Arrow (returnA, (<<<), (>>>))
import qualified Opaleye.Internal.Binary as B
import qualified Opaleye.Internal.Column as IC
import qualified Opaleye.ToFields as Constant
import qualified Opaleye.Internal.HaskellDB.PrimQuery as HPQ
import Opaleye.Internal.Inferrable (Inferrable(Inferrable),
runInferrable)
import qualified Opaleye.Internal.QueryArr as IQ
import qualified Opaleye.Internal.Rebind as Rebind
import qualified Opaleye.Internal.RunQuery as RQ
import qualified Opaleye.Internal.Unpackspec as U
import qualified Opaleye.Internal.Values as V
import Opaleye.Select (Select, SelectArr)
import qualified Opaleye.Column
import qualified Opaleye.Field
import Opaleye.Field (Field)
import Opaleye.Internal.Operators ((.&&), (.||), (.==), restrict, not,
ifExplict, IfPP, EqPP(EqPP))
import qualified Opaleye.Internal.Lateral
import qualified Opaleye.SqlTypes
import Opaleye.SqlTypes (SqlBool, IsSqlType)
import Control.Monad (replicateM_)
import qualified Data.Profunctor as P
import qualified Data.Profunctor.Product as PP
import qualified Data.Profunctor.Product.Default as PP
import qualified Database.PostgreSQL.Simple.FromRow as PGSR
data MaybeFields fields =
MaybeFields {
forall fields. MaybeFields fields -> Column SqlBool
mfPresent :: Opaleye.Column.Column Opaleye.SqlTypes.SqlBool
, forall fields. MaybeFields fields -> fields
mfFields :: fields
}
deriving (forall a b. (a -> b) -> MaybeFields a -> MaybeFields b)
-> (forall a b. a -> MaybeFields b -> MaybeFields a)
-> Functor MaybeFields
forall a b. a -> MaybeFields b -> MaybeFields a
forall a b. (a -> b) -> MaybeFields a -> MaybeFields b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> MaybeFields a -> MaybeFields b
fmap :: forall a b. (a -> b) -> MaybeFields a -> MaybeFields b
$c<$ :: forall a b. a -> MaybeFields b -> MaybeFields a
<$ :: forall a b. a -> MaybeFields b -> MaybeFields a
Functor
instance Applicative MaybeFields where
pure :: forall a. a -> MaybeFields a
pure a
fields = MaybeFields { mfPresent :: Column SqlBool
mfPresent = Bool -> Field SqlBool
Opaleye.SqlTypes.sqlBool Bool
True
, mfFields :: a
mfFields = a
fields
}
MaybeFields Column SqlBool
t a -> b
f <*> :: forall a b. MaybeFields (a -> b) -> MaybeFields a -> MaybeFields b
<*> MaybeFields Column SqlBool
t' a
a =
MaybeFields {
mfPresent :: Column SqlBool
mfPresent = Column SqlBool
Field SqlBool
t Field SqlBool -> Field SqlBool -> Field SqlBool
.&& Column SqlBool
Field SqlBool
t'
, mfFields :: b
mfFields = a -> b
f a
a
}
instance Monad MaybeFields where
return :: forall a. a -> MaybeFields a
return = a -> MaybeFields a
forall a. a -> MaybeFields a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
MaybeFields Column SqlBool
t a
a >>= :: forall a b. MaybeFields a -> (a -> MaybeFields b) -> MaybeFields b
>>= a -> MaybeFields b
f = case a -> MaybeFields b
f a
a of
MaybeFields Column SqlBool
t' b
b -> Column SqlBool -> b -> MaybeFields b
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (Column SqlBool
Field SqlBool
t Field SqlBool -> Field SqlBool -> Field SqlBool
.&& Column SqlBool
Field SqlBool
t') b
b
nothingFields :: PP.Default V.Nullspec a a => MaybeFields a
nothingFields :: forall a. Default Nullspec a a => MaybeFields a
nothingFields = Nullspec a a -> MaybeFields a
forall a b. Nullspec a b -> MaybeFields b
nothingFieldsExplicit Nullspec a a
forall a. Default Nullspec a a => Nullspec a a
def
where def :: PP.Default V.Nullspec a a => V.Nullspec a a
def :: forall a. Default Nullspec a a => Nullspec a a
def = Nullspec a a
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
nothingFieldsOfTypeOf :: a -> MaybeFields a
nothingFieldsOfTypeOf :: forall a. a -> MaybeFields a
nothingFieldsOfTypeOf a
a = MaybeFields {
mfPresent :: Column SqlBool
mfPresent = Bool -> Field SqlBool
Opaleye.SqlTypes.sqlBool Bool
False
, mfFields :: a
mfFields = a
a
}
justFields :: a -> MaybeFields a
justFields :: forall a. a -> MaybeFields a
justFields = a -> MaybeFields a
forall a. a -> MaybeFields a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
maybeFields :: PP.Default IfPP b b => b -> (a -> b) -> MaybeFields a -> b
maybeFields :: forall b a. Default IfPP b b => b -> (a -> b) -> MaybeFields a -> b
maybeFields = IfPP b b -> b -> (a -> b) -> MaybeFields a -> b
forall b b' a. IfPP b b' -> b -> (a -> b) -> MaybeFields a -> b'
maybeFieldsExplicit IfPP b b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
matchMaybe :: PP.Default IfPP b b => MaybeFields a -> (Maybe a -> b) -> b
matchMaybe :: forall b a.
Default IfPP b b =>
MaybeFields a -> (Maybe a -> b) -> b
matchMaybe MaybeFields a
mf Maybe a -> b
f = b -> (a -> b) -> MaybeFields a -> b
forall b a. Default IfPP b b => b -> (a -> b) -> MaybeFields a -> b
maybeFields (Maybe a -> b
f Maybe a
forall a. Maybe a
Nothing) (Maybe a -> b
f (Maybe a -> b) -> (a -> Maybe a) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just) MaybeFields a
mf
fromMaybeFields :: PP.Default IfPP b b => b -> MaybeFields b -> b
fromMaybeFields :: forall b. Default IfPP b b => b -> MaybeFields b -> b
fromMaybeFields = IfPP b b -> b -> MaybeFields b -> b
forall b. IfPP b b -> b -> MaybeFields b -> b
fromMaybeFieldsExplicit IfPP b b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
maybeFieldsToSelect :: SelectArr (MaybeFields a) a
maybeFieldsToSelect :: forall a. SelectArr (MaybeFields a) a
maybeFieldsToSelect = proc MaybeFields a
mf -> do
SelectArr (Field SqlBool) ()
restrict -< MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
mf
SelectArr a a
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields MaybeFields a
mf
catMaybeFields :: SelectArr i (MaybeFields a) -> SelectArr i a
catMaybeFields :: forall i a. SelectArr i (MaybeFields a) -> SelectArr i a
catMaybeFields = (SelectArr i (MaybeFields a)
-> SelectArr (MaybeFields a) a -> SelectArr i a
forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> SelectArr (MaybeFields a) a
forall a. SelectArr (MaybeFields a) a
maybeFieldsToSelect)
maybeFieldsExplicit :: IfPP b b' -> b -> (a -> b) -> MaybeFields a -> b'
maybeFieldsExplicit :: forall b b' a. IfPP b b' -> b -> (a -> b) -> MaybeFields a -> b'
maybeFieldsExplicit IfPP b b'
ifpp b
b a -> b
f MaybeFields a
mf =
IfPP b b' -> Field SqlBool -> b -> b -> b'
forall columns columns'.
IfPP columns columns'
-> Field SqlBool -> columns -> columns -> columns'
ifExplict IfPP b b'
ifpp (MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
mf) (a -> b
f (MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields MaybeFields a
mf)) b
b
fromMaybeFieldsExplicit :: IfPP b b -> b -> MaybeFields b -> b
fromMaybeFieldsExplicit :: forall b. IfPP b b -> b -> MaybeFields b -> b
fromMaybeFieldsExplicit IfPP b b
ifpp = (b -> (b -> b) -> MaybeFields b -> b)
-> (b -> b) -> b -> MaybeFields b -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip (IfPP b b -> b -> (b -> b) -> MaybeFields b -> b
forall b b' a. IfPP b b' -> b -> (a -> b) -> MaybeFields a -> b'
maybeFieldsExplicit IfPP b b
ifpp) b -> b
forall a. a -> a
id
nothingFieldsExplicit :: V.Nullspec a b -> MaybeFields b
nothingFieldsExplicit :: forall a b. Nullspec a b -> MaybeFields b
nothingFieldsExplicit = b -> MaybeFields b
forall a. a -> MaybeFields a
nothingFieldsOfTypeOf (b -> MaybeFields b)
-> (Nullspec a b -> b) -> Nullspec a b -> MaybeFields b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Nullspec a b -> b
forall a fields. Nullspec a fields -> fields
V.nullFields
traverseMaybeFields :: SelectArr a b -> SelectArr (MaybeFields a) (MaybeFields b)
traverseMaybeFields :: forall a b.
SelectArr a b -> SelectArr (MaybeFields a) (MaybeFields b)
traverseMaybeFields SelectArr a b
query = proc MaybeFields a
mfInput -> do
MaybeFields b
mfOutput <- SelectArr (MaybeFields a) b
-> SelectArr (MaybeFields a) (MaybeFields b)
forall i a. SelectArr i a -> SelectArr i (MaybeFields a)
optional (SelectArr a b
query SelectArr a b
-> SelectArr (MaybeFields a) a -> SelectArr (MaybeFields a) b
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< SelectArr (MaybeFields a) a
forall a. SelectArr (MaybeFields a) a
maybeFieldsToSelect) -< MaybeFields a
mfInput
SelectArr (Field SqlBool) ()
restrict -< MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
mfInput Field SqlBool -> Field SqlBool -> Field SqlBool
`implies` MaybeFields b -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields b
mfOutput
SelectArr (MaybeFields b) (MaybeFields b)
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< Column SqlBool -> b -> MaybeFields b
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
mfInput) (MaybeFields b -> b
forall fields. MaybeFields fields -> fields
mfFields MaybeFields b
mfOutput)
where Field SqlBool
a implies :: Field SqlBool -> Field SqlBool -> Field SqlBool
`implies` Field SqlBool
b = Field SqlBool -> Field SqlBool
Opaleye.Internal.Operators.not Field SqlBool
a Field SqlBool -> Field SqlBool -> Field SqlBool
.|| Field SqlBool
b
isJustAnd ::
MaybeFields a ->
(a -> Opaleye.Field.Field SqlBool) ->
Opaleye.Field.Field SqlBool
isJustAnd :: forall a. MaybeFields a -> (a -> Field SqlBool) -> Field SqlBool
isJustAnd MaybeFields a
ma a -> Field SqlBool
cond = MaybeFields a -> (Maybe a -> Field SqlBool) -> Field SqlBool
forall b a.
Default IfPP b b =>
MaybeFields a -> (Maybe a -> b) -> b
matchMaybe MaybeFields a
ma ((Maybe a -> Field SqlBool) -> Field SqlBool)
-> (Maybe a -> Field SqlBool) -> Field SqlBool
forall a b. (a -> b) -> a -> b
$ \case
Maybe a
Nothing -> Bool -> Field SqlBool
Opaleye.SqlTypes.sqlBool Bool
False
Just a
a -> a -> Field SqlBool
cond a
a
optional :: SelectArr i a -> SelectArr i (MaybeFields a)
optional :: forall i a. SelectArr i a -> SelectArr i (MaybeFields a)
optional = (Select a -> Select (MaybeFields a))
-> SelectArr i a -> SelectArr i (MaybeFields a)
forall a b i.
(Select a -> Select b) -> SelectArr i a -> SelectArr i b
Opaleye.Internal.Lateral.laterally ((FieldNullable SqlBool -> a -> MaybeFields a)
-> Select a -> Select (MaybeFields a)
forall a r.
(FieldNullable SqlBool -> a -> r) -> Select a -> Select r
optionalInternal (Column SqlBool -> a -> MaybeFields a
Field SqlBool -> a -> MaybeFields a
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (Field SqlBool -> a -> MaybeFields a)
-> (FieldNullable SqlBool -> Field SqlBool)
-> FieldNullable SqlBool
-> a
-> MaybeFields a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldNullable SqlBool -> Field SqlBool
forall {a}. FieldNullable a -> Field SqlBool
isNotNull))
where isNotNull :: FieldNullable a -> Field SqlBool
isNotNull = Field SqlBool -> Field SqlBool
Opaleye.Internal.Operators.not (Field SqlBool -> Field SqlBool)
-> (FieldNullable a -> Field SqlBool)
-> FieldNullable a
-> Field SqlBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldNullable a -> Field SqlBool
forall {a}. FieldNullable a -> Field SqlBool
Opaleye.Field.isNull
optionalInternal :: (Opaleye.Field.FieldNullable SqlBool -> a -> r) -> Select a -> Select r
optionalInternal :: forall a r.
(FieldNullable SqlBool -> a -> r) -> Select a -> Select r
optionalInternal FieldNullable SqlBool -> a -> r
f Select a
query = State Tag (() -> (r, PrimExpr, PrimQuery)) -> QueryArr () r
forall a b.
State Tag (a -> (b, PrimExpr, PrimQuery)) -> QueryArr a b
IQ.leftJoinQueryArr' (State Tag (() -> (r, PrimExpr, PrimQuery)) -> QueryArr () r)
-> State Tag (() -> (r, PrimExpr, PrimQuery)) -> QueryArr () r
forall a b. (a -> b) -> a -> b
$ do
let true :: PrimExpr
true = Literal -> PrimExpr
HPQ.ConstExpr (Bool -> Literal
HPQ.BoolLit Bool
True)
(r
r, PrimQuery
right) <- QueryArr () r -> State Tag (r, PrimQuery)
forall a. Select a -> State Tag (a, PrimQuery)
IQ.runSimpleSelect (QueryArr () r -> State Tag (r, PrimQuery))
-> QueryArr () r -> State Tag (r, PrimQuery)
forall a b. (a -> b) -> a -> b
$ proc () -> do
a
a <- Select a
query -< ()
FieldNullable SqlBool
true_ <- SelectArr (FieldNullable SqlBool) (FieldNullable SqlBool)
forall a. Default Unpackspec a a => SelectArr a a
Rebind.rebind -< Field SqlBool -> FieldNullable SqlBool
forall a. Field a -> FieldNullable a
Opaleye.Field.toNullable (PrimExpr -> Field SqlBool
forall (n :: Nullability) sqlType. PrimExpr -> Field_ n sqlType
IC.Column PrimExpr
true)
SelectArr r r
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< FieldNullable SqlBool -> a -> r
f FieldNullable SqlBool
true_ a
a
(() -> (r, PrimExpr, PrimQuery))
-> State Tag (() -> (r, PrimExpr, PrimQuery))
forall a. a -> StateT Tag Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((() -> (r, PrimExpr, PrimQuery))
-> State Tag (() -> (r, PrimExpr, PrimQuery)))
-> (() -> (r, PrimExpr, PrimQuery))
-> State Tag (() -> (r, PrimExpr, PrimQuery))
forall a b. (a -> b) -> a -> b
$ \() -> (r
r, PrimExpr
true, PrimQuery
right)
lateralLeftJoinOptional :: SelectArr i a
-> SelectArr i b
-> ((a, b) -> Opaleye.Field.Field Opaleye.SqlTypes.SqlBool)
-> SelectArr i (a, MaybeFields b)
lateralLeftJoinOptional :: forall i a b.
SelectArr i a
-> SelectArr i b
-> ((a, b) -> Field SqlBool)
-> SelectArr i (a, MaybeFields b)
lateralLeftJoinOptional SelectArr i a
fieldsL SelectArr i b
fieldsR (a, b) -> Field SqlBool
cond = proc i
i -> do
a
fieldsL' <- SelectArr i a
fieldsL -< i
i
MaybeFields b
maybeFieldsR' <- SelectArr (a, i) b -> SelectArr (a, i) (MaybeFields b)
forall i a. SelectArr i a -> SelectArr i (MaybeFields a)
optional (proc (a
fieldsL', i
i) -> do
b
fieldsR' <- SelectArr i b
fieldsR -< i
i
SelectArr (Field SqlBool) ()
restrict -< (a, b) -> Field SqlBool
cond (a
fieldsL', b
fieldsR')
SelectArr b b
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< b
fieldsR'
) -< (a
fieldsL', i
i)
SelectArr (a, MaybeFields b) (a, MaybeFields b)
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< (a
fieldsL', MaybeFields b
maybeFieldsR')
optionalRestrictOptional :: Select a
-> SelectArr (a -> Field SqlBool) (MaybeFields a)
optionalRestrictOptional :: forall a.
Select a -> SelectArr (a -> Field SqlBool) (MaybeFields a)
optionalRestrictOptional Select a
q = SelectArr (a -> Field SqlBool) a
-> SelectArr (a -> Field SqlBool) (MaybeFields a)
forall i a. SelectArr i a -> SelectArr i (MaybeFields a)
optional (SelectArr (a -> Field SqlBool) a
-> SelectArr (a -> Field SqlBool) (MaybeFields a))
-> SelectArr (a -> Field SqlBool) a
-> SelectArr (a -> Field SqlBool) (MaybeFields a)
forall a b. (a -> b) -> a -> b
$ proc a -> Field SqlBool
cond -> do
a
a <- Select a
q -< ()
SelectArr (Field SqlBool) ()
restrict -< a -> Field SqlBool
cond a
a
SelectArr a a
forall (a :: * -> * -> *) b. Arrow a => a b b
returnA -< a
a
nullableToMaybeFields :: Opaleye.Field.FieldNullable a -> MaybeFields (Field a)
nullableToMaybeFields :: forall a. FieldNullable a -> MaybeFields (Field a)
nullableToMaybeFields FieldNullable a
x = MaybeFields
{ mfPresent :: Column SqlBool
mfPresent = Field SqlBool -> Field SqlBool
Opaleye.Internal.Operators.not (FieldNullable a -> Field SqlBool
forall {a}. FieldNullable a -> Field SqlBool
Opaleye.Field.isNull FieldNullable a
x)
, mfFields :: Field a
mfFields = FieldNullable a -> Field a
forall a. FieldNullable a -> Field a
unsafeFromNonNull FieldNullable a
x
}
where unsafeFromNonNull :: Opaleye.Field.FieldNullable a -> Field a
unsafeFromNonNull :: forall a. FieldNullable a -> Field a
unsafeFromNonNull = Field_ 'Nullable a -> Field_ 'NonNullable a
forall (n :: Nullability) a (n' :: Nullability) b.
Field_ n a -> Field_ n' b
Opaleye.Field.unsafeCoerceField
maybeFieldsToNullable :: MaybeFields (Field a) -> Opaleye.Field.FieldNullable a
maybeFieldsToNullable :: forall a. MaybeFields (Field a) -> FieldNullable a
maybeFieldsToNullable MaybeFields (Field a)
x =
Field SqlBool
-> Field_ 'Nullable a -> Field_ 'Nullable a -> Field_ 'Nullable a
forall (n' :: Nullability) pgBool (n :: Nullability) a.
Field_ n' pgBool -> Field_ n a -> Field_ n a -> Field_ n a
IC.unsafeIfThenElse (MaybeFields (Field a) -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields (Field a)
x)
(Field a -> Field_ 'Nullable a
forall a. Field a -> FieldNullable a
Opaleye.Field.toNullable (MaybeFields (Field a) -> Field a
forall fields. MaybeFields fields -> fields
mfFields MaybeFields (Field a)
x))
Field_ 'Nullable a
forall a. FieldNullable a
Opaleye.Field.null
fromFieldsMaybeFields :: RQ.FromFields fields haskells
-> RQ.FromFields (MaybeFields fields) (Maybe haskells)
fromFieldsMaybeFields :: forall fields haskells.
FromFields fields haskells
-> FromFields (MaybeFields fields) (Maybe haskells)
fromFieldsMaybeFields (RQ.FromFields Unpackspec fields ()
u fields -> RowParser haskells
p fields -> Int
c) = Unpackspec (MaybeFields fields) ()
-> (MaybeFields fields -> RowParser (Maybe haskells))
-> (MaybeFields fields -> Int)
-> FromFields (MaybeFields fields) (Maybe haskells)
forall fields haskells.
Unpackspec fields ()
-> (fields -> RowParser haskells)
-> (fields -> Int)
-> FromFields fields haskells
RQ.FromFields Unpackspec (MaybeFields fields) ()
u' MaybeFields fields -> RowParser (Maybe haskells)
p' MaybeFields fields -> Int
c'
where u' :: Unpackspec (MaybeFields fields) ()
u' = () ()
-> Unpackspec (MaybeFields fields) (MaybeFields ())
-> Unpackspec (MaybeFields fields) ()
forall a b.
a
-> Unpackspec (MaybeFields fields) b
-> Unpackspec (MaybeFields fields) a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Unpackspec (Field SqlBool) (Field SqlBool)
-> Unpackspec fields ()
-> Unpackspec (MaybeFields fields) (MaybeFields ())
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields Unpackspec (Field SqlBool) (Field SqlBool)
forall (n :: Nullability) a. Unpackspec (Field_ n a) (Field_ n a)
U.unpackspecField Unpackspec fields ()
u
p' :: MaybeFields fields -> RowParser (Maybe haskells)
p' = \MaybeFields fields
mf -> do
Bool
hIsPresent <- RowParser Bool
forall a. FromField a => RowParser a
PGSR.field
case Bool
hIsPresent of
Bool
True -> haskells -> Maybe haskells
forall a. a -> Maybe a
Just (haskells -> Maybe haskells)
-> RowParser haskells -> RowParser (Maybe haskells)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> fields -> RowParser haskells
p (MaybeFields fields -> fields
forall fields. MaybeFields fields -> fields
mfFields MaybeFields fields
mf)
Bool
False -> Maybe haskells
forall a. Maybe a
Nothing Maybe haskells -> RowParser () -> RowParser (Maybe haskells)
forall a b. a -> RowParser b -> RowParser a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> RowParser () -> RowParser ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ (fields -> Int
c (MaybeFields fields -> fields
forall fields. MaybeFields fields -> fields
mfFields MaybeFields fields
mf))
(FieldParser () -> RowParser ()
forall a. FieldParser a -> RowParser a
PGSR.fieldWith (\Field
_ Maybe ByteString
_ -> () -> Conversion ()
forall a. a -> Conversion a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()))
c' :: MaybeFields fields -> Int
c' = \MaybeFields fields
mf -> fields -> Int
c (MaybeFields fields -> fields
forall fields. MaybeFields fields -> fields
mfFields MaybeFields fields
mf) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
productProfunctorMaybeFields :: PP.ProductProfunctor p
=> p (Field SqlBool) (Field SqlBool)
-> p a b
-> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields :: forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields p (Field SqlBool) (Field SqlBool)
b p a b
p = Column SqlBool -> b -> MaybeFields b
Field SqlBool -> b -> MaybeFields b
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (Field SqlBool -> b -> MaybeFields b)
-> p (MaybeFields a) (Field SqlBool)
-> p (MaybeFields a) (b -> MaybeFields b)
forall (p :: * -> * -> *) b c a.
Profunctor p =>
(b -> c) -> p a b -> p a c
PP.***$ (MaybeFields a -> Field SqlBool)
-> p (Field SqlBool) (Field SqlBool)
-> p (MaybeFields a) (Field SqlBool)
forall a b c. (a -> b) -> p b c -> p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap MaybeFields a -> Column SqlBool
MaybeFields a -> Field SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent p (Field SqlBool) (Field SqlBool)
b
p (MaybeFields a) (b -> MaybeFields b)
-> p (MaybeFields a) b -> p (MaybeFields a) (MaybeFields b)
forall a b c. p a (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) a b c.
ProductProfunctor p =>
p a (b -> c) -> p a b -> p a c
PP.**** (MaybeFields a -> a) -> p a b -> p (MaybeFields a) b
forall a b c. (a -> b) -> p b c -> p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields p a b
p
nullspecMaybeFields :: V.Nullspec a b
-> V.Nullspec (MaybeFields a) (MaybeFields b)
nullspecMaybeFields :: forall a b.
Nullspec a b -> Nullspec (MaybeFields a) (MaybeFields b)
nullspecMaybeFields = Nullspec (Field SqlBool) (Field SqlBool)
-> Nullspec a b -> Nullspec (MaybeFields a) (MaybeFields b)
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields Nullspec (Field SqlBool) (Field SqlBool)
forall a (n :: Nullability) sqlType.
IsSqlType sqlType =>
Nullspec a (Field_ n sqlType)
V.nullspecField
unpackspecMaybeFields :: U.Unpackspec a b
-> U.Unpackspec (MaybeFields a) (MaybeFields b)
unpackspecMaybeFields :: forall a b.
Unpackspec a b -> Unpackspec (MaybeFields a) (MaybeFields b)
unpackspecMaybeFields = Unpackspec (Field SqlBool) (Field SqlBool)
-> Unpackspec a b -> Unpackspec (MaybeFields a) (MaybeFields b)
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields Unpackspec (Field SqlBool) (Field SqlBool)
forall (n :: Nullability) a. Unpackspec (Field_ n a) (Field_ n a)
U.unpackspecField
valuesspecMaybeFields :: V.Valuesspec a b
-> V.Valuesspec (MaybeFields a) (MaybeFields b)
valuesspecMaybeFields :: forall a b.
Valuesspec a b -> Valuesspec (MaybeFields a) (MaybeFields b)
valuesspecMaybeFields = Valuesspec (Field SqlBool) (Field SqlBool)
-> Valuesspec a b -> Valuesspec (MaybeFields a) (MaybeFields b)
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields Valuesspec (Field SqlBool) (Field SqlBool)
forall a (n :: Nullability).
IsSqlType a =>
Valuesspec (Field_ n a) (Field_ n a)
V.valuesspecField
toFieldsMaybeFields :: V.Nullspec a b
-> Constant.ToFields a b
-> Constant.ToFields (Maybe a) (MaybeFields b)
toFieldsMaybeFields :: forall a b.
Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)
toFieldsMaybeFields Nullspec a b
n ToFields a b
p = (Maybe a -> MaybeFields b) -> ToFields (Maybe a) (MaybeFields b)
forall haskells fields.
(haskells -> fields) -> ToFields haskells fields
Constant.toToFields ((Maybe a -> MaybeFields b) -> ToFields (Maybe a) (MaybeFields b))
-> (Maybe a -> MaybeFields b) -> ToFields (Maybe a) (MaybeFields b)
forall a b. (a -> b) -> a -> b
$ \case
Maybe a
Nothing -> Nullspec a b -> MaybeFields b
forall a b. Nullspec a b -> MaybeFields b
nothingFieldsExplicit Nullspec a b
n
Just a
a -> b -> MaybeFields b
forall a. a -> MaybeFields a
justFields (ToFields a b -> a -> b
forall haskells fields.
ToFields haskells fields -> haskells -> fields
Constant.toFieldsExplicit ToFields a b
p a
a)
ifPPMaybeFields :: IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)
ifPPMaybeFields :: forall a b. IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)
ifPPMaybeFields = IfPP (Field SqlBool) (Field SqlBool)
-> IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> p a b -> p (MaybeFields a) (MaybeFields b)
productProfunctorMaybeFields IfPP (Field SqlBool) (Field SqlBool)
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
eqPPMaybeFields :: EqPP a b -> EqPP (MaybeFields a) (MaybeFields b)
eqPPMaybeFields :: forall a b. EqPP a b -> EqPP (MaybeFields a) (MaybeFields b)
eqPPMaybeFields (EqPP a -> a -> Field SqlBool
eqFields) = (MaybeFields a -> MaybeFields a -> Field SqlBool)
-> EqPP (MaybeFields a) (MaybeFields b)
forall a b. (a -> a -> Field SqlBool) -> EqPP a b
EqPP (\MaybeFields a
m1 MaybeFields a
m2 ->
(MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
m1 Field SqlBool -> Field SqlBool -> Field SqlBool
forall columns.
Default EqPP columns columns =>
columns -> columns -> Field SqlBool
.== MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
m2)
Field SqlBool -> Field SqlBool -> Field SqlBool
.&& (MaybeFields a -> Column SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent MaybeFields a
m1 Field SqlBool -> Field SqlBool -> Field SqlBool
`implies` a -> a -> Field SqlBool
eqFields (MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields MaybeFields a
m1) (MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields MaybeFields a
m2)))
where Field SqlBool
a implies :: Field SqlBool -> Field SqlBool -> Field SqlBool
`implies` Field SqlBool
b = Field SqlBool -> Field SqlBool
Opaleye.Internal.Operators.not Field SqlBool
a Field SqlBool -> Field SqlBool -> Field SqlBool
.|| Field SqlBool
b
unWithNulls :: PP.ProductProfunctor p
=> p (Field SqlBool) (Field SqlBool)
-> WithNulls p a b
-> p (MaybeFields a) (MaybeFields b)
unWithNulls :: forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> WithNulls p a b -> p (MaybeFields a) (MaybeFields b)
unWithNulls p (Field SqlBool) (Field SqlBool)
b (WithNulls p (MaybeFields a) b
d) =
Column SqlBool -> b -> MaybeFields b
Field SqlBool -> b -> MaybeFields b
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (Field SqlBool -> b -> MaybeFields b)
-> p (MaybeFields a) (Field SqlBool)
-> p (MaybeFields a) (b -> MaybeFields b)
forall (p :: * -> * -> *) b c a.
Profunctor p =>
(b -> c) -> p a b -> p a c
PP.***$ (MaybeFields a -> Field SqlBool)
-> p (Field SqlBool) (Field SqlBool)
-> p (MaybeFields a) (Field SqlBool)
forall a b c. (a -> b) -> p b c -> p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap MaybeFields a -> Column SqlBool
MaybeFields a -> Field SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent p (Field SqlBool) (Field SqlBool)
b
p (MaybeFields a) (b -> MaybeFields b)
-> p (MaybeFields a) b -> p (MaybeFields a) (MaybeFields b)
forall a b c. p a (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) a b c.
ProductProfunctor p =>
p a (b -> c) -> p a b -> p a c
PP.**** p (MaybeFields a) b
d
newtype WithNulls p a b =
WithNulls (p (MaybeFields a) b)
mapMaybeFieldsWithNulls :: PP.ProductProfunctor p
=> p (Field SqlBool) (Field SqlBool)
-> WithNulls p a b
-> WithNulls p (MaybeFields a) (MaybeFields b)
mapMaybeFieldsWithNulls :: forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> WithNulls p a b -> WithNulls p (MaybeFields a) (MaybeFields b)
mapMaybeFieldsWithNulls p (Field SqlBool) (Field SqlBool)
b WithNulls p a b
d =
Column SqlBool -> b -> MaybeFields b
Field SqlBool -> b -> MaybeFields b
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields (Field SqlBool -> b -> MaybeFields b)
-> WithNulls p (MaybeFields a) (Field SqlBool)
-> WithNulls p (MaybeFields a) (b -> MaybeFields b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (MaybeFields a -> Field SqlBool)
-> WithNulls p (Field SqlBool) (Field SqlBool)
-> WithNulls p (MaybeFields a) (Field SqlBool)
forall a b c. (a -> b) -> WithNulls p b c -> WithNulls p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap MaybeFields a -> Column SqlBool
MaybeFields a -> Field SqlBool
forall fields. MaybeFields fields -> Column SqlBool
mfPresent (p (Field SqlBool) (Field SqlBool)
-> WithNulls p (Field SqlBool) (Field SqlBool)
forall a (p :: * -> * -> *) (n :: Nullability).
(IsSqlType a, Profunctor p) =>
p (Field_ n a) (Field_ n a)
-> WithNulls p (Field_ n a) (Field_ n a)
withNullsField p (Field SqlBool) (Field SqlBool)
b)
WithNulls p (MaybeFields a) (b -> MaybeFields b)
-> WithNulls p (MaybeFields a) b
-> WithNulls p (MaybeFields a) (MaybeFields b)
forall a b.
WithNulls p (MaybeFields a) (a -> b)
-> WithNulls p (MaybeFields a) a -> WithNulls p (MaybeFields a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (MaybeFields a -> a)
-> WithNulls p a b -> WithNulls p (MaybeFields a) b
forall a b c. (a -> b) -> WithNulls p b c -> WithNulls p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap MaybeFields a -> a
forall fields. MaybeFields fields -> fields
mfFields WithNulls p a b
d
withNullsField :: (IsSqlType a, P.Profunctor p)
=> p (IC.Field_ n a) (IC.Field_ n a)
-> WithNulls p (IC.Field_ n a) (IC.Field_ n a)
withNullsField :: forall a (p :: * -> * -> *) (n :: Nullability).
(IsSqlType a, Profunctor p) =>
p (Field_ n a) (Field_ n a)
-> WithNulls p (Field_ n a) (Field_ n a)
withNullsField p (Field_ n a) (Field_ n a)
col = WithNulls p (Field_ n a) (Field_ n a)
result
where result :: WithNulls p (Field_ n a) (Field_ n a)
result = p (MaybeFields (Field_ n a)) (Field_ n a)
-> WithNulls p (Field_ n a) (Field_ n a)
forall (p :: * -> * -> *) a b.
p (MaybeFields a) b -> WithNulls p a b
WithNulls ((MaybeFields (Field_ n a) -> Field_ n a)
-> p (Field_ n a) (Field_ n a)
-> p (MaybeFields (Field_ n a)) (Field_ n a)
forall a b c. (a -> b) -> p b c -> p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap (\(MaybeFields Column SqlBool
b Field_ n a
c) ->
IfPP (Field_ n a) (Field_ n a)
-> Field SqlBool -> Field_ n a -> Field_ n a -> Field_ n a
forall columns columns'.
IfPP columns columns'
-> Field SqlBool -> columns -> columns -> columns'
ifExplict IfPP (Field_ n a) (Field_ n a)
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def Column SqlBool
Field SqlBool
b Field_ n a
c Field_ n a
forall {n :: Nullability}. Field_ n a
nullC) p (Field_ n a) (Field_ n a)
col)
nullC :: Field_ n a
nullC = Nullspec Any (Field_ n a) -> Field_ n a
forall a fields. Nullspec a fields -> fields
V.nullFields Nullspec Any (Field_ n a)
forall a (n :: Nullability) sqlType.
IsSqlType sqlType =>
Nullspec a (Field_ n sqlType)
V.nullspecField
binaryspecMaybeFields
:: WithNulls B.Binaryspec a b
-> B.Binaryspec (MaybeFields a) (MaybeFields b)
binaryspecMaybeFields :: forall a b.
WithNulls Binaryspec a b
-> Binaryspec (MaybeFields a) (MaybeFields b)
binaryspecMaybeFields = Binaryspec (Field SqlBool) (Field SqlBool)
-> WithNulls Binaryspec a b
-> Binaryspec (MaybeFields a) (MaybeFields b)
forall (p :: * -> * -> *) a b.
ProductProfunctor p =>
p (Field SqlBool) (Field SqlBool)
-> WithNulls p a b -> p (MaybeFields a) (MaybeFields b)
unWithNulls Binaryspec (Field SqlBool) (Field SqlBool)
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance P.Profunctor p => P.Profunctor (WithNulls p) where
dimap :: forall a b c d.
(a -> b) -> (c -> d) -> WithNulls p b c -> WithNulls p a d
dimap a -> b
f c -> d
g (WithNulls p (MaybeFields b) c
d) = p (MaybeFields a) d -> WithNulls p a d
forall (p :: * -> * -> *) a b.
p (MaybeFields a) b -> WithNulls p a b
WithNulls ((MaybeFields a -> MaybeFields b)
-> (c -> d) -> p (MaybeFields b) c -> p (MaybeFields a) d
forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
P.dimap ((a -> b) -> MaybeFields a -> MaybeFields b
forall a b. (a -> b) -> MaybeFields a -> MaybeFields b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) c -> d
g p (MaybeFields b) c
d)
instance P.Profunctor p => Functor (WithNulls p a) where
fmap :: forall a b. (a -> b) -> WithNulls p a a -> WithNulls p a b
fmap = (a -> b) -> WithNulls p a a -> WithNulls p a b
forall b c a. (b -> c) -> WithNulls p a b -> WithNulls p a c
forall (p :: * -> * -> *) b c a.
Profunctor p =>
(b -> c) -> p a b -> p a c
P.rmap
instance PP.ProductProfunctor p => Applicative (WithNulls p a) where
pure :: forall a. a -> WithNulls p a a
pure = p (MaybeFields a) a -> WithNulls p a a
forall (p :: * -> * -> *) a b.
p (MaybeFields a) b -> WithNulls p a b
WithNulls (p (MaybeFields a) a -> WithNulls p a a)
-> (a -> p (MaybeFields a) a) -> a -> WithNulls p a a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> p (MaybeFields a) a
forall b a. b -> p a b
forall (p :: * -> * -> *) b a. ProductProfunctor p => b -> p a b
PP.purePP
WithNulls p (MaybeFields a) (a -> b)
fd <*> :: forall a b.
WithNulls p a (a -> b) -> WithNulls p a a -> WithNulls p a b
<*> WithNulls p (MaybeFields a) a
xd = p (MaybeFields a) b -> WithNulls p a b
forall (p :: * -> * -> *) a b.
p (MaybeFields a) b -> WithNulls p a b
WithNulls (p (MaybeFields a) (a -> b)
fd p (MaybeFields a) (a -> b)
-> p (MaybeFields a) a -> p (MaybeFields a) b
forall a b c. p a (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) a b c.
ProductProfunctor p =>
p a (b -> c) -> p a b -> p a c
PP.**** p (MaybeFields a) a
xd)
instance PP.ProductProfunctor p => PP.ProductProfunctor (WithNulls p) where
purePP :: forall b a. b -> WithNulls p a b
purePP = b -> WithNulls p a b
forall a. a -> WithNulls p a a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
**** :: forall a b c.
WithNulls p a (b -> c) -> WithNulls p a b -> WithNulls p a c
(****) = WithNulls p a (b -> c) -> WithNulls p a b -> WithNulls p a c
forall a b.
WithNulls p a (a -> b) -> WithNulls p a a -> WithNulls p a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>)
instance PP.SumProfunctor p => PP.SumProfunctor (WithNulls p) where
WithNulls p (MaybeFields a) b
ff +++! :: forall a b a' b'.
WithNulls p a b
-> WithNulls p a' b' -> WithNulls p (Either a a') (Either b b')
+++! WithNulls p (MaybeFields a') b'
xf =
p (MaybeFields (Either a a')) (Either b b')
-> WithNulls p (Either a a') (Either b b')
forall (p :: * -> * -> *) a b.
p (MaybeFields a) b -> WithNulls p a b
WithNulls (((MaybeFields (Either a a')
-> Either (MaybeFields a) (MaybeFields a'))
-> p (Either (MaybeFields a) (MaybeFields a')) (Either b b')
-> p (MaybeFields (Either a a')) (Either b b'))
-> p (Either (MaybeFields a) (MaybeFields a')) (Either b b')
-> (MaybeFields (Either a a')
-> Either (MaybeFields a) (MaybeFields a'))
-> p (MaybeFields (Either a a')) (Either b b')
forall a b c. (a -> b -> c) -> b -> a -> c
flip (MaybeFields (Either a a')
-> Either (MaybeFields a) (MaybeFields a'))
-> p (Either (MaybeFields a) (MaybeFields a')) (Either b b')
-> p (MaybeFields (Either a a')) (Either b b')
forall a b c. (a -> b) -> p b c -> p a c
forall (p :: * -> * -> *) a b c.
Profunctor p =>
(a -> b) -> p b c -> p a c
P.lmap (p (MaybeFields a) b
ff p (MaybeFields a) b
-> p (MaybeFields a') b'
-> p (Either (MaybeFields a) (MaybeFields a')) (Either b b')
forall a b a' b'. p a b -> p a' b' -> p (Either a a') (Either b b')
forall (p :: * -> * -> *) a b a' b'.
SumProfunctor p =>
p a b -> p a' b' -> p (Either a a') (Either b b')
PP.+++! p (MaybeFields a') b'
xf) ((MaybeFields (Either a a')
-> Either (MaybeFields a) (MaybeFields a'))
-> p (MaybeFields (Either a a')) (Either b b'))
-> (MaybeFields (Either a a')
-> Either (MaybeFields a) (MaybeFields a'))
-> p (MaybeFields (Either a a')) (Either b b')
forall a b. (a -> b) -> a -> b
$ \case
MaybeFields Column SqlBool
b (Left a
l) -> MaybeFields a -> Either (MaybeFields a) (MaybeFields a')
forall a b. a -> Either a b
Left (Column SqlBool -> a -> MaybeFields a
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields Column SqlBool
b a
l)
MaybeFields Column SqlBool
b (Right a'
r) -> MaybeFields a' -> Either (MaybeFields a) (MaybeFields a')
forall a b. b -> Either a b
Right (Column SqlBool -> a' -> MaybeFields a'
forall fields. Column SqlBool -> fields -> MaybeFields fields
MaybeFields Column SqlBool
b a'
r))
instance PP.Default RQ.FromFields fields haskells
=> PP.Default RQ.FromFields (MaybeFields fields) (Maybe haskells) where
def :: FromFields (MaybeFields fields) (Maybe haskells)
def = FromFields fields haskells
-> FromFields (MaybeFields fields) (Maybe haskells)
forall fields haskells.
FromFields fields haskells
-> FromFields (MaybeFields fields) (Maybe haskells)
fromFieldsMaybeFields FromFields fields haskells
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance PP.Default U.Unpackspec a b
=> PP.Default U.Unpackspec (MaybeFields a) (MaybeFields b) where
def :: Unpackspec (MaybeFields a) (MaybeFields b)
def = Unpackspec a b -> Unpackspec (MaybeFields a) (MaybeFields b)
forall a b.
Unpackspec a b -> Unpackspec (MaybeFields a) (MaybeFields b)
unpackspecMaybeFields Unpackspec a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance PP.Default V.Valuesspec a b
=> PP.Default V.Valuesspec (MaybeFields a) (MaybeFields b) where
def :: Valuesspec (MaybeFields a) (MaybeFields b)
def = Valuesspec a b -> Valuesspec (MaybeFields a) (MaybeFields b)
forall a b.
Valuesspec a b -> Valuesspec (MaybeFields a) (MaybeFields b)
valuesspecMaybeFields Valuesspec a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance (PP.Default Constant.ToFields a b, PP.Default V.Nullspec a b)
=> PP.Default Constant.ToFields (Maybe a) (MaybeFields b) where
def :: ToFields (Maybe a) (MaybeFields b)
def = Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)
forall a b.
Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)
toFieldsMaybeFields Nullspec a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def ToFields a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance PP.Default IfPP a b
=> PP.Default IfPP (MaybeFields a) (MaybeFields b) where
def :: IfPP (MaybeFields a) (MaybeFields b)
def = IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)
forall a b. IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)
ifPPMaybeFields IfPP a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance PP.Default EqPP a b
=> PP.Default EqPP (MaybeFields a) (MaybeFields b) where
def :: EqPP (MaybeFields a) (MaybeFields b)
def = EqPP a b -> EqPP (MaybeFields a) (MaybeFields b)
forall a b. EqPP a b -> EqPP (MaybeFields a) (MaybeFields b)
eqPPMaybeFields EqPP a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance (P.Profunctor p, IsSqlType a, PP.Default p (IC.Field_ n a) (IC.Field_ n a))
=> PP.Default (WithNulls p) (IC.Field_ n a) (IC.Field_ n a) where
def :: WithNulls p (Field_ n a) (Field_ n a)
def = p (Field_ n a) (Field_ n a)
-> WithNulls p (Field_ n a) (Field_ n a)
forall a (p :: * -> * -> *) (n :: Nullability).
(IsSqlType a, Profunctor p) =>
p (Field_ n a) (Field_ n a)
-> WithNulls p (Field_ n a) (Field_ n a)
withNullsField p (Field_ n a) (Field_ n a)
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance PP.Default (WithNulls B.Binaryspec) a b
=> PP.Default B.Binaryspec (MaybeFields a) (MaybeFields b) where
def :: Binaryspec (MaybeFields a) (MaybeFields b)
def = WithNulls Binaryspec a b
-> Binaryspec (MaybeFields a) (MaybeFields b)
forall a b.
WithNulls Binaryspec a b
-> Binaryspec (MaybeFields a) (MaybeFields b)
binaryspecMaybeFields WithNulls Binaryspec a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def
instance (PP.Default (Inferrable RQ.FromFields) fields haskells,
Maybe haskells ~ maybe_haskells)
=> PP.Default (Inferrable RQ.FromFields) (MaybeFields fields) maybe_haskells where
def :: Inferrable FromFields (MaybeFields fields) maybe_haskells
def = FromFields (MaybeFields fields) maybe_haskells
-> Inferrable FromFields (MaybeFields fields) maybe_haskells
forall (p :: * -> * -> *) a b. p a b -> Inferrable p a b
Inferrable (FromFields fields haskells
-> FromFields (MaybeFields fields) (Maybe haskells)
forall fields haskells.
FromFields fields haskells
-> FromFields (MaybeFields fields) (Maybe haskells)
fromFieldsMaybeFields (Inferrable FromFields fields haskells -> FromFields fields haskells
forall (p :: * -> * -> *) a b. Inferrable p a b -> p a b
runInferrable Inferrable FromFields fields haskells
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def))
instance (PP.Default (Inferrable Constant.ToFields) a b, PP.Default V.Nullspec a b,
MaybeFields b ~ maybeFields_b)
=> PP.Default (Inferrable Constant.ToFields) (Maybe a) maybeFields_b where
def :: Inferrable ToFields (Maybe a) maybeFields_b
def = ToFields (Maybe a) maybeFields_b
-> Inferrable ToFields (Maybe a) maybeFields_b
forall (p :: * -> * -> *) a b. p a b -> Inferrable p a b
Inferrable (Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)
forall a b.
Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)
toFieldsMaybeFields Nullspec a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def (Inferrable ToFields a b -> ToFields a b
forall (p :: * -> * -> *) a b. Inferrable p a b -> p a b
runInferrable Inferrable ToFields a b
forall (p :: * -> * -> *) a b. Default p a b => p a b
PP.def))