module Opaleye.SQLite.Operators (module Opaleye.SQLite.Operators) where

import qualified Data.Foldable as F

import           Opaleye.SQLite.Internal.Column (Column(Column), unsafeCase_,
                                          unsafeIfThenElse, unsafeGt, unsafeEq)
import qualified Opaleye.SQLite.Internal.Column as C
import           Opaleye.SQLite.Internal.QueryArr (QueryArr(QueryArr))
import qualified Opaleye.SQLite.Internal.PrimQuery as PQ
import qualified Opaleye.SQLite.Order as Ord
import qualified Opaleye.SQLite.PGTypes as T

import qualified Opaleye.SQLite.Internal.HaskellDB.PrimQuery as HPQ

{-| Restrict query results to a particular condition.  Corresponds to
    the guard method of the MonadPlus class.
-}
restrict :: QueryArr (Column T.PGBool) ()
restrict :: QueryArr (Column PGBool) ()
restrict = ((Column PGBool, PrimQuery, Tag) -> ((), PrimQuery, Tag))
-> QueryArr (Column PGBool) ()
forall a b.
((a, PrimQuery, Tag) -> (b, PrimQuery, Tag)) -> QueryArr a b
QueryArr (Column PGBool, PrimQuery, Tag) -> ((), PrimQuery, Tag)
forall a c. (Column a, PrimQuery, c) -> ((), PrimQuery, c)
f where
  f :: (Column a, PrimQuery, c) -> ((), PrimQuery, c)
f (Column PrimExpr
predicate, PrimQuery
primQ, c
t0) = ((), PrimExpr -> PrimQuery -> PrimQuery
PQ.restrict PrimExpr
predicate PrimQuery
primQ, c
t0)

doubleOfInt :: Column T.PGInt4 -> Column T.PGFloat8
doubleOfInt :: Column PGInt4 -> Column PGFloat8
doubleOfInt (Column PrimExpr
e) = PrimExpr -> Column PGFloat8
forall a. PrimExpr -> Column a
Column (Name -> PrimExpr -> PrimExpr
HPQ.CastExpr Name
"float8" PrimExpr
e)

infix 4 .==
(.==) :: Column a -> Column a -> Column T.PGBool
.== :: Column a -> Column a -> Column PGBool
(.==) = Column a -> Column a -> Column PGBool
forall a pgBool. Column a -> Column a -> Column pgBool
unsafeEq

infix 4 ./=
(./=) :: Column a -> Column a -> Column T.PGBool
./= :: Column a -> Column a -> Column PGBool
(./=) = BinOp -> Column a -> Column a -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpNotEq

infix 4 .>
(.>) :: Ord.PGOrd a => Column a -> Column a -> Column T.PGBool
.> :: Column a -> Column a -> Column PGBool
(.>) = Column a -> Column a -> Column PGBool
forall a pgBool. Column a -> Column a -> Column pgBool
unsafeGt

infix 4 .<
(.<) :: Ord.PGOrd a => Column a -> Column a -> Column T.PGBool
.< :: Column a -> Column a -> Column PGBool
(.<) = BinOp -> Column a -> Column a -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpLt

infix 4 .<=
(.<=) :: Ord.PGOrd a => Column a -> Column a -> Column T.PGBool
.<= :: Column a -> Column a -> Column PGBool
(.<=) = BinOp -> Column a -> Column a -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpLtEq

infix 4 .>=
(.>=) :: Ord.PGOrd a => Column a -> Column a -> Column T.PGBool
.>= :: Column a -> Column a -> Column PGBool
(.>=) = BinOp -> Column a -> Column a -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpGtEq

case_ :: [(Column T.PGBool, Column a)] -> Column a -> Column a
case_ :: [(Column PGBool, Column a)] -> Column a -> Column a
case_ = [(Column PGBool, Column a)] -> Column a -> Column a
forall pgBool a.
[(Column pgBool, Column a)] -> Column a -> Column a
unsafeCase_

ifThenElse :: Column T.PGBool -> Column a -> Column a -> Column a
ifThenElse :: Column PGBool -> Column a -> Column a -> Column a
ifThenElse = Column PGBool -> Column a -> Column a -> Column a
forall pgBool a. Column pgBool -> Column a -> Column a -> Column a
unsafeIfThenElse

infixr 3 .&&
(.&&) :: Column T.PGBool -> Column T.PGBool -> Column T.PGBool
.&& :: Column PGBool -> Column PGBool -> Column PGBool
(.&&) = BinOp -> Column PGBool -> Column PGBool -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpAnd

infixr 2 .||
(.||) :: Column T.PGBool -> Column T.PGBool -> Column T.PGBool
.|| :: Column PGBool -> Column PGBool -> Column PGBool
(.||) = BinOp -> Column PGBool -> Column PGBool -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpOr

not :: Column T.PGBool -> Column T.PGBool
not :: Column PGBool -> Column PGBool
not = UnOp -> Column PGBool -> Column PGBool
forall a b. UnOp -> Column a -> Column b
C.unOp UnOp
HPQ.OpNot

(.++) :: Column T.PGText -> Column T.PGText -> Column T.PGText
.++ :: Column PGText -> Column PGText -> Column PGText
(.++) = BinOp -> Column PGText -> Column PGText -> Column PGText
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpCat

lower :: Column T.PGText -> Column T.PGText
lower :: Column PGText -> Column PGText
lower = UnOp -> Column PGText -> Column PGText
forall a b. UnOp -> Column a -> Column b
C.unOp UnOp
HPQ.OpLower

upper :: Column T.PGText -> Column T.PGText
upper :: Column PGText -> Column PGText
upper = UnOp -> Column PGText -> Column PGText
forall a b. UnOp -> Column a -> Column b
C.unOp UnOp
HPQ.OpUpper

like :: Column T.PGText -> Column T.PGText -> Column T.PGBool
like :: Column PGText -> Column PGText -> Column PGBool
like = BinOp -> Column PGText -> Column PGText -> Column PGBool
forall a b c. BinOp -> Column a -> Column b -> Column c
C.binOp BinOp
HPQ.OpLike

ors :: F.Foldable f => f (Column T.PGBool) -> Column T.PGBool
ors :: f (Column PGBool) -> Column PGBool
ors = (Column PGBool -> Column PGBool -> Column PGBool)
-> Column PGBool -> f (Column PGBool) -> Column PGBool
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' Column PGBool -> Column PGBool -> Column PGBool
(.||) (Bool -> Column PGBool
T.pgBool Bool
False)

in_ :: (Functor f, F.Foldable f) => f (Column a) -> Column a -> Column T.PGBool
in_ :: f (Column a) -> Column a -> Column PGBool
in_ f (Column a)
hs Column a
w = f (Column PGBool) -> Column PGBool
forall (f :: * -> *).
Foldable f =>
f (Column PGBool) -> Column PGBool
ors (f (Column PGBool) -> Column PGBool)
-> (f (Column a) -> f (Column PGBool))
-> f (Column a)
-> Column PGBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Column a -> Column PGBool) -> f (Column a) -> f (Column PGBool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Column a
w Column a -> Column a -> Column PGBool
forall a. Column a -> Column a -> Column PGBool
.==) (f (Column a) -> Column PGBool) -> f (Column a) -> Column PGBool
forall a b. (a -> b) -> a -> b
$ f (Column a)
hs